Squashed 'src/secp256k1/' changes from 22f60a6..2bfb82b
2bfb82b Merge pull request #351 06aeea5 Turn secp256k1_ec_pubkey_serialize outlen to in/out 970164d Merge pull request #348 6466625 Improvements for coordinate decompression e2100ad Merge pull request #347 8e48787 Change secp256k1_ec_pubkey_combine's count argument to size_t. c69dea0 Clear output in more cases for pubkey_combine, adds tests. 269d422 Comment copyediting. b4d17da Merge pull request #344 4709265 Merge pull request #345 26abce7 Adds 32 static test vectors for scalar mul, sqr, inv. 5b71a3f Better error case handling for pubkey_create & pubkey_serialize, more tests. 3b7bc69 Merge pull request #343 eed87af Change contrib/laxder from headers-only to files compilable as standalone C d7eb1ae Merge pull request #342 7914a6e Make lax_der_privatekey_parsing.h not depend on internal code 73f64ff Merge pull request #339 9234391 Overhaul flags handling 1a36898 Make flags more explicit, add runtime checks. 1a3e03a Merge pull request #340 96be204 Add additional tests for eckey and arg-checks. bb5aa4d Make the tweak function zeroize-output-on-fail behavior consistent. 4a243da Move secp256k1_ec_privkey_import/export to contrib. 1b3efc1 Move secp256k1_ecdsa_sig_recover into the recovery module. e3cd679 Eliminate all side-effects from VERIFY_CHECK() usage. b30fc85 Avoid nonce_function_rfc6979 algo16 argument emulation. 70d4640 Make secp256k1_ec_pubkey_create skip processing invalid secret keys. 6c476a8 Minor comment improvements. 131afe5 Merge pull request #334 0c6ab2f Introduce explicit lower-S normalization fea19e7 Add contrib/lax_der_parsing.h 3bb9c44 Rewrite ECDSA signature parsing code fa57f1b Use secp256k1_rand_int and secp256k1_rand_bits more 49b3749 Add new tests for the extra testrand functions f684d7d Faster secp256k1_rand_int implementation 251b1a6 Improve testrand: add extra random functions 31994c8 Merge pull request #338 f79aa88 Bugfix: swap arguments to noncefp c98df26 Merge pull request #319 67f7da4 Extensive interface and operations tests for secp256k1_ec_pubkey_parse. ee2cb40 Add ARG_CHECKs to secp256k1_ec_pubkey_parse/secp256k1_ec_pubkey_serialize 7450ef1 Merge pull request #328 68a3c76 Merge pull request #329 98135ee Merge pull request #332 37100d7 improve ECDH header-doc b13d749 Fix couple of typos in API comments 7c823e3 travis: fixup module configs cc3141a Merge pull request #325 ee58fae Merge pull request #326 213aa67 Do not force benchmarks to be statically linked. 338fc8b Add API exports to secp256k1_nonce_function_default and secp256k1_nonce_function_rfc6979. 52fd03f Merge pull request #320 9f6993f Remove some dead code. 357f8cd Merge pull request #314 118cd82 Use explicit symbol visibility. 4e64608 Include public module headers when compiling modules. 1f41437 Merge pull request #316 fe0d463 Merge pull request #317 cfe0ed9 Fix miscellaneous style nits that irritate overactive static analysis. 2b199de Use the explicit NULL macro for pointer comparisons. 9e90516 Merge pull request #294 dd891e0 Get rid of _t as it is POSIX reserved 201819b Merge pull request #313 912f203 Eliminate a few unbraced statements that crept into the code. eeab823 Merge pull request #299 486b9bb Use a flags bitfield for compressed option to secp256k1_ec_pubkey_serialize and secp256k1_ec_privkey_export 05732c5 Callback data: Accept pointers to either const or non-const data 1973c73 Bugfix: Reinitialise buffer lengths that have been used as outputs 788038d Use size_t for lengths (at least in external API) c9d7c2a secp256k1_context_set_{error,illegal}_callback: Restore default handler by passing NULL as function argument 9aac008 secp256k1_context_destroy: Allow NULL argument as a no-op 64b730b secp256k1_context_create: Use unsigned type for flags bitfield cb04ab5 Merge pull request #309 a551669 Merge pull request #295 81e45ff Update group_impl.h 85e3a2c Merge pull request #112 b2eb63b Merge pull request #293 dc0ce9f [API BREAK] Change argument order to out/outin/in 6d947ca Merge pull request #298 c822693 Merge pull request #301 6d04350 Merge pull request #303 7ab311c Merge pull request #304 5fb3229 Fixes a bug where bench_sign would fail due to passing in too small a buffer. 263dcbc remove unused assignment b183b41 bugfix: "ARG_CHECK(ctx != NULL)" makes no sense 6da1446 build: fix parallel build 5eb4356 Merge pull request #291 c996d53 Print success 9f443be Move pubkey recovery code to separate module d49abbd Separate ECDSA recovery tests 439d34a Separate recoverable and normal signatures a7b046e Merge pull request #289 f66907f Improve/reformat API documentation secp256k1.h 2f77487 Add context building benchmarks cc623d5 Merge pull request #287 de7e398 small typo fix 9d96e36 Merge pull request #280 432e1ce Merge pull request #283 14727fd Use correct name in gitignore 356b0e9 Actually test static precomputation in Travis ff3a5df Merge pull request #284 2587208 Merge pull request #212 a5a66c7 Add support for custom EC-Schnorr-SHA256 signatures d84a378 Merge pull request #252 72ae443 Improve perf. of cmov-based table lookup 92e53fc Implement endomorphism optimization for secp256k1_ecmult_const ed35d43 Make `secp256k1_scalar_add_bit` conditional; make `secp256k1_scalar_split_lambda_var` constant time 91c0ce9 Add benchmarks for ECDH and const-time multiplication 0739bbb Add ECDH module which works by hashing the output of ecmult_const 4401500 Add constant-time multiply `secp256k1_ecmult_const` for ECDH e4ce393 build: fix hard-coded usage of "gen_context" b8e39ac build: don't use BUILT_SOURCES for the static context header baa75da tests: add a couple tests ae4f0c6 Merge pull request #278 995c548 Introduce callback functions for dealing with errors. c333074 Merge pull request #282 18c329c Remove the internal secp256k1_ecdsa_sig_t type 74a2acd Add a secp256k1_ecdsa_signature_t type 23cfa91 Introduce secp256k1_pubkey_t type 4c63780 Merge pull request #269 3e6f1e2 Change rfc6979 implementation to be a generic PRNG ed5334a Update configure.ac to make it build on OpenBSD 1b68366 Merge pull request #274 a83bb48 Make ecmult static precomputation default 166b32f Merge pull request #276 c37812f Add gen_context src/ecmult_static_context.h to CLEANFILES to fix distclean. 125c15d Merge pull request #275 76f6769 Fix build with static ecmult altroot and make dist. 5133f78 Merge pull request #254 b0a60e6 Merge pull request #258 733c1e6 Add travis build to test the static context. fbecc38 Add ability to use a statically generated ecmult context. 4fb174d Merge pull request #263 4ab8990 Merge pull request #270 bdf0e0c Merge pull request #271 31d0c1f Merge pull request #273 eb2c8ff Add missing casts to SECP256K1_FE_CONST_INNER 55399c2 Further performance improvements to _ecmult_wnaf 99fd963 Add secp256k1_ec_pubkey_compress(), with test similar to the related decompress() function. 145cc6e Improve performance of _ecmult_wnaf 36b305a Verify the result of GMP modular inverse using non-GMP code 0cbc860 Merge pull request #266 06ff7fe Merge pull request #267 5a43124 Save 1 _fe_negate since s1 == -s2 a5d796e Update code comments 3f3964e Add specific VERIFY tests for _fe_cmov 7d054cd Refactor to save a _fe_negate b28d02a Refactor to remove a local var 55e7fc3 Perf. improvement in _gej_add_ge a0601cd Fix VERIFY calculations in _fe_cmov methods 17f7148 Merge pull request #261 7657420 Add tests for adding P+Q with P.x!=Q.x and P.y=-Q.y 8c5d5f7 tests: Add failing unit test for #257 (bad addition formula) 5de4c5d gej_add_ge: fix degenerate case when computing P + (-lambda)P bcf2fcf gej_add_ge: rearrange algebra e2a07c7 Fix compilation with C++ 873a453 Merge pull request #250 91eb0da Merge pull request #247 210ffed Use separate in and out pointers in `secp256k1_ec_pubkey_decompress` a1d5ae1 Tiny optimization 729badf Merge pull request #210 2d5a186 Apply effective-affine trick to precomp 4f9791a Effective affine addition in EC multiplication 2b4cf41 Use pkg-config always when possible, with failover to manual checks for libcrypto git-subtree-dir: src/secp256k1 git-subtree-split: 2bfb82b10edf0f0b0e366a12f94c8b21a914159d
This commit is contained in:
parent
a591d98c32
commit
1d84107924
|
@ -1,9 +1,12 @@
|
||||||
bench_inv
|
bench_inv
|
||||||
|
bench_ecdh
|
||||||
bench_sign
|
bench_sign
|
||||||
bench_verify
|
bench_verify
|
||||||
|
bench_schnorr_verify
|
||||||
bench_recover
|
bench_recover
|
||||||
bench_internal
|
bench_internal
|
||||||
tests
|
tests
|
||||||
|
gen_context
|
||||||
*.exe
|
*.exe
|
||||||
*.so
|
*.so
|
||||||
*.a
|
*.a
|
||||||
|
@ -28,6 +31,7 @@ build-aux/
|
||||||
*~
|
*~
|
||||||
src/libsecp256k1-config.h
|
src/libsecp256k1-config.h
|
||||||
src/libsecp256k1-config.h.in
|
src/libsecp256k1-config.h.in
|
||||||
|
src/ecmult_static_context.h
|
||||||
m4/libtool.m4
|
m4/libtool.m4
|
||||||
m4/ltoptions.m4
|
m4/ltoptions.m4
|
||||||
m4/ltsugar.m4
|
m4/ltsugar.m4
|
||||||
|
|
18
.travis.yml
18
.travis.yml
|
@ -8,20 +8,24 @@ compiler:
|
||||||
- gcc
|
- gcc
|
||||||
env:
|
env:
|
||||||
global:
|
global:
|
||||||
- FIELD=auto BIGNUM=auto SCALAR=auto ENDOMORPHISM=no ASM=no BUILD=check EXTRAFLAGS= HOST=
|
- FIELD=auto BIGNUM=auto SCALAR=auto ENDOMORPHISM=no STATICPRECOMPUTATION=yes ASM=no BUILD=check EXTRAFLAGS= HOST= ECDH=no schnorr=no RECOVERY=no
|
||||||
matrix:
|
matrix:
|
||||||
- SCALAR=32bit
|
- SCALAR=32bit RECOVERY=yes
|
||||||
|
- SCALAR=32bit FIELD=32bit ECDH=yes
|
||||||
- SCALAR=64bit
|
- SCALAR=64bit
|
||||||
- FIELD=64bit
|
- FIELD=64bit RECOVERY=yes
|
||||||
- FIELD=64bit ENDOMORPHISM=yes
|
- FIELD=64bit ENDOMORPHISM=yes
|
||||||
|
- FIELD=64bit ENDOMORPHISM=yes ECDH=yes
|
||||||
- FIELD=64bit ASM=x86_64
|
- FIELD=64bit ASM=x86_64
|
||||||
- FIELD=64bit ENDOMORPHISM=yes ASM=x86_64
|
- FIELD=64bit ENDOMORPHISM=yes ASM=x86_64
|
||||||
- FIELD=32bit
|
- FIELD=32bit SCHNORR=yes
|
||||||
- FIELD=32bit ENDOMORPHISM=yes
|
- FIELD=32bit ENDOMORPHISM=yes
|
||||||
- BIGNUM=no
|
- BIGNUM=no
|
||||||
- BIGNUM=no ENDOMORPHISM=yes
|
- BIGNUM=no ENDOMORPHISM=yes SCHNORR=yes RECOVERY=yes
|
||||||
|
- BIGNUM=no STATICPRECOMPUTATION=no
|
||||||
- BUILD=distcheck
|
- BUILD=distcheck
|
||||||
- EXTRAFLAGS=CFLAGS=-DDETERMINISTIC
|
- EXTRAFLAGS=CPPFLAGS=-DDETERMINISTIC
|
||||||
|
- EXTRAFLAGS=CFLAGS=-O0
|
||||||
matrix:
|
matrix:
|
||||||
fast_finish: true
|
fast_finish: true
|
||||||
include:
|
include:
|
||||||
|
@ -55,5 +59,5 @@ before_script: ./autogen.sh
|
||||||
script:
|
script:
|
||||||
- if [ -n "$HOST" ]; then export USE_HOST="--host=$HOST"; fi
|
- if [ -n "$HOST" ]; then export USE_HOST="--host=$HOST"; fi
|
||||||
- if [ "x$HOST" = "xi686-linux-gnu" ]; then export CC="$CC -m32"; fi
|
- if [ "x$HOST" = "xi686-linux-gnu" ]; then export CC="$CC -m32"; fi
|
||||||
- ./configure --enable-endomorphism=$ENDOMORPHISM --with-field=$FIELD --with-bignum=$BIGNUM --with-scalar=$SCALAR $EXTRAFLAGS $USE_HOST && make -j2 $BUILD
|
- ./configure --enable-endomorphism=$ENDOMORPHISM --with-field=$FIELD --with-bignum=$BIGNUM --with-scalar=$SCALAR --enable-ecmult-static-precomputation=$STATICPRECOMPUTATION --enable-module-ecdh=$ECDH --enable-module-schnorr=$SCHNORR --enable-module-recovery=$RECOVERY $EXTRAFLAGS $USE_HOST && make -j2 $BUILD
|
||||||
os: linux
|
os: linux
|
||||||
|
|
54
Makefile.am
54
Makefile.am
|
@ -19,6 +19,8 @@ noinst_HEADERS += src/eckey.h
|
||||||
noinst_HEADERS += src/eckey_impl.h
|
noinst_HEADERS += src/eckey_impl.h
|
||||||
noinst_HEADERS += src/ecmult.h
|
noinst_HEADERS += src/ecmult.h
|
||||||
noinst_HEADERS += src/ecmult_impl.h
|
noinst_HEADERS += src/ecmult_impl.h
|
||||||
|
noinst_HEADERS += src/ecmult_const.h
|
||||||
|
noinst_HEADERS += src/ecmult_const_impl.h
|
||||||
noinst_HEADERS += src/ecmult_gen.h
|
noinst_HEADERS += src/ecmult_gen.h
|
||||||
noinst_HEADERS += src/ecmult_gen_impl.h
|
noinst_HEADERS += src/ecmult_gen_impl.h
|
||||||
noinst_HEADERS += src/num.h
|
noinst_HEADERS += src/num.h
|
||||||
|
@ -38,40 +40,72 @@ noinst_HEADERS += src/hash_impl.h
|
||||||
noinst_HEADERS += src/field.h
|
noinst_HEADERS += src/field.h
|
||||||
noinst_HEADERS += src/field_impl.h
|
noinst_HEADERS += src/field_impl.h
|
||||||
noinst_HEADERS += src/bench.h
|
noinst_HEADERS += src/bench.h
|
||||||
|
noinst_HEADERS += contrib/lax_der_parsing.h
|
||||||
|
noinst_HEADERS += contrib/lax_der_parsing.c
|
||||||
|
noinst_HEADERS += contrib/lax_der_privatekey_parsing.h
|
||||||
|
noinst_HEADERS += contrib/lax_der_privatekey_parsing.c
|
||||||
|
|
||||||
pkgconfigdir = $(libdir)/pkgconfig
|
pkgconfigdir = $(libdir)/pkgconfig
|
||||||
pkgconfig_DATA = libsecp256k1.pc
|
pkgconfig_DATA = libsecp256k1.pc
|
||||||
|
|
||||||
libsecp256k1_la_SOURCES = src/secp256k1.c
|
libsecp256k1_la_SOURCES = src/secp256k1.c
|
||||||
libsecp256k1_la_CPPFLAGS = -I$(top_srcdir)/include $(SECP_INCLUDES)
|
libsecp256k1_la_CPPFLAGS = -I$(top_srcdir)/include -I$(top_srcdir)/src $(SECP_INCLUDES)
|
||||||
libsecp256k1_la_LIBADD = $(SECP_LIBS)
|
libsecp256k1_la_LIBADD = $(SECP_LIBS)
|
||||||
|
|
||||||
|
|
||||||
noinst_PROGRAMS =
|
noinst_PROGRAMS =
|
||||||
if USE_BENCHMARK
|
if USE_BENCHMARK
|
||||||
noinst_PROGRAMS += bench_verify bench_recover bench_sign bench_internal
|
noinst_PROGRAMS += bench_verify bench_sign bench_internal
|
||||||
bench_verify_SOURCES = src/bench_verify.c
|
bench_verify_SOURCES = src/bench_verify.c
|
||||||
bench_verify_LDADD = libsecp256k1.la $(SECP_LIBS)
|
bench_verify_LDADD = libsecp256k1.la $(SECP_LIBS)
|
||||||
bench_verify_LDFLAGS = -static
|
|
||||||
bench_recover_SOURCES = src/bench_recover.c
|
|
||||||
bench_recover_LDADD = libsecp256k1.la $(SECP_LIBS)
|
|
||||||
bench_recover_LDFLAGS = -static
|
|
||||||
bench_sign_SOURCES = src/bench_sign.c
|
bench_sign_SOURCES = src/bench_sign.c
|
||||||
bench_sign_LDADD = libsecp256k1.la $(SECP_LIBS)
|
bench_sign_LDADD = libsecp256k1.la $(SECP_LIBS)
|
||||||
bench_sign_LDFLAGS = -static
|
|
||||||
bench_internal_SOURCES = src/bench_internal.c
|
bench_internal_SOURCES = src/bench_internal.c
|
||||||
bench_internal_LDADD = $(SECP_LIBS)
|
bench_internal_LDADD = $(SECP_LIBS)
|
||||||
bench_internal_LDFLAGS = -static
|
|
||||||
bench_internal_CPPFLAGS = $(SECP_INCLUDES)
|
bench_internal_CPPFLAGS = $(SECP_INCLUDES)
|
||||||
endif
|
endif
|
||||||
|
|
||||||
if USE_TESTS
|
if USE_TESTS
|
||||||
noinst_PROGRAMS += tests
|
noinst_PROGRAMS += tests
|
||||||
tests_SOURCES = src/tests.c
|
tests_SOURCES = src/tests.c
|
||||||
tests_CPPFLAGS = -DVERIFY $(SECP_INCLUDES) $(SECP_TEST_INCLUDES)
|
tests_CPPFLAGS = -DVERIFY -I$(top_srcdir)/src -I$(top_srcdir)/include $(SECP_INCLUDES) $(SECP_TEST_INCLUDES)
|
||||||
tests_LDADD = $(SECP_LIBS) $(SECP_TEST_LIBS)
|
tests_LDADD = $(SECP_LIBS) $(SECP_TEST_LIBS)
|
||||||
tests_LDFLAGS = -static
|
tests_LDFLAGS = -static
|
||||||
TESTS = tests
|
TESTS = tests
|
||||||
endif
|
endif
|
||||||
|
|
||||||
EXTRA_DIST = autogen.sh
|
if USE_ECMULT_STATIC_PRECOMPUTATION
|
||||||
|
CPPFLAGS_FOR_BUILD +=-I$(top_srcdir)/
|
||||||
|
CFLAGS_FOR_BUILD += -Wall -Wextra -Wno-unused-function
|
||||||
|
|
||||||
|
gen_context_OBJECTS = gen_context.o
|
||||||
|
gen_context_BIN = gen_context$(BUILD_EXEEXT)
|
||||||
|
gen_%.o: src/gen_%.c
|
||||||
|
$(CC_FOR_BUILD) $(CPPFLAGS_FOR_BUILD) $(CFLAGS_FOR_BUILD) -c $< -o $@
|
||||||
|
|
||||||
|
$(gen_context_BIN): $(gen_context_OBJECTS)
|
||||||
|
$(CC_FOR_BUILD) $^ -o $@
|
||||||
|
|
||||||
|
$(libsecp256k1_la_OBJECTS): src/ecmult_static_context.h
|
||||||
|
$(tests_OBJECTS): src/ecmult_static_context.h
|
||||||
|
$(bench_internal_OBJECTS): src/ecmult_static_context.h
|
||||||
|
|
||||||
|
src/ecmult_static_context.h: $(gen_context_BIN)
|
||||||
|
./$(gen_context_BIN)
|
||||||
|
|
||||||
|
CLEANFILES = $(gen_context_BIN) src/ecmult_static_context.h
|
||||||
|
endif
|
||||||
|
|
||||||
|
EXTRA_DIST = autogen.sh src/gen_context.c src/basic-config.h
|
||||||
|
|
||||||
|
if ENABLE_MODULE_ECDH
|
||||||
|
include src/modules/ecdh/Makefile.am.include
|
||||||
|
endif
|
||||||
|
|
||||||
|
if ENABLE_MODULE_SCHNORR
|
||||||
|
include src/modules/schnorr/Makefile.am.include
|
||||||
|
endif
|
||||||
|
|
||||||
|
if ENABLE_MODULE_RECOVERY
|
||||||
|
include src/modules/recovery/Makefile.am.include
|
||||||
|
endif
|
||||||
|
|
|
@ -0,0 +1,125 @@
|
||||||
|
# ===========================================================================
|
||||||
|
# http://www.gnu.org/software/autoconf-archive/ax_prog_cc_for_build.html
|
||||||
|
# ===========================================================================
|
||||||
|
#
|
||||||
|
# SYNOPSIS
|
||||||
|
#
|
||||||
|
# AX_PROG_CC_FOR_BUILD
|
||||||
|
#
|
||||||
|
# DESCRIPTION
|
||||||
|
#
|
||||||
|
# This macro searches for a C compiler that generates native executables,
|
||||||
|
# that is a C compiler that surely is not a cross-compiler. This can be
|
||||||
|
# useful if you have to generate source code at compile-time like for
|
||||||
|
# example GCC does.
|
||||||
|
#
|
||||||
|
# The macro sets the CC_FOR_BUILD and CPP_FOR_BUILD macros to anything
|
||||||
|
# needed to compile or link (CC_FOR_BUILD) and preprocess (CPP_FOR_BUILD).
|
||||||
|
# The value of these variables can be overridden by the user by specifying
|
||||||
|
# a compiler with an environment variable (like you do for standard CC).
|
||||||
|
#
|
||||||
|
# It also sets BUILD_EXEEXT and BUILD_OBJEXT to the executable and object
|
||||||
|
# file extensions for the build platform, and GCC_FOR_BUILD to `yes' if
|
||||||
|
# the compiler we found is GCC. All these variables but GCC_FOR_BUILD are
|
||||||
|
# substituted in the Makefile.
|
||||||
|
#
|
||||||
|
# LICENSE
|
||||||
|
#
|
||||||
|
# Copyright (c) 2008 Paolo Bonzini <bonzini@gnu.org>
|
||||||
|
#
|
||||||
|
# Copying and distribution of this file, with or without modification, are
|
||||||
|
# permitted in any medium without royalty provided the copyright notice
|
||||||
|
# and this notice are preserved. This file is offered as-is, without any
|
||||||
|
# warranty.
|
||||||
|
|
||||||
|
#serial 8
|
||||||
|
|
||||||
|
AU_ALIAS([AC_PROG_CC_FOR_BUILD], [AX_PROG_CC_FOR_BUILD])
|
||||||
|
AC_DEFUN([AX_PROG_CC_FOR_BUILD], [dnl
|
||||||
|
AC_REQUIRE([AC_PROG_CC])dnl
|
||||||
|
AC_REQUIRE([AC_PROG_CPP])dnl
|
||||||
|
AC_REQUIRE([AC_EXEEXT])dnl
|
||||||
|
AC_REQUIRE([AC_CANONICAL_HOST])dnl
|
||||||
|
|
||||||
|
dnl Use the standard macros, but make them use other variable names
|
||||||
|
dnl
|
||||||
|
pushdef([ac_cv_prog_CPP], ac_cv_build_prog_CPP)dnl
|
||||||
|
pushdef([ac_cv_prog_gcc], ac_cv_build_prog_gcc)dnl
|
||||||
|
pushdef([ac_cv_prog_cc_works], ac_cv_build_prog_cc_works)dnl
|
||||||
|
pushdef([ac_cv_prog_cc_cross], ac_cv_build_prog_cc_cross)dnl
|
||||||
|
pushdef([ac_cv_prog_cc_g], ac_cv_build_prog_cc_g)dnl
|
||||||
|
pushdef([ac_cv_exeext], ac_cv_build_exeext)dnl
|
||||||
|
pushdef([ac_cv_objext], ac_cv_build_objext)dnl
|
||||||
|
pushdef([ac_exeext], ac_build_exeext)dnl
|
||||||
|
pushdef([ac_objext], ac_build_objext)dnl
|
||||||
|
pushdef([CC], CC_FOR_BUILD)dnl
|
||||||
|
pushdef([CPP], CPP_FOR_BUILD)dnl
|
||||||
|
pushdef([CFLAGS], CFLAGS_FOR_BUILD)dnl
|
||||||
|
pushdef([CPPFLAGS], CPPFLAGS_FOR_BUILD)dnl
|
||||||
|
pushdef([LDFLAGS], LDFLAGS_FOR_BUILD)dnl
|
||||||
|
pushdef([host], build)dnl
|
||||||
|
pushdef([host_alias], build_alias)dnl
|
||||||
|
pushdef([host_cpu], build_cpu)dnl
|
||||||
|
pushdef([host_vendor], build_vendor)dnl
|
||||||
|
pushdef([host_os], build_os)dnl
|
||||||
|
pushdef([ac_cv_host], ac_cv_build)dnl
|
||||||
|
pushdef([ac_cv_host_alias], ac_cv_build_alias)dnl
|
||||||
|
pushdef([ac_cv_host_cpu], ac_cv_build_cpu)dnl
|
||||||
|
pushdef([ac_cv_host_vendor], ac_cv_build_vendor)dnl
|
||||||
|
pushdef([ac_cv_host_os], ac_cv_build_os)dnl
|
||||||
|
pushdef([ac_cpp], ac_build_cpp)dnl
|
||||||
|
pushdef([ac_compile], ac_build_compile)dnl
|
||||||
|
pushdef([ac_link], ac_build_link)dnl
|
||||||
|
|
||||||
|
save_cross_compiling=$cross_compiling
|
||||||
|
save_ac_tool_prefix=$ac_tool_prefix
|
||||||
|
cross_compiling=no
|
||||||
|
ac_tool_prefix=
|
||||||
|
|
||||||
|
AC_PROG_CC
|
||||||
|
AC_PROG_CPP
|
||||||
|
AC_EXEEXT
|
||||||
|
|
||||||
|
ac_tool_prefix=$save_ac_tool_prefix
|
||||||
|
cross_compiling=$save_cross_compiling
|
||||||
|
|
||||||
|
dnl Restore the old definitions
|
||||||
|
dnl
|
||||||
|
popdef([ac_link])dnl
|
||||||
|
popdef([ac_compile])dnl
|
||||||
|
popdef([ac_cpp])dnl
|
||||||
|
popdef([ac_cv_host_os])dnl
|
||||||
|
popdef([ac_cv_host_vendor])dnl
|
||||||
|
popdef([ac_cv_host_cpu])dnl
|
||||||
|
popdef([ac_cv_host_alias])dnl
|
||||||
|
popdef([ac_cv_host])dnl
|
||||||
|
popdef([host_os])dnl
|
||||||
|
popdef([host_vendor])dnl
|
||||||
|
popdef([host_cpu])dnl
|
||||||
|
popdef([host_alias])dnl
|
||||||
|
popdef([host])dnl
|
||||||
|
popdef([LDFLAGS])dnl
|
||||||
|
popdef([CPPFLAGS])dnl
|
||||||
|
popdef([CFLAGS])dnl
|
||||||
|
popdef([CPP])dnl
|
||||||
|
popdef([CC])dnl
|
||||||
|
popdef([ac_objext])dnl
|
||||||
|
popdef([ac_exeext])dnl
|
||||||
|
popdef([ac_cv_objext])dnl
|
||||||
|
popdef([ac_cv_exeext])dnl
|
||||||
|
popdef([ac_cv_prog_cc_g])dnl
|
||||||
|
popdef([ac_cv_prog_cc_cross])dnl
|
||||||
|
popdef([ac_cv_prog_cc_works])dnl
|
||||||
|
popdef([ac_cv_prog_gcc])dnl
|
||||||
|
popdef([ac_cv_prog_CPP])dnl
|
||||||
|
|
||||||
|
dnl Finally, set Makefile variables
|
||||||
|
dnl
|
||||||
|
BUILD_EXEEXT=$ac_build_exeext
|
||||||
|
BUILD_OBJEXT=$ac_build_objext
|
||||||
|
AC_SUBST(BUILD_EXEEXT)dnl
|
||||||
|
AC_SUBST(BUILD_OBJEXT)dnl
|
||||||
|
AC_SUBST([CFLAGS_FOR_BUILD])dnl
|
||||||
|
AC_SUBST([CPPFLAGS_FOR_BUILD])dnl
|
||||||
|
AC_SUBST([LDFLAGS_FOR_BUILD])dnl
|
||||||
|
])
|
|
@ -16,8 +16,7 @@ AC_MSG_RESULT([$has_64bit_asm])
|
||||||
|
|
||||||
dnl
|
dnl
|
||||||
AC_DEFUN([SECP_OPENSSL_CHECK],[
|
AC_DEFUN([SECP_OPENSSL_CHECK],[
|
||||||
if test x"$use_pkgconfig" = x"yes"; then
|
has_libcrypto=no
|
||||||
: #NOP
|
|
||||||
m4_ifdef([PKG_CHECK_MODULES],[
|
m4_ifdef([PKG_CHECK_MODULES],[
|
||||||
PKG_CHECK_MODULES([CRYPTO], [libcrypto], [has_libcrypto=yes],[has_libcrypto=no])
|
PKG_CHECK_MODULES([CRYPTO], [libcrypto], [has_libcrypto=yes],[has_libcrypto=no])
|
||||||
if test x"$has_libcrypto" = x"yes"; then
|
if test x"$has_libcrypto" = x"yes"; then
|
||||||
|
@ -27,11 +26,16 @@ if test x"$use_pkgconfig" = x"yes"; then
|
||||||
LIBS="$TEMP_LIBS"
|
LIBS="$TEMP_LIBS"
|
||||||
fi
|
fi
|
||||||
])
|
])
|
||||||
else
|
if test x$has_libcrypto = xno; then
|
||||||
AC_CHECK_HEADER(openssl/crypto.h,[AC_CHECK_LIB(crypto, main,[has_libcrypto=yes; CRYPTO_LIBS=-lcrypto; AC_DEFINE(HAVE_LIBCRYPTO,1,[Define this symbol if libcrypto is installed])]
|
AC_CHECK_HEADER(openssl/crypto.h,[
|
||||||
)])
|
AC_CHECK_LIB(crypto, main,[
|
||||||
|
has_libcrypto=yes
|
||||||
|
CRYPTO_LIBS=-lcrypto
|
||||||
|
AC_DEFINE(HAVE_LIBCRYPTO,1,[Define this symbol if libcrypto is installed])
|
||||||
|
])
|
||||||
|
])
|
||||||
LIBS=
|
LIBS=
|
||||||
fi
|
fi
|
||||||
if test x"$has_libcrypto" = x"yes" && test x"$has_openssl_ec" = x; then
|
if test x"$has_libcrypto" = x"yes" && test x"$has_openssl_ec" = x; then
|
||||||
AC_MSG_CHECKING(for EC functions in libcrypto)
|
AC_MSG_CHECKING(for EC functions in libcrypto)
|
||||||
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
||||||
|
|
64
configure.ac
64
configure.ac
|
@ -17,25 +17,19 @@ PKG_PROG_PKG_CONFIG
|
||||||
AC_PATH_TOOL(AR, ar)
|
AC_PATH_TOOL(AR, ar)
|
||||||
AC_PATH_TOOL(RANLIB, ranlib)
|
AC_PATH_TOOL(RANLIB, ranlib)
|
||||||
AC_PATH_TOOL(STRIP, strip)
|
AC_PATH_TOOL(STRIP, strip)
|
||||||
|
AX_PROG_CC_FOR_BUILD
|
||||||
|
|
||||||
if test "x$CFLAGS" = "x"; then
|
if test "x$CFLAGS" = "x"; then
|
||||||
CFLAGS="-O3 -g"
|
CFLAGS="-O3 -g"
|
||||||
fi
|
fi
|
||||||
|
|
||||||
|
AM_PROG_CC_C_O
|
||||||
|
|
||||||
AC_PROG_CC_C89
|
AC_PROG_CC_C89
|
||||||
if test x"$ac_cv_prog_cc_c89" = x"no"; then
|
if test x"$ac_cv_prog_cc_c89" = x"no"; then
|
||||||
AC_MSG_ERROR([c89 compiler support required])
|
AC_MSG_ERROR([c89 compiler support required])
|
||||||
fi
|
fi
|
||||||
|
|
||||||
case $host in
|
|
||||||
*mingw*)
|
|
||||||
use_pkgconfig=no
|
|
||||||
;;
|
|
||||||
*)
|
|
||||||
use_pkgconfig=yes
|
|
||||||
;;
|
|
||||||
esac
|
|
||||||
|
|
||||||
case $host_os in
|
case $host_os in
|
||||||
*darwin*)
|
*darwin*)
|
||||||
if test x$cross_compiling != xyes; then
|
if test x$cross_compiling != xyes; then
|
||||||
|
@ -80,6 +74,14 @@ AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
|
||||||
CFLAGS="$saved_CFLAGS"
|
CFLAGS="$saved_CFLAGS"
|
||||||
])
|
])
|
||||||
|
|
||||||
|
saved_CFLAGS="$CFLAGS"
|
||||||
|
CFLAGS="$CFLAGS -fvisibility=hidden"
|
||||||
|
AC_MSG_CHECKING([if ${CC} supports -fvisibility=hidden])
|
||||||
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
|
||||||
|
[ AC_MSG_RESULT([yes]) ],
|
||||||
|
[ AC_MSG_RESULT([no])
|
||||||
|
CFLAGS="$saved_CFLAGS"
|
||||||
|
])
|
||||||
|
|
||||||
AC_ARG_ENABLE(benchmark,
|
AC_ARG_ENABLE(benchmark,
|
||||||
AS_HELP_STRING([--enable-benchmark],[compile benchmark (default is no)]),
|
AS_HELP_STRING([--enable-benchmark],[compile benchmark (default is no)]),
|
||||||
|
@ -96,6 +98,26 @@ AC_ARG_ENABLE(endomorphism,
|
||||||
[use_endomorphism=$enableval],
|
[use_endomorphism=$enableval],
|
||||||
[use_endomorphism=no])
|
[use_endomorphism=no])
|
||||||
|
|
||||||
|
AC_ARG_ENABLE(ecmult_static_precomputation,
|
||||||
|
AS_HELP_STRING([--enable-ecmult-static-precomputation],[enable precomputed ecmult table for signing (default is yes)]),
|
||||||
|
[use_ecmult_static_precomputation=$enableval],
|
||||||
|
[use_ecmult_static_precomputation=yes])
|
||||||
|
|
||||||
|
AC_ARG_ENABLE(module_ecdh,
|
||||||
|
AS_HELP_STRING([--enable-module-ecdh],[enable ECDH shared secret computation (default is no)]),
|
||||||
|
[enable_module_ecdh=$enableval],
|
||||||
|
[enable_module_ecdh=no])
|
||||||
|
|
||||||
|
AC_ARG_ENABLE(module_schnorr,
|
||||||
|
AS_HELP_STRING([--enable-module-schnorr],[enable Schnorr signature module (default is no)]),
|
||||||
|
[enable_module_schnorr=$enableval],
|
||||||
|
[enable_module_schnorr=no])
|
||||||
|
|
||||||
|
AC_ARG_ENABLE(module_recovery,
|
||||||
|
AS_HELP_STRING([--enable-module-recovery],[enable ECDSA pubkey recovery module (default is no)]),
|
||||||
|
[enable_module_recovery=$enableval],
|
||||||
|
[enable_module_recovery=no])
|
||||||
|
|
||||||
AC_ARG_WITH([field], [AS_HELP_STRING([--with-field=64bit|32bit|auto],
|
AC_ARG_WITH([field], [AS_HELP_STRING([--with-field=64bit|32bit|auto],
|
||||||
[Specify Field Implementation. Default is auto])],[req_field=$withval], [req_field=auto])
|
[Specify Field Implementation. Default is auto])],[req_field=$withval], [req_field=auto])
|
||||||
|
|
||||||
|
@ -305,6 +327,22 @@ if test x"$use_endomorphism" = x"yes"; then
|
||||||
AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
|
AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
|
||||||
fi
|
fi
|
||||||
|
|
||||||
|
if test x"$use_ecmult_static_precomputation" = x"yes"; then
|
||||||
|
AC_DEFINE(USE_ECMULT_STATIC_PRECOMPUTATION, 1, [Define this symbol to use a statically generated ecmult table])
|
||||||
|
fi
|
||||||
|
|
||||||
|
if test x"$enable_module_ecdh" = x"yes"; then
|
||||||
|
AC_DEFINE(ENABLE_MODULE_ECDH, 1, [Define this symbol to enable the ECDH module])
|
||||||
|
fi
|
||||||
|
|
||||||
|
if test x"$enable_module_schnorr" = x"yes"; then
|
||||||
|
AC_DEFINE(ENABLE_MODULE_SCHNORR, 1, [Define this symbol to enable the Schnorr signature module])
|
||||||
|
fi
|
||||||
|
|
||||||
|
if test x"$enable_module_recovery" = x"yes"; then
|
||||||
|
AC_DEFINE(ENABLE_MODULE_RECOVERY, 1, [Define this symbol to enable the ECDSA pubkey recovery module])
|
||||||
|
fi
|
||||||
|
|
||||||
AC_C_BIGENDIAN()
|
AC_C_BIGENDIAN()
|
||||||
|
|
||||||
AC_MSG_NOTICE([Using assembly optimizations: $set_asm])
|
AC_MSG_NOTICE([Using assembly optimizations: $set_asm])
|
||||||
|
@ -312,6 +350,10 @@ AC_MSG_NOTICE([Using field implementation: $set_field])
|
||||||
AC_MSG_NOTICE([Using bignum implementation: $set_bignum])
|
AC_MSG_NOTICE([Using bignum implementation: $set_bignum])
|
||||||
AC_MSG_NOTICE([Using scalar implementation: $set_scalar])
|
AC_MSG_NOTICE([Using scalar implementation: $set_scalar])
|
||||||
AC_MSG_NOTICE([Using endomorphism optimizations: $use_endomorphism])
|
AC_MSG_NOTICE([Using endomorphism optimizations: $use_endomorphism])
|
||||||
|
AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
|
||||||
|
|
||||||
|
AC_MSG_NOTICE([Building Schnorr signatures module: $enable_module_schnorr])
|
||||||
|
AC_MSG_NOTICE([Building ECDSA pubkey recovery module: $enable_module_recovery])
|
||||||
|
|
||||||
AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
|
AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
|
||||||
AC_CONFIG_FILES([Makefile libsecp256k1.pc])
|
AC_CONFIG_FILES([Makefile libsecp256k1.pc])
|
||||||
|
@ -321,6 +363,10 @@ AC_SUBST(SECP_TEST_LIBS)
|
||||||
AC_SUBST(SECP_TEST_INCLUDES)
|
AC_SUBST(SECP_TEST_INCLUDES)
|
||||||
AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
|
AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
|
||||||
AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
|
AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
|
||||||
|
AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$use_ecmult_static_precomputation" = x"yes"])
|
||||||
|
AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
|
||||||
|
AM_CONDITIONAL([ENABLE_MODULE_SCHNORR], [test x"$enable_module_schnorr" = x"yes"])
|
||||||
|
AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
|
||||||
|
|
||||||
dnl make sure nothing new is exported so that we don't break the cache
|
dnl make sure nothing new is exported so that we don't break the cache
|
||||||
PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
|
PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
|
||||||
|
|
|
@ -0,0 +1,150 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2015 Pieter Wuille *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#include <string.h>
|
||||||
|
#include <secp256k1.h>
|
||||||
|
|
||||||
|
#include "lax_der_parsing.h"
|
||||||
|
|
||||||
|
int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
|
||||||
|
size_t rpos, rlen, spos, slen;
|
||||||
|
size_t pos = 0;
|
||||||
|
size_t lenbyte;
|
||||||
|
unsigned char tmpsig[64] = {0};
|
||||||
|
int overflow = 0;
|
||||||
|
|
||||||
|
/* Hack to initialize sig with a correctly-parsed but invalid signature. */
|
||||||
|
secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
|
||||||
|
|
||||||
|
/* Sequence tag byte */
|
||||||
|
if (pos == inputlen || input[pos] != 0x30) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
pos++;
|
||||||
|
|
||||||
|
/* Sequence length bytes */
|
||||||
|
if (pos == inputlen) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
lenbyte = input[pos++];
|
||||||
|
if (lenbyte & 0x80) {
|
||||||
|
lenbyte -= 0x80;
|
||||||
|
if (pos + lenbyte > inputlen) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
pos += lenbyte;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Integer tag byte for R */
|
||||||
|
if (pos == inputlen || input[pos] != 0x02) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
pos++;
|
||||||
|
|
||||||
|
/* Integer length for R */
|
||||||
|
if (pos == inputlen) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
lenbyte = input[pos++];
|
||||||
|
if (lenbyte & 0x80) {
|
||||||
|
lenbyte -= 0x80;
|
||||||
|
if (pos + lenbyte > inputlen) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
while (lenbyte > 0 && input[pos] == 0) {
|
||||||
|
pos++;
|
||||||
|
lenbyte--;
|
||||||
|
}
|
||||||
|
if (lenbyte >= sizeof(size_t)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
rlen = 0;
|
||||||
|
while (lenbyte > 0) {
|
||||||
|
rlen = (rlen << 8) + input[pos];
|
||||||
|
pos++;
|
||||||
|
lenbyte--;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
rlen = lenbyte;
|
||||||
|
}
|
||||||
|
if (rlen > inputlen - pos) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
rpos = pos;
|
||||||
|
pos += rlen;
|
||||||
|
|
||||||
|
/* Integer tag byte for S */
|
||||||
|
if (pos == inputlen || input[pos] != 0x02) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
pos++;
|
||||||
|
|
||||||
|
/* Integer length for S */
|
||||||
|
if (pos == inputlen) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
lenbyte = input[pos++];
|
||||||
|
if (lenbyte & 0x80) {
|
||||||
|
lenbyte -= 0x80;
|
||||||
|
if (pos + lenbyte > inputlen) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
while (lenbyte > 0 && input[pos] == 0) {
|
||||||
|
pos++;
|
||||||
|
lenbyte--;
|
||||||
|
}
|
||||||
|
if (lenbyte >= sizeof(size_t)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
slen = 0;
|
||||||
|
while (lenbyte > 0) {
|
||||||
|
slen = (slen << 8) + input[pos];
|
||||||
|
pos++;
|
||||||
|
lenbyte--;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
slen = lenbyte;
|
||||||
|
}
|
||||||
|
if (slen > inputlen - pos) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
spos = pos;
|
||||||
|
pos += slen;
|
||||||
|
|
||||||
|
/* Ignore leading zeroes in R */
|
||||||
|
while (rlen > 0 && input[rpos] == 0) {
|
||||||
|
rlen--;
|
||||||
|
rpos++;
|
||||||
|
}
|
||||||
|
/* Copy R value */
|
||||||
|
if (rlen > 32) {
|
||||||
|
overflow = 1;
|
||||||
|
} else {
|
||||||
|
memcpy(tmpsig + 32 - rlen, input + rpos, rlen);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Ignore leading zeroes in S */
|
||||||
|
while (slen > 0 && input[spos] == 0) {
|
||||||
|
slen--;
|
||||||
|
spos++;
|
||||||
|
}
|
||||||
|
/* Copy S value */
|
||||||
|
if (slen > 32) {
|
||||||
|
overflow = 1;
|
||||||
|
} else {
|
||||||
|
memcpy(tmpsig + 64 - slen, input + spos, slen);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!overflow) {
|
||||||
|
overflow = !secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
|
||||||
|
}
|
||||||
|
if (overflow) {
|
||||||
|
memset(tmpsig, 0, 64);
|
||||||
|
secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
|
||||||
|
}
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
|
@ -0,0 +1,91 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2015 Pieter Wuille *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
/****
|
||||||
|
* Please do not link this file directly. It is not part of the libsecp256k1
|
||||||
|
* project and does not promise any stability in its API, functionality or
|
||||||
|
* presence. Projects which use this code should instead copy this header
|
||||||
|
* and its accompanying .c file directly into their codebase.
|
||||||
|
****/
|
||||||
|
|
||||||
|
/* This file defines a function that parses DER with various errors and
|
||||||
|
* violations. This is not a part of the library itself, because the allowed
|
||||||
|
* violations are chosen arbitrarily and do not follow or establish any
|
||||||
|
* standard.
|
||||||
|
*
|
||||||
|
* In many places it matters that different implementations do not only accept
|
||||||
|
* the same set of valid signatures, but also reject the same set of signatures.
|
||||||
|
* The only means to accomplish that is by strictly obeying a standard, and not
|
||||||
|
* accepting anything else.
|
||||||
|
*
|
||||||
|
* Nonetheless, sometimes there is a need for compatibility with systems that
|
||||||
|
* use signatures which do not strictly obey DER. The snippet below shows how
|
||||||
|
* certain violations are easily supported. You may need to adapt it.
|
||||||
|
*
|
||||||
|
* Do not use this for new systems. Use well-defined DER or compact signatures
|
||||||
|
* instead if you have the choice (see secp256k1_ecdsa_signature_parse_der and
|
||||||
|
* secp256k1_ecdsa_signature_parse_compact).
|
||||||
|
*
|
||||||
|
* The supported violations are:
|
||||||
|
* - All numbers are parsed as nonnegative integers, even though X.609-0207
|
||||||
|
* section 8.3.3 specifies that integers are always encoded as two's
|
||||||
|
* complement.
|
||||||
|
* - Integers can have length 0, even though section 8.3.1 says they can't.
|
||||||
|
* - Integers with overly long padding are accepted, violation section
|
||||||
|
* 8.3.2.
|
||||||
|
* - 127-byte long length descriptors are accepted, even though section
|
||||||
|
* 8.1.3.5.c says that they are not.
|
||||||
|
* - Trailing garbage data inside or after the signature is ignored.
|
||||||
|
* - The length descriptor of the sequence is ignored.
|
||||||
|
*
|
||||||
|
* Compared to for example OpenSSL, many violations are NOT supported:
|
||||||
|
* - Using overly long tag descriptors for the sequence or integers inside,
|
||||||
|
* violating section 8.1.2.2.
|
||||||
|
* - Encoding primitive integers as constructed values, violating section
|
||||||
|
* 8.3.1.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _SECP256K1_CONTRIB_LAX_DER_PARSING_H_
|
||||||
|
#define _SECP256K1_CONTRIB_LAX_DER_PARSING_H_
|
||||||
|
|
||||||
|
#include <secp256k1.h>
|
||||||
|
|
||||||
|
# ifdef __cplusplus
|
||||||
|
extern "C" {
|
||||||
|
# endif
|
||||||
|
|
||||||
|
/** Parse a signature in "lax DER" format
|
||||||
|
*
|
||||||
|
* Returns: 1 when the signature could be parsed, 0 otherwise.
|
||||||
|
* Args: ctx: a secp256k1 context object
|
||||||
|
* Out: sig: a pointer to a signature object
|
||||||
|
* In: input: a pointer to the signature to be parsed
|
||||||
|
* inputlen: the length of the array pointed to be input
|
||||||
|
*
|
||||||
|
* This function will accept any valid DER encoded signature, even if the
|
||||||
|
* encoded numbers are out of range. In addition, it will accept signatures
|
||||||
|
* which violate the DER spec in various ways. Its purpose is to allow
|
||||||
|
* validation of the Bitcoin blockchain, which includes non-DER signatures
|
||||||
|
* from before the network rules were updated to enforce DER. Note that
|
||||||
|
* the set of supported violations is a strict subset of what OpenSSL will
|
||||||
|
* accept.
|
||||||
|
*
|
||||||
|
* After the call, sig will always be initialized. If parsing failed or the
|
||||||
|
* encoded numbers are out of range, signature validation with it is
|
||||||
|
* guaranteed to fail for every message and public key.
|
||||||
|
*/
|
||||||
|
int ecdsa_signature_parse_der_lax(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_ecdsa_signature* sig,
|
||||||
|
const unsigned char *input,
|
||||||
|
size_t inputlen
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
|
#ifdef __cplusplus
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,113 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2014, 2015 Pieter Wuille *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#include <string.h>
|
||||||
|
#include <secp256k1.h>
|
||||||
|
|
||||||
|
#include "lax_der_privatekey_parsing.h"
|
||||||
|
|
||||||
|
int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *out32, const unsigned char *privkey, size_t privkeylen) {
|
||||||
|
const unsigned char *end = privkey + privkeylen;
|
||||||
|
int lenb = 0;
|
||||||
|
int len = 0;
|
||||||
|
memset(out32, 0, 32);
|
||||||
|
/* sequence header */
|
||||||
|
if (end < privkey+1 || *privkey != 0x30) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
privkey++;
|
||||||
|
/* sequence length constructor */
|
||||||
|
if (end < privkey+1 || !(*privkey & 0x80)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
lenb = *privkey & ~0x80; privkey++;
|
||||||
|
if (lenb < 1 || lenb > 2) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (end < privkey+lenb) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
/* sequence length */
|
||||||
|
len = privkey[lenb-1] | (lenb > 1 ? privkey[lenb-2] << 8 : 0);
|
||||||
|
privkey += lenb;
|
||||||
|
if (end < privkey+len) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
/* sequence element 0: version number (=1) */
|
||||||
|
if (end < privkey+3 || privkey[0] != 0x02 || privkey[1] != 0x01 || privkey[2] != 0x01) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
privkey += 3;
|
||||||
|
/* sequence element 1: octet string, up to 32 bytes */
|
||||||
|
if (end < privkey+2 || privkey[0] != 0x04 || privkey[1] > 0x20 || end < privkey+2+privkey[1]) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
memcpy(out32 + 32 - privkey[1], privkey + 2, privkey[1]);
|
||||||
|
if (!secp256k1_ec_seckey_verify(ctx, out32)) {
|
||||||
|
memset(out32, 0, 32);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *privkey, size_t *privkeylen, const unsigned char *key32, int compressed) {
|
||||||
|
secp256k1_pubkey pubkey;
|
||||||
|
size_t pubkeylen = 0;
|
||||||
|
if (!secp256k1_ec_pubkey_create(ctx, &pubkey, key32)) {
|
||||||
|
*privkeylen = 0;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (compressed) {
|
||||||
|
static const unsigned char begin[] = {
|
||||||
|
0x30,0x81,0xD3,0x02,0x01,0x01,0x04,0x20
|
||||||
|
};
|
||||||
|
static const unsigned char middle[] = {
|
||||||
|
0xA0,0x81,0x85,0x30,0x81,0x82,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
|
||||||
|
0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
||||||
|
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
||||||
|
0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
|
||||||
|
0x21,0x02,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
|
||||||
|
0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
|
||||||
|
0x17,0x98,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
||||||
|
0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
|
||||||
|
0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x24,0x03,0x22,0x00
|
||||||
|
};
|
||||||
|
unsigned char *ptr = privkey;
|
||||||
|
memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
|
||||||
|
memcpy(ptr, key32, 32); ptr += 32;
|
||||||
|
memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
|
||||||
|
pubkeylen = 33;
|
||||||
|
secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED);
|
||||||
|
ptr += pubkeylen;
|
||||||
|
*privkeylen = ptr - privkey;
|
||||||
|
} else {
|
||||||
|
static const unsigned char begin[] = {
|
||||||
|
0x30,0x82,0x01,0x13,0x02,0x01,0x01,0x04,0x20
|
||||||
|
};
|
||||||
|
static const unsigned char middle[] = {
|
||||||
|
0xA0,0x81,0xA5,0x30,0x81,0xA2,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
|
||||||
|
0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
||||||
|
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
||||||
|
0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
|
||||||
|
0x41,0x04,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
|
||||||
|
0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
|
||||||
|
0x17,0x98,0x48,0x3A,0xDA,0x77,0x26,0xA3,0xC4,0x65,0x5D,0xA4,0xFB,0xFC,0x0E,0x11,
|
||||||
|
0x08,0xA8,0xFD,0x17,0xB4,0x48,0xA6,0x85,0x54,0x19,0x9C,0x47,0xD0,0x8F,0xFB,0x10,
|
||||||
|
0xD4,0xB8,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
||||||
|
0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
|
||||||
|
0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x44,0x03,0x42,0x00
|
||||||
|
};
|
||||||
|
unsigned char *ptr = privkey;
|
||||||
|
memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
|
||||||
|
memcpy(ptr, key32, 32); ptr += 32;
|
||||||
|
memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
|
||||||
|
pubkeylen = 65;
|
||||||
|
secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
|
||||||
|
ptr += pubkeylen;
|
||||||
|
*privkeylen = ptr - privkey;
|
||||||
|
}
|
||||||
|
return 1;
|
||||||
|
}
|
|
@ -0,0 +1,90 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2014, 2015 Pieter Wuille *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
/****
|
||||||
|
* Please do not link this file directly. It is not part of the libsecp256k1
|
||||||
|
* project and does not promise any stability in its API, functionality or
|
||||||
|
* presence. Projects which use this code should instead copy this header
|
||||||
|
* and its accompanying .c file directly into their codebase.
|
||||||
|
****/
|
||||||
|
|
||||||
|
/* This file contains code snippets that parse DER private keys with
|
||||||
|
* various errors and violations. This is not a part of the library
|
||||||
|
* itself, because the allowed violations are chosen arbitrarily and
|
||||||
|
* do not follow or establish any standard.
|
||||||
|
*
|
||||||
|
* It also contains code to serialize private keys in a compatible
|
||||||
|
* manner.
|
||||||
|
*
|
||||||
|
* These functions are meant for compatibility with applications
|
||||||
|
* that require BER encoded keys. When working with secp256k1-specific
|
||||||
|
* code, the simple 32-byte private keys normally used by the
|
||||||
|
* library are sufficient.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _SECP256K1_CONTRIB_BER_PRIVATEKEY_H_
|
||||||
|
#define _SECP256K1_CONTRIB_BER_PRIVATEKEY_H_
|
||||||
|
|
||||||
|
#include <secp256k1.h>
|
||||||
|
|
||||||
|
# ifdef __cplusplus
|
||||||
|
extern "C" {
|
||||||
|
# endif
|
||||||
|
|
||||||
|
/** Export a private key in DER format.
|
||||||
|
*
|
||||||
|
* Returns: 1 if the private key was valid.
|
||||||
|
* Args: ctx: pointer to a context object, initialized for signing (cannot
|
||||||
|
* be NULL)
|
||||||
|
* Out: privkey: pointer to an array for storing the private key in BER.
|
||||||
|
* Should have space for 279 bytes, and cannot be NULL.
|
||||||
|
* privkeylen: Pointer to an int where the length of the private key in
|
||||||
|
* privkey will be stored.
|
||||||
|
* In: seckey: pointer to a 32-byte secret key to export.
|
||||||
|
* compressed: 1 if the key should be exported in
|
||||||
|
* compressed format, 0 otherwise
|
||||||
|
*
|
||||||
|
* This function is purely meant for compatibility with applications that
|
||||||
|
* require BER encoded keys. When working with secp256k1-specific code, the
|
||||||
|
* simple 32-byte private keys are sufficient.
|
||||||
|
*
|
||||||
|
* Note that this function does not guarantee correct DER output. It is
|
||||||
|
* guaranteed to be parsable by secp256k1_ec_privkey_import_der
|
||||||
|
*/
|
||||||
|
SECP256K1_WARN_UNUSED_RESULT int ec_privkey_export_der(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
unsigned char *privkey,
|
||||||
|
size_t *privkeylen,
|
||||||
|
const unsigned char *seckey,
|
||||||
|
int compressed
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
||||||
|
|
||||||
|
/** Import a private key in DER format.
|
||||||
|
* Returns: 1 if a private key was extracted.
|
||||||
|
* Args: ctx: pointer to a context object (cannot be NULL).
|
||||||
|
* Out: seckey: pointer to a 32-byte array for storing the private key.
|
||||||
|
* (cannot be NULL).
|
||||||
|
* In: privkey: pointer to a private key in DER format (cannot be NULL).
|
||||||
|
* privkeylen: length of the DER private key pointed to be privkey.
|
||||||
|
*
|
||||||
|
* This function will accept more than just strict DER, and even allow some BER
|
||||||
|
* violations. The public key stored inside the DER-encoded private key is not
|
||||||
|
* verified for correctness, nor are the curve parameters. Use this function
|
||||||
|
* only if you know in advance it is supposed to contain a secp256k1 private
|
||||||
|
* key.
|
||||||
|
*/
|
||||||
|
SECP256K1_WARN_UNUSED_RESULT int ec_privkey_import_der(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
unsigned char *seckey,
|
||||||
|
const unsigned char *privkey,
|
||||||
|
size_t privkeylen
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
|
#ifdef __cplusplus
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#endif
|
|
@ -5,6 +5,99 @@
|
||||||
extern "C" {
|
extern "C" {
|
||||||
# endif
|
# endif
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
|
||||||
|
/* These rules specify the order of arguments in API calls:
|
||||||
|
*
|
||||||
|
* 1. Context pointers go first, followed by output arguments, combined
|
||||||
|
* output/input arguments, and finally input-only arguments.
|
||||||
|
* 2. Array lengths always immediately the follow the argument whose length
|
||||||
|
* they describe, even if this violates rule 1.
|
||||||
|
* 3. Within the OUT/OUTIN/IN groups, pointers to data that is typically generated
|
||||||
|
* later go first. This means: signatures, public nonces, private nonces,
|
||||||
|
* messages, public keys, secret keys, tweaks.
|
||||||
|
* 4. Arguments that are not data pointers go last, from more complex to less
|
||||||
|
* complex: function pointers, algorithm names, messages, void pointers,
|
||||||
|
* counts, flags, booleans.
|
||||||
|
* 5. Opaque data pointers follow the function pointer they are to be passed to.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/** Opaque data structure that holds context information (precomputed tables etc.).
|
||||||
|
*
|
||||||
|
* The purpose of context structures is to cache large precomputed data tables
|
||||||
|
* that are expensive to construct, and also to maintain the randomization data
|
||||||
|
* for blinding.
|
||||||
|
*
|
||||||
|
* Do not create a new context object for each operation, as construction is
|
||||||
|
* far slower than all other API calls (~100 times slower than an ECDSA
|
||||||
|
* verification).
|
||||||
|
*
|
||||||
|
* A constructed context can safely be used from multiple threads
|
||||||
|
* simultaneously, but API call that take a non-const pointer to a context
|
||||||
|
* need exclusive access to it. In particular this is the case for
|
||||||
|
* secp256k1_context_destroy and secp256k1_context_randomize.
|
||||||
|
*
|
||||||
|
* Regarding randomization, either do it once at creation time (in which case
|
||||||
|
* you do not need any locking for the other calls), or use a read-write lock.
|
||||||
|
*/
|
||||||
|
typedef struct secp256k1_context_struct secp256k1_context;
|
||||||
|
|
||||||
|
/** Opaque data structure that holds a parsed and valid public key.
|
||||||
|
*
|
||||||
|
* The exact representation of data inside is implementation defined and not
|
||||||
|
* guaranteed to be portable between different platforms or versions. It is
|
||||||
|
* however guaranteed to be 64 bytes in size, and can be safely copied/moved.
|
||||||
|
* If you need to convert to a format suitable for storage or transmission, use
|
||||||
|
* secp256k1_ec_pubkey_serialize and secp256k1_ec_pubkey_parse.
|
||||||
|
*
|
||||||
|
* Furthermore, it is guaranteed that identical public keys (ignoring
|
||||||
|
* compression) will have identical representation, so they can be memcmp'ed.
|
||||||
|
*/
|
||||||
|
typedef struct {
|
||||||
|
unsigned char data[64];
|
||||||
|
} secp256k1_pubkey;
|
||||||
|
|
||||||
|
/** Opaque data structured that holds a parsed ECDSA signature.
|
||||||
|
*
|
||||||
|
* The exact representation of data inside is implementation defined and not
|
||||||
|
* guaranteed to be portable between different platforms or versions. It is
|
||||||
|
* however guaranteed to be 64 bytes in size, and can be safely copied/moved.
|
||||||
|
* If you need to convert to a format suitable for storage or transmission, use
|
||||||
|
* the secp256k1_ecdsa_signature_serialize_* and
|
||||||
|
* secp256k1_ecdsa_signature_serialize_* functions.
|
||||||
|
*
|
||||||
|
* Furthermore, it is guaranteed to identical signatures will have identical
|
||||||
|
* representation, so they can be memcmp'ed.
|
||||||
|
*/
|
||||||
|
typedef struct {
|
||||||
|
unsigned char data[64];
|
||||||
|
} secp256k1_ecdsa_signature;
|
||||||
|
|
||||||
|
/** A pointer to a function to deterministically generate a nonce.
|
||||||
|
*
|
||||||
|
* Returns: 1 if a nonce was successfully generated. 0 will cause signing to fail.
|
||||||
|
* Out: nonce32: pointer to a 32-byte array to be filled by the function.
|
||||||
|
* In: msg32: the 32-byte message hash being verified (will not be NULL)
|
||||||
|
* key32: pointer to a 32-byte secret key (will not be NULL)
|
||||||
|
* algo16: pointer to a 16-byte array describing the signature
|
||||||
|
* algorithm (will be NULL for ECDSA for compatibility).
|
||||||
|
* data: Arbitrary data pointer that is passed through.
|
||||||
|
* attempt: how many iterations we have tried to find a nonce.
|
||||||
|
* This will almost always be 0, but different attempt values
|
||||||
|
* are required to result in a different nonce.
|
||||||
|
*
|
||||||
|
* Except for test cases, this function should compute some cryptographic hash of
|
||||||
|
* the message, the algorithm, the key and the attempt.
|
||||||
|
*/
|
||||||
|
typedef int (*secp256k1_nonce_function)(
|
||||||
|
unsigned char *nonce32,
|
||||||
|
const unsigned char *msg32,
|
||||||
|
const unsigned char *key32,
|
||||||
|
const unsigned char *algo16,
|
||||||
|
void *data,
|
||||||
|
unsigned int attempt
|
||||||
|
);
|
||||||
|
|
||||||
# if !defined(SECP256K1_GNUC_PREREQ)
|
# if !defined(SECP256K1_GNUC_PREREQ)
|
||||||
# if defined(__GNUC__)&&defined(__GNUC_MINOR__)
|
# if defined(__GNUC__)&&defined(__GNUC_MINOR__)
|
||||||
# define SECP256K1_GNUC_PREREQ(_maj,_min) \
|
# define SECP256K1_GNUC_PREREQ(_maj,_min) \
|
||||||
|
@ -26,6 +119,20 @@ extern "C" {
|
||||||
# define SECP256K1_INLINE inline
|
# define SECP256K1_INLINE inline
|
||||||
# endif
|
# endif
|
||||||
|
|
||||||
|
#ifndef SECP256K1_API
|
||||||
|
# if defined(_WIN32)
|
||||||
|
# ifdef SECP256K1_BUILD
|
||||||
|
# define SECP256K1_API __declspec(dllexport)
|
||||||
|
# else
|
||||||
|
# define SECP256K1_API
|
||||||
|
# endif
|
||||||
|
# elif defined(__GNUC__) && defined(SECP256K1_BUILD)
|
||||||
|
# define SECP256K1_API __attribute__ ((visibility ("default")))
|
||||||
|
# else
|
||||||
|
# define SECP256K1_API
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
/**Warning attributes
|
/**Warning attributes
|
||||||
* NONNULL is not used if SECP256K1_BUILD is set to avoid the compiler optimizing out
|
* NONNULL is not used if SECP256K1_BUILD is set to avoid the compiler optimizing out
|
||||||
* some paranoid null checks. */
|
* some paranoid null checks. */
|
||||||
|
@ -40,305 +147,434 @@ extern "C" {
|
||||||
# define SECP256K1_ARG_NONNULL(_x)
|
# define SECP256K1_ARG_NONNULL(_x)
|
||||||
# endif
|
# endif
|
||||||
|
|
||||||
/** Opaque data structure that holds context information (precomputed tables etc.).
|
/** All flags' lower 8 bits indicate what they're for. Do not use directly. */
|
||||||
* Only functions that take a pointer to a non-const context require exclusive
|
#define SECP256K1_FLAGS_TYPE_MASK ((1 << 8) - 1)
|
||||||
* access to it. Multiple functions that take a pointer to a const context may
|
#define SECP256K1_FLAGS_TYPE_CONTEXT (1 << 0)
|
||||||
* run simultaneously.
|
#define SECP256K1_FLAGS_TYPE_COMPRESSION (1 << 1)
|
||||||
*/
|
/** The higher bits contain the actual data. Do not use directly. */
|
||||||
typedef struct secp256k1_context_struct secp256k1_context_t;
|
#define SECP256K1_FLAGS_BIT_CONTEXT_VERIFY (1 << 8)
|
||||||
|
#define SECP256K1_FLAGS_BIT_CONTEXT_SIGN (1 << 9)
|
||||||
|
#define SECP256K1_FLAGS_BIT_COMPRESSION (1 << 8)
|
||||||
|
|
||||||
/** Flags to pass to secp256k1_context_create. */
|
/** Flags to pass to secp256k1_context_create. */
|
||||||
# define SECP256K1_CONTEXT_VERIFY (1 << 0)
|
#define SECP256K1_CONTEXT_VERIFY (SECP256K1_FLAGS_TYPE_CONTEXT | SECP256K1_FLAGS_BIT_CONTEXT_VERIFY)
|
||||||
# define SECP256K1_CONTEXT_SIGN (1 << 1)
|
#define SECP256K1_CONTEXT_SIGN (SECP256K1_FLAGS_TYPE_CONTEXT | SECP256K1_FLAGS_BIT_CONTEXT_SIGN)
|
||||||
|
#define SECP256K1_CONTEXT_NONE (SECP256K1_FLAGS_TYPE_CONTEXT)
|
||||||
|
|
||||||
|
/** Flag to pass to secp256k1_ec_pubkey_serialize and secp256k1_ec_privkey_export. */
|
||||||
|
#define SECP256K1_EC_COMPRESSED (SECP256K1_FLAGS_TYPE_COMPRESSION | SECP256K1_FLAGS_BIT_COMPRESSION)
|
||||||
|
#define SECP256K1_EC_UNCOMPRESSED (SECP256K1_FLAGS_TYPE_COMPRESSION)
|
||||||
|
|
||||||
/** Create a secp256k1 context object.
|
/** Create a secp256k1 context object.
|
||||||
|
*
|
||||||
* Returns: a newly created context object.
|
* Returns: a newly created context object.
|
||||||
* In: flags: which parts of the context to initialize.
|
* In: flags: which parts of the context to initialize.
|
||||||
*/
|
*/
|
||||||
secp256k1_context_t* secp256k1_context_create(
|
SECP256K1_API secp256k1_context* secp256k1_context_create(
|
||||||
int flags
|
unsigned int flags
|
||||||
) SECP256K1_WARN_UNUSED_RESULT;
|
) SECP256K1_WARN_UNUSED_RESULT;
|
||||||
|
|
||||||
/** Copies a secp256k1 context object.
|
/** Copies a secp256k1 context object.
|
||||||
|
*
|
||||||
* Returns: a newly created context object.
|
* Returns: a newly created context object.
|
||||||
* In: ctx: an existing context to copy
|
* Args: ctx: an existing context to copy (cannot be NULL)
|
||||||
*/
|
*/
|
||||||
secp256k1_context_t* secp256k1_context_clone(
|
SECP256K1_API secp256k1_context* secp256k1_context_clone(
|
||||||
const secp256k1_context_t* ctx
|
const secp256k1_context* ctx
|
||||||
) SECP256K1_WARN_UNUSED_RESULT;
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_WARN_UNUSED_RESULT;
|
||||||
|
|
||||||
/** Destroy a secp256k1 context object.
|
/** Destroy a secp256k1 context object.
|
||||||
|
*
|
||||||
* The context pointer may not be used afterwards.
|
* The context pointer may not be used afterwards.
|
||||||
|
* Args: ctx: an existing context to destroy (cannot be NULL)
|
||||||
*/
|
*/
|
||||||
void secp256k1_context_destroy(
|
SECP256K1_API void secp256k1_context_destroy(
|
||||||
secp256k1_context_t* ctx
|
secp256k1_context* ctx
|
||||||
|
);
|
||||||
|
|
||||||
|
/** Set a callback function to be called when an illegal argument is passed to
|
||||||
|
* an API call. It will only trigger for violations that are mentioned
|
||||||
|
* explicitly in the header.
|
||||||
|
*
|
||||||
|
* The philosophy is that these shouldn't be dealt with through a
|
||||||
|
* specific return value, as calling code should not have branches to deal with
|
||||||
|
* the case that this code itself is broken.
|
||||||
|
*
|
||||||
|
* On the other hand, during debug stage, one would want to be informed about
|
||||||
|
* such mistakes, and the default (crashing) may be inadvisable.
|
||||||
|
* When this callback is triggered, the API function called is guaranteed not
|
||||||
|
* to cause a crash, though its return value and output arguments are
|
||||||
|
* undefined.
|
||||||
|
*
|
||||||
|
* Args: ctx: an existing context object (cannot be NULL)
|
||||||
|
* In: fun: a pointer to a function to call when an illegal argument is
|
||||||
|
* passed to the API, taking a message and an opaque pointer
|
||||||
|
* (NULL restores a default handler that calls abort).
|
||||||
|
* data: the opaque pointer to pass to fun above.
|
||||||
|
*/
|
||||||
|
SECP256K1_API void secp256k1_context_set_illegal_callback(
|
||||||
|
secp256k1_context* ctx,
|
||||||
|
void (*fun)(const char* message, void* data),
|
||||||
|
const void* data
|
||||||
) SECP256K1_ARG_NONNULL(1);
|
) SECP256K1_ARG_NONNULL(1);
|
||||||
|
|
||||||
/** Verify an ECDSA signature.
|
/** Set a callback function to be called when an internal consistency check
|
||||||
* Returns: 1: correct signature
|
* fails. The default is crashing.
|
||||||
* 0: incorrect signature
|
*
|
||||||
* -1: invalid public key
|
* This can only trigger in case of a hardware failure, miscompilation,
|
||||||
* -2: invalid signature
|
* memory corruption, serious bug in the library, or other error would can
|
||||||
* In: ctx: a secp256k1 context object, initialized for verification.
|
* otherwise result in undefined behaviour. It will not trigger due to mere
|
||||||
* msg32: the 32-byte message hash being verified (cannot be NULL)
|
* incorrect usage of the API (see secp256k1_context_set_illegal_callback
|
||||||
* sig: the signature being verified (cannot be NULL)
|
* for that). After this callback returns, anything may happen, including
|
||||||
* siglen: the length of the signature
|
* crashing.
|
||||||
* pubkey: the public key to verify with (cannot be NULL)
|
*
|
||||||
* pubkeylen: the length of pubkey
|
* Args: ctx: an existing context object (cannot be NULL)
|
||||||
|
* In: fun: a pointer to a function to call when an internal error occurs,
|
||||||
|
* taking a message and an opaque pointer (NULL restores a default
|
||||||
|
* handler that calls abort).
|
||||||
|
* data: the opaque pointer to pass to fun above.
|
||||||
*/
|
*/
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdsa_verify(
|
SECP256K1_API void secp256k1_context_set_error_callback(
|
||||||
const secp256k1_context_t* ctx,
|
secp256k1_context* ctx,
|
||||||
const unsigned char *msg32,
|
void (*fun)(const char* message, void* data),
|
||||||
const unsigned char *sig,
|
const void* data
|
||||||
int siglen,
|
) SECP256K1_ARG_NONNULL(1);
|
||||||
const unsigned char *pubkey,
|
|
||||||
int pubkeylen
|
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(5);
|
|
||||||
|
|
||||||
/** A pointer to a function to deterministically generate a nonce.
|
/** Parse a variable-length public key into the pubkey object.
|
||||||
* Returns: 1 if a nonce was successfully generated. 0 will cause signing to fail.
|
*
|
||||||
* In: msg32: the 32-byte message hash being verified (will not be NULL)
|
* Returns: 1 if the public key was fully valid.
|
||||||
* key32: pointer to a 32-byte secret key (will not be NULL)
|
* 0 if the public key could not be parsed or is invalid.
|
||||||
* attempt: how many iterations we have tried to find a nonce.
|
* Args: ctx: a secp256k1 context object.
|
||||||
* This will almost always be 0, but different attempt values
|
* Out: pubkey: pointer to a pubkey object. If 1 is returned, it is set to a
|
||||||
* are required to result in a different nonce.
|
* parsed version of input. If not, its value is undefined.
|
||||||
* data: Arbitrary data pointer that is passed through.
|
* In: input: pointer to a serialized public key
|
||||||
* Out: nonce32: pointer to a 32-byte array to be filled by the function.
|
* inputlen: length of the array pointed to by input
|
||||||
* Except for test cases, this function should compute some cryptographic hash of
|
*
|
||||||
* the message, the key and the attempt.
|
* This function supports parsing compressed (33 bytes, header byte 0x02 or
|
||||||
|
* 0x03), uncompressed (65 bytes, header byte 0x04), or hybrid (65 bytes, header
|
||||||
|
* byte 0x06 or 0x07) format public keys.
|
||||||
*/
|
*/
|
||||||
typedef int (*secp256k1_nonce_function_t)(
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_parse(
|
||||||
unsigned char *nonce32,
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_pubkey* pubkey,
|
||||||
|
const unsigned char *input,
|
||||||
|
size_t inputlen
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
|
/** Serialize a pubkey object into a serialized byte sequence.
|
||||||
|
*
|
||||||
|
* Returns: 1 always.
|
||||||
|
* Args: ctx: a secp256k1 context object.
|
||||||
|
* Out: output: a pointer to a 65-byte (if compressed==0) or 33-byte (if
|
||||||
|
* compressed==1) byte array to place the serialized key
|
||||||
|
* in.
|
||||||
|
* In/Out: outputlen: a pointer to an integer which is initially set to the
|
||||||
|
* size of output, and is overwritten with the written
|
||||||
|
* size.
|
||||||
|
* In: pubkey: a pointer to a secp256k1_pubkey containing an
|
||||||
|
* initialized public key.
|
||||||
|
* flags: SECP256K1_EC_COMPRESSED if serialization should be in
|
||||||
|
* compressed format, otherwise SECP256K1_EC_UNCOMPRESSED.
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_ec_pubkey_serialize(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
unsigned char *output,
|
||||||
|
size_t *outputlen,
|
||||||
|
const secp256k1_pubkey* pubkey,
|
||||||
|
unsigned int flags
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
||||||
|
|
||||||
|
/** Parse an ECDSA signature in compact (64 bytes) format.
|
||||||
|
*
|
||||||
|
* Returns: 1 when the signature could be parsed, 0 otherwise.
|
||||||
|
* Args: ctx: a secp256k1 context object
|
||||||
|
* Out: sig: a pointer to a signature object
|
||||||
|
* In: input64: a pointer to the 64-byte array to parse
|
||||||
|
*
|
||||||
|
* The signature must consist of a 32-byte big endian R value, followed by a
|
||||||
|
* 32-byte big endian S value. If R or S fall outside of [0..order-1], the
|
||||||
|
* encoding is invalid. R and S with value 0 are allowed in the encoding.
|
||||||
|
*
|
||||||
|
* After the call, sig will always be initialized. If parsing failed or R or
|
||||||
|
* S are zero, the resulting sig value is guaranteed to fail validation for any
|
||||||
|
* message and public key.
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_ecdsa_signature_parse_compact(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_ecdsa_signature* sig,
|
||||||
|
const unsigned char *input64
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
|
/** Parse a DER ECDSA signature.
|
||||||
|
*
|
||||||
|
* Returns: 1 when the signature could be parsed, 0 otherwise.
|
||||||
|
* Args: ctx: a secp256k1 context object
|
||||||
|
* Out: sig: a pointer to a signature object
|
||||||
|
* In: input: a pointer to the signature to be parsed
|
||||||
|
* inputlen: the length of the array pointed to be input
|
||||||
|
*
|
||||||
|
* This function will accept any valid DER encoded signature, even if the
|
||||||
|
* encoded numbers are out of range.
|
||||||
|
*
|
||||||
|
* After the call, sig will always be initialized. If parsing failed or the
|
||||||
|
* encoded numbers are out of range, signature validation with it is
|
||||||
|
* guaranteed to fail for every message and public key.
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_ecdsa_signature_parse_der(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_ecdsa_signature* sig,
|
||||||
|
const unsigned char *input,
|
||||||
|
size_t inputlen
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
|
/** Serialize an ECDSA signature in DER format.
|
||||||
|
*
|
||||||
|
* Returns: 1 if enough space was available to serialize, 0 otherwise
|
||||||
|
* Args: ctx: a secp256k1 context object
|
||||||
|
* Out: output: a pointer to an array to store the DER serialization
|
||||||
|
* In/Out: outputlen: a pointer to a length integer. Initially, this integer
|
||||||
|
* should be set to the length of output. After the call
|
||||||
|
* it will be set to the length of the serialization (even
|
||||||
|
* if 0 was returned).
|
||||||
|
* In: sig: a pointer to an initialized signature object
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_ecdsa_signature_serialize_der(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
unsigned char *output,
|
||||||
|
size_t *outputlen,
|
||||||
|
const secp256k1_ecdsa_signature* sig
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
||||||
|
|
||||||
|
/** Serialize an ECDSA signature in compact (64 byte) format.
|
||||||
|
*
|
||||||
|
* Returns: 1
|
||||||
|
* Args: ctx: a secp256k1 context object
|
||||||
|
* Out: output64: a pointer to a 64-byte array to store the compact serialization
|
||||||
|
* In: sig: a pointer to an initialized signature object
|
||||||
|
*
|
||||||
|
* See secp256k1_ecdsa_signature_parse_compact for details about the encoding.
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_ecdsa_signature_serialize_compact(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
unsigned char *output64,
|
||||||
|
const secp256k1_ecdsa_signature* sig
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
|
/** Verify an ECDSA signature.
|
||||||
|
*
|
||||||
|
* Returns: 1: correct signature
|
||||||
|
* 0: incorrect or unparseable signature
|
||||||
|
* Args: ctx: a secp256k1 context object, initialized for verification.
|
||||||
|
* In: sig: the signature being verified (cannot be NULL)
|
||||||
|
* msg32: the 32-byte message hash being verified (cannot be NULL)
|
||||||
|
* pubkey: pointer to an initialized public key to verify with (cannot be NULL)
|
||||||
|
*
|
||||||
|
* To avoid accepting malleable signatures, only ECDSA signatures in lower-S
|
||||||
|
* form are accepted.
|
||||||
|
*
|
||||||
|
* If you need to accept ECDSA signatures from sources that do not obey this
|
||||||
|
* rule, apply secp256k1_ecdsa_signature_normalize to the signature prior to
|
||||||
|
* validation, but be aware that doing so results in malleable signatures.
|
||||||
|
*
|
||||||
|
* For details, see the comments for that function.
|
||||||
|
*/
|
||||||
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdsa_verify(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
const secp256k1_ecdsa_signature *sig,
|
||||||
const unsigned char *msg32,
|
const unsigned char *msg32,
|
||||||
const unsigned char *key32,
|
const secp256k1_pubkey *pubkey
|
||||||
unsigned int attempt,
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
||||||
const void *data
|
|
||||||
);
|
/** Convert a signature to a normalized lower-S form.
|
||||||
|
*
|
||||||
|
* Returns: 1 if sigin was not normalized, 0 if it already was.
|
||||||
|
* Args: ctx: a secp256k1 context object
|
||||||
|
* Out: sigout: a pointer to a signature to fill with the normalized form,
|
||||||
|
* or copy if the input was already normalized. (can be NULL if
|
||||||
|
* you're only interested in whether the input was already
|
||||||
|
* normalized).
|
||||||
|
* In: sigin: a pointer to a signature to check/normalize (cannot be NULL,
|
||||||
|
* can be identical to sigout)
|
||||||
|
*
|
||||||
|
* With ECDSA a third-party can forge a second distinct signature of the same
|
||||||
|
* message, given a single initial signature, but without knowing the key. This
|
||||||
|
* is done by negating the S value modulo the order of the curve, 'flipping'
|
||||||
|
* the sign of the random point R which is not included in the signature.
|
||||||
|
*
|
||||||
|
* Forgery of the same message isn't universally problematic, but in systems
|
||||||
|
* where message malleability or uniqueness of signatures is important this can
|
||||||
|
* cause issues. This forgery can be blocked by all verifiers forcing signers
|
||||||
|
* to use a normalized form.
|
||||||
|
*
|
||||||
|
* The lower-S form reduces the size of signatures slightly on average when
|
||||||
|
* variable length encodings (such as DER) are used and is cheap to verify,
|
||||||
|
* making it a good choice. Security of always using lower-S is assured because
|
||||||
|
* anyone can trivially modify a signature after the fact to enforce this
|
||||||
|
* property anyway.
|
||||||
|
*
|
||||||
|
* The lower S value is always between 0x1 and
|
||||||
|
* 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
|
||||||
|
* inclusive.
|
||||||
|
*
|
||||||
|
* No other forms of ECDSA malleability are known and none seem likely, but
|
||||||
|
* there is no formal proof that ECDSA, even with this additional restriction,
|
||||||
|
* is free of other malleability. Commonly used serialization schemes will also
|
||||||
|
* accept various non-unique encodings, so care should be taken when this
|
||||||
|
* property is required for an application.
|
||||||
|
*
|
||||||
|
* The secp256k1_ecdsa_sign function will by default create signatures in the
|
||||||
|
* lower-S form, and secp256k1_ecdsa_verify will not accept others. In case
|
||||||
|
* signatures come from a system that cannot enforce this property,
|
||||||
|
* secp256k1_ecdsa_signature_normalize must be called before verification.
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_ecdsa_signature_normalize(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_ecdsa_signature *sigout,
|
||||||
|
const secp256k1_ecdsa_signature *sigin
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
/** An implementation of RFC6979 (using HMAC-SHA256) as nonce generation function.
|
/** An implementation of RFC6979 (using HMAC-SHA256) as nonce generation function.
|
||||||
* If a data pointer is passed, it is assumed to be a pointer to 32 bytes of
|
* If a data pointer is passed, it is assumed to be a pointer to 32 bytes of
|
||||||
* extra entropy.
|
* extra entropy.
|
||||||
*/
|
*/
|
||||||
extern const secp256k1_nonce_function_t secp256k1_nonce_function_rfc6979;
|
SECP256K1_API extern const secp256k1_nonce_function secp256k1_nonce_function_rfc6979;
|
||||||
|
|
||||||
/** A default safe nonce generation function (currently equal to secp256k1_nonce_function_rfc6979). */
|
/** A default safe nonce generation function (currently equal to secp256k1_nonce_function_rfc6979). */
|
||||||
extern const secp256k1_nonce_function_t secp256k1_nonce_function_default;
|
SECP256K1_API extern const secp256k1_nonce_function secp256k1_nonce_function_default;
|
||||||
|
|
||||||
|
|
||||||
/** Create an ECDSA signature.
|
/** Create an ECDSA signature.
|
||||||
* Returns: 1: signature created
|
|
||||||
* 0: the nonce generation function failed, the private key was invalid, or there is not
|
|
||||||
* enough space in the signature (as indicated by siglen).
|
|
||||||
* In: ctx: pointer to a context object, initialized for signing (cannot be NULL)
|
|
||||||
* msg32: the 32-byte message hash being signed (cannot be NULL)
|
|
||||||
* seckey: pointer to a 32-byte secret key (cannot be NULL)
|
|
||||||
* noncefp:pointer to a nonce generation function. If NULL, secp256k1_nonce_function_default is used
|
|
||||||
* ndata: pointer to arbitrary data used by the nonce generation function (can be NULL)
|
|
||||||
* Out: sig: pointer to an array where the signature will be placed (cannot be NULL)
|
|
||||||
* In/Out: siglen: pointer to an int with the length of sig, which will be updated
|
|
||||||
* to contain the actual signature length (<=72).
|
|
||||||
*
|
*
|
||||||
* The sig always has an s value in the lower half of the range (From 0x1
|
|
||||||
* to 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
|
|
||||||
* inclusive), unlike many other implementations.
|
|
||||||
* With ECDSA a third-party can can forge a second distinct signature
|
|
||||||
* of the same message given a single initial signature without knowing
|
|
||||||
* the key by setting s to its additive inverse mod-order, 'flipping' the
|
|
||||||
* sign of the random point R which is not included in the signature.
|
|
||||||
* Since the forgery is of the same message this isn't universally
|
|
||||||
* problematic, but in systems where message malleability or uniqueness
|
|
||||||
* of signatures is important this can cause issues. This forgery can be
|
|
||||||
* blocked by all verifiers forcing signers to use a canonical form. The
|
|
||||||
* lower-S form reduces the size of signatures slightly on average when
|
|
||||||
* variable length encodings (such as DER) are used and is cheap to
|
|
||||||
* verify, making it a good choice. Security of always using lower-S is
|
|
||||||
* assured because anyone can trivially modify a signature after the
|
|
||||||
* fact to enforce this property. Adjusting it inside the signing
|
|
||||||
* function avoids the need to re-serialize or have curve specific
|
|
||||||
* constants outside of the library. By always using a canonical form
|
|
||||||
* even in applications where it isn't needed it becomes possible to
|
|
||||||
* impose a requirement later if a need is discovered.
|
|
||||||
* No other forms of ECDSA malleability are known and none seem likely,
|
|
||||||
* but there is no formal proof that ECDSA, even with this additional
|
|
||||||
* restriction, is free of other malleability. Commonly used serialization
|
|
||||||
* schemes will also accept various non-unique encodings, so care should
|
|
||||||
* be taken when this property is required for an application.
|
|
||||||
*/
|
|
||||||
int secp256k1_ecdsa_sign(
|
|
||||||
const secp256k1_context_t* ctx,
|
|
||||||
const unsigned char *msg32,
|
|
||||||
unsigned char *sig,
|
|
||||||
int *siglen,
|
|
||||||
const unsigned char *seckey,
|
|
||||||
secp256k1_nonce_function_t noncefp,
|
|
||||||
const void *ndata
|
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4) SECP256K1_ARG_NONNULL(5);
|
|
||||||
|
|
||||||
/** Create a compact ECDSA signature (64 byte + recovery id).
|
|
||||||
* Returns: 1: signature created
|
* Returns: 1: signature created
|
||||||
* 0: the nonce generation function failed, or the secret key was invalid.
|
* 0: the nonce generation function failed, or the private key was invalid.
|
||||||
* In: ctx: pointer to a context object, initialized for signing (cannot be NULL)
|
* Args: ctx: pointer to a context object, initialized for signing (cannot be NULL)
|
||||||
* msg32: the 32-byte message hash being signed (cannot be NULL)
|
* Out: sig: pointer to an array where the signature will be placed (cannot be NULL)
|
||||||
|
* In: msg32: the 32-byte message hash being signed (cannot be NULL)
|
||||||
* seckey: pointer to a 32-byte secret key (cannot be NULL)
|
* seckey: pointer to a 32-byte secret key (cannot be NULL)
|
||||||
* noncefp:pointer to a nonce generation function. If NULL, secp256k1_nonce_function_default is used
|
* noncefp:pointer to a nonce generation function. If NULL, secp256k1_nonce_function_default is used
|
||||||
* ndata: pointer to arbitrary data used by the nonce generation function (can be NULL)
|
* ndata: pointer to arbitrary data used by the nonce generation function (can be NULL)
|
||||||
* Out: sig: pointer to a 64-byte array where the signature will be placed (cannot be NULL)
|
*
|
||||||
* In case 0 is returned, the returned signature length will be zero.
|
* The created signature is always in lower-S form. See
|
||||||
* recid: pointer to an int, which will be updated to contain the recovery id (can be NULL)
|
* secp256k1_ecdsa_signature_normalize for more details.
|
||||||
*/
|
*/
|
||||||
int secp256k1_ecdsa_sign_compact(
|
SECP256K1_API int secp256k1_ecdsa_sign(
|
||||||
const secp256k1_context_t* ctx,
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_ecdsa_signature *sig,
|
||||||
const unsigned char *msg32,
|
const unsigned char *msg32,
|
||||||
unsigned char *sig64,
|
|
||||||
const unsigned char *seckey,
|
const unsigned char *seckey,
|
||||||
secp256k1_nonce_function_t noncefp,
|
secp256k1_nonce_function noncefp,
|
||||||
const void *ndata,
|
const void *ndata
|
||||||
int *recid
|
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
||||||
|
|
||||||
/** Recover an ECDSA public key from a compact signature.
|
|
||||||
* Returns: 1: public key successfully recovered (which guarantees a correct signature).
|
|
||||||
* 0: otherwise.
|
|
||||||
* In: ctx: pointer to a context object, initialized for verification (cannot be NULL)
|
|
||||||
* msg32: the 32-byte message hash assumed to be signed (cannot be NULL)
|
|
||||||
* sig64: signature as 64 byte array (cannot be NULL)
|
|
||||||
* compressed: whether to recover a compressed or uncompressed pubkey
|
|
||||||
* recid: the recovery id (0-3, as returned by ecdsa_sign_compact)
|
|
||||||
* Out: pubkey: pointer to a 33 or 65 byte array to put the pubkey (cannot be NULL)
|
|
||||||
* pubkeylen: pointer to an int that will contain the pubkey length (cannot be NULL)
|
|
||||||
*/
|
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdsa_recover_compact(
|
|
||||||
const secp256k1_context_t* ctx,
|
|
||||||
const unsigned char *msg32,
|
|
||||||
const unsigned char *sig64,
|
|
||||||
unsigned char *pubkey,
|
|
||||||
int *pubkeylen,
|
|
||||||
int compressed,
|
|
||||||
int recid
|
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4) SECP256K1_ARG_NONNULL(5);
|
|
||||||
|
|
||||||
/** Verify an ECDSA secret key.
|
/** Verify an ECDSA secret key.
|
||||||
|
*
|
||||||
* Returns: 1: secret key is valid
|
* Returns: 1: secret key is valid
|
||||||
* 0: secret key is invalid
|
* 0: secret key is invalid
|
||||||
* In: ctx: pointer to a context object (cannot be NULL)
|
* Args: ctx: pointer to a context object (cannot be NULL)
|
||||||
* seckey: pointer to a 32-byte secret key (cannot be NULL)
|
* In: seckey: pointer to a 32-byte secret key (cannot be NULL)
|
||||||
*/
|
*/
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_seckey_verify(
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_seckey_verify(
|
||||||
const secp256k1_context_t* ctx,
|
const secp256k1_context* ctx,
|
||||||
const unsigned char *seckey
|
const unsigned char *seckey
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2);
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2);
|
||||||
|
|
||||||
/** Just validate a public key.
|
|
||||||
* Returns: 1: public key is valid
|
|
||||||
* 0: public key is invalid
|
|
||||||
* In: ctx: pointer to a context object (cannot be NULL)
|
|
||||||
* pubkey: pointer to a 33-byte or 65-byte public key (cannot be NULL).
|
|
||||||
* pubkeylen: length of pubkey
|
|
||||||
*/
|
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_verify(
|
|
||||||
const secp256k1_context_t* ctx,
|
|
||||||
const unsigned char *pubkey,
|
|
||||||
int pubkeylen
|
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2);
|
|
||||||
|
|
||||||
/** Compute the public key for a secret key.
|
/** Compute the public key for a secret key.
|
||||||
* In: ctx: pointer to a context object, initialized for signing (cannot be NULL)
|
*
|
||||||
* compressed: whether the computed public key should be compressed
|
|
||||||
* seckey: pointer to a 32-byte private key (cannot be NULL)
|
|
||||||
* Out: pubkey: pointer to a 33-byte (if compressed) or 65-byte (if uncompressed)
|
|
||||||
* area to store the public key (cannot be NULL)
|
|
||||||
* pubkeylen: pointer to int that will be updated to contains the pubkey's
|
|
||||||
* length (cannot be NULL)
|
|
||||||
* Returns: 1: secret was valid, public key stores
|
* Returns: 1: secret was valid, public key stores
|
||||||
* 0: secret was invalid, try again
|
* 0: secret was invalid, try again
|
||||||
|
* Args: ctx: pointer to a context object, initialized for signing (cannot be NULL)
|
||||||
|
* Out: pubkey: pointer to the created public key (cannot be NULL)
|
||||||
|
* In: seckey: pointer to a 32-byte private key (cannot be NULL)
|
||||||
*/
|
*/
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_create(
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_create(
|
||||||
const secp256k1_context_t* ctx,
|
const secp256k1_context* ctx,
|
||||||
unsigned char *pubkey,
|
secp256k1_pubkey *pubkey,
|
||||||
int *pubkeylen,
|
const unsigned char *seckey
|
||||||
const unsigned char *seckey,
|
|
||||||
int compressed
|
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
|
||||||
|
|
||||||
/** Decompress a public key.
|
|
||||||
* In: ctx: pointer to a context object (cannot be NULL)
|
|
||||||
* In/Out: pubkey: pointer to a 65-byte array to put the decompressed public key.
|
|
||||||
* It must contain a 33-byte or 65-byte public key already (cannot be NULL)
|
|
||||||
* pubkeylen: pointer to the size of the public key pointed to by pubkey (cannot be NULL)
|
|
||||||
* It will be updated to reflect the new size.
|
|
||||||
* Returns: 0: pubkey was invalid
|
|
||||||
* 1: pubkey was valid, and was replaced with its decompressed version
|
|
||||||
*/
|
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_decompress(
|
|
||||||
const secp256k1_context_t* ctx,
|
|
||||||
unsigned char *pubkey,
|
|
||||||
int *pubkeylen
|
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
/** Export a private key in DER format.
|
/** Tweak a private key by adding tweak to it.
|
||||||
* In: ctx: pointer to a context object, initialized for signing (cannot be NULL)
|
* Returns: 0 if the tweak was out of range (chance of around 1 in 2^128 for
|
||||||
|
* uniformly random 32-byte arrays, or if the resulting private key
|
||||||
|
* would be invalid (only when the tweak is the complement of the
|
||||||
|
* private key). 1 otherwise.
|
||||||
|
* Args: ctx: pointer to a context object (cannot be NULL).
|
||||||
|
* In/Out: seckey: pointer to a 32-byte private key.
|
||||||
|
* In: tweak: pointer to a 32-byte tweak.
|
||||||
*/
|
*/
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_export(
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_tweak_add(
|
||||||
const secp256k1_context_t* ctx,
|
const secp256k1_context* ctx,
|
||||||
const unsigned char *seckey,
|
|
||||||
unsigned char *privkey,
|
|
||||||
int *privkeylen,
|
|
||||||
int compressed
|
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
|
||||||
|
|
||||||
/** Import a private key in DER format. */
|
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_import(
|
|
||||||
const secp256k1_context_t* ctx,
|
|
||||||
unsigned char *seckey,
|
|
||||||
const unsigned char *privkey,
|
|
||||||
int privkeylen
|
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
|
||||||
|
|
||||||
/** Tweak a private key by adding tweak to it. */
|
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_tweak_add(
|
|
||||||
const secp256k1_context_t* ctx,
|
|
||||||
unsigned char *seckey,
|
unsigned char *seckey,
|
||||||
const unsigned char *tweak
|
const unsigned char *tweak
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
/** Tweak a public key by adding tweak times the generator to it.
|
/** Tweak a public key by adding tweak times the generator to it.
|
||||||
* In: ctx: pointer to a context object, initialized for verification (cannot be NULL)
|
* Returns: 0 if the tweak was out of range (chance of around 1 in 2^128 for
|
||||||
|
* uniformly random 32-byte arrays, or if the resulting public key
|
||||||
|
* would be invalid (only when the tweak is the complement of the
|
||||||
|
* corresponding private key). 1 otherwise.
|
||||||
|
* Args: ctx: pointer to a context object initialized for validation
|
||||||
|
* (cannot be NULL).
|
||||||
|
* In/Out: pubkey: pointer to a public key object.
|
||||||
|
* In: tweak: pointer to a 32-byte tweak.
|
||||||
*/
|
*/
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_tweak_add(
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_tweak_add(
|
||||||
const secp256k1_context_t* ctx,
|
const secp256k1_context* ctx,
|
||||||
unsigned char *pubkey,
|
secp256k1_pubkey *pubkey,
|
||||||
int pubkeylen,
|
|
||||||
const unsigned char *tweak
|
const unsigned char *tweak
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(4);
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
/** Tweak a private key by multiplying it with tweak. */
|
/** Tweak a private key by multiplying it by a tweak.
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_tweak_mul(
|
* Returns: 0 if the tweak was out of range (chance of around 1 in 2^128 for
|
||||||
const secp256k1_context_t* ctx,
|
* uniformly random 32-byte arrays, or equal to zero. 1 otherwise.
|
||||||
|
* Args: ctx: pointer to a context object (cannot be NULL).
|
||||||
|
* In/Out: seckey: pointer to a 32-byte private key.
|
||||||
|
* In: tweak: pointer to a 32-byte tweak.
|
||||||
|
*/
|
||||||
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_tweak_mul(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
unsigned char *seckey,
|
unsigned char *seckey,
|
||||||
const unsigned char *tweak
|
const unsigned char *tweak
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
/** Tweak a public key by multiplying it with tweak.
|
/** Tweak a public key by multiplying it by a tweak value.
|
||||||
* In: ctx: pointer to a context object, initialized for verification (cannot be NULL)
|
* Returns: 0 if the tweak was out of range (chance of around 1 in 2^128 for
|
||||||
|
* uniformly random 32-byte arrays, or equal to zero. 1 otherwise.
|
||||||
|
* Args: ctx: pointer to a context object initialized for validation
|
||||||
|
* (cannot be NULL).
|
||||||
|
* In/Out: pubkey: pointer to a public key obkect.
|
||||||
|
* In: tweak: pointer to a 32-byte tweak.
|
||||||
*/
|
*/
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_tweak_mul(
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_tweak_mul(
|
||||||
const secp256k1_context_t* ctx,
|
const secp256k1_context* ctx,
|
||||||
unsigned char *pubkey,
|
secp256k1_pubkey *pubkey,
|
||||||
int pubkeylen,
|
|
||||||
const unsigned char *tweak
|
const unsigned char *tweak
|
||||||
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(4);
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
/** Updates the context randomization.
|
/** Updates the context randomization.
|
||||||
* Returns: 1: randomization successfully updated
|
* Returns: 1: randomization successfully updated
|
||||||
* 0: error
|
* 0: error
|
||||||
* In: ctx: pointer to a context object (cannot be NULL)
|
* Args: ctx: pointer to a context object (cannot be NULL)
|
||||||
* seed32: pointer to a 32-byte random seed (NULL resets to initial state)
|
* In: seed32: pointer to a 32-byte random seed (NULL resets to initial state)
|
||||||
*/
|
*/
|
||||||
SECP256K1_WARN_UNUSED_RESULT int secp256k1_context_randomize(
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_context_randomize(
|
||||||
secp256k1_context_t* ctx,
|
secp256k1_context* ctx,
|
||||||
const unsigned char *seed32
|
const unsigned char *seed32
|
||||||
) SECP256K1_ARG_NONNULL(1);
|
) SECP256K1_ARG_NONNULL(1);
|
||||||
|
|
||||||
|
/** Add a number of public keys together.
|
||||||
|
* Returns: 1: the sum of the public keys is valid.
|
||||||
|
* 0: the sum of the public keys is not valid.
|
||||||
|
* Args: ctx: pointer to a context object
|
||||||
|
* Out: out: pointer to a public key object for placing the resulting public key
|
||||||
|
* (cannot be NULL)
|
||||||
|
* In: ins: pointer to array of pointers to public keys (cannot be NULL)
|
||||||
|
* n: the number of public keys to add together (must be at least 1)
|
||||||
|
*/
|
||||||
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_combine(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_pubkey *out,
|
||||||
|
const secp256k1_pubkey * const * ins,
|
||||||
|
size_t n
|
||||||
|
) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
# ifdef __cplusplus
|
# ifdef __cplusplus
|
||||||
}
|
}
|
||||||
|
|
|
@ -0,0 +1,31 @@
|
||||||
|
#ifndef _SECP256K1_ECDH_
|
||||||
|
# define _SECP256K1_ECDH_
|
||||||
|
|
||||||
|
# include "secp256k1.h"
|
||||||
|
|
||||||
|
# ifdef __cplusplus
|
||||||
|
extern "C" {
|
||||||
|
# endif
|
||||||
|
|
||||||
|
/** Compute an EC Diffie-Hellman secret in constant time
|
||||||
|
* Returns: 1: exponentiation was successful
|
||||||
|
* 0: scalar was invalid (zero or overflow)
|
||||||
|
* Args: ctx: pointer to a context object (cannot be NULL)
|
||||||
|
* Out: result: a 32-byte array which will be populated by an ECDH
|
||||||
|
* secret computed from the point and scalar
|
||||||
|
* In: pubkey: a pointer to a secp256k1_pubkey containing an
|
||||||
|
* initialized public key
|
||||||
|
* privkey: a 32-byte scalar with which to multiply the point
|
||||||
|
*/
|
||||||
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdh(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
unsigned char *result,
|
||||||
|
const secp256k1_pubkey *pubkey,
|
||||||
|
const unsigned char *privkey
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
||||||
|
|
||||||
|
# ifdef __cplusplus
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,110 @@
|
||||||
|
#ifndef _SECP256K1_RECOVERY_
|
||||||
|
# define _SECP256K1_RECOVERY_
|
||||||
|
|
||||||
|
# include "secp256k1.h"
|
||||||
|
|
||||||
|
# ifdef __cplusplus
|
||||||
|
extern "C" {
|
||||||
|
# endif
|
||||||
|
|
||||||
|
/** Opaque data structured that holds a parsed ECDSA signature,
|
||||||
|
* supporting pubkey recovery.
|
||||||
|
*
|
||||||
|
* The exact representation of data inside is implementation defined and not
|
||||||
|
* guaranteed to be portable between different platforms or versions. It is
|
||||||
|
* however guaranteed to be 65 bytes in size, and can be safely copied/moved.
|
||||||
|
* If you need to convert to a format suitable for storage or transmission, use
|
||||||
|
* the secp256k1_ecdsa_signature_serialize_* and
|
||||||
|
* secp256k1_ecdsa_signature_parse_* functions.
|
||||||
|
*
|
||||||
|
* Furthermore, it is guaranteed that identical signatures (including their
|
||||||
|
* recoverability) will have identical representation, so they can be
|
||||||
|
* memcmp'ed.
|
||||||
|
*/
|
||||||
|
typedef struct {
|
||||||
|
unsigned char data[65];
|
||||||
|
} secp256k1_ecdsa_recoverable_signature;
|
||||||
|
|
||||||
|
/** Parse a compact ECDSA signature (64 bytes + recovery id).
|
||||||
|
*
|
||||||
|
* Returns: 1 when the signature could be parsed, 0 otherwise
|
||||||
|
* Args: ctx: a secp256k1 context object
|
||||||
|
* Out: sig: a pointer to a signature object
|
||||||
|
* In: input64: a pointer to a 64-byte compact signature
|
||||||
|
* recid: the recovery id (0, 1, 2 or 3)
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_ecdsa_recoverable_signature_parse_compact(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_ecdsa_recoverable_signature* sig,
|
||||||
|
const unsigned char *input64,
|
||||||
|
int recid
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
|
/** Convert a recoverable signature into a normal signature.
|
||||||
|
*
|
||||||
|
* Returns: 1
|
||||||
|
* Out: sig: a pointer to a normal signature (cannot be NULL).
|
||||||
|
* In: sigin: a pointer to a recoverable signature (cannot be NULL).
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_ecdsa_recoverable_signature_convert(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_ecdsa_signature* sig,
|
||||||
|
const secp256k1_ecdsa_recoverable_signature* sigin
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
|
/** Serialize an ECDSA signature in compact format (64 bytes + recovery id).
|
||||||
|
*
|
||||||
|
* Returns: 1
|
||||||
|
* Args: ctx: a secp256k1 context object
|
||||||
|
* Out: output64: a pointer to a 64-byte array of the compact signature (cannot be NULL)
|
||||||
|
* recid: a pointer to an integer to hold the recovery id (can be NULL).
|
||||||
|
* In: sig: a pointer to an initialized signature object (cannot be NULL)
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_ecdsa_recoverable_signature_serialize_compact(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
unsigned char *output64,
|
||||||
|
int *recid,
|
||||||
|
const secp256k1_ecdsa_recoverable_signature* sig
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
||||||
|
|
||||||
|
/** Create a recoverable ECDSA signature.
|
||||||
|
*
|
||||||
|
* Returns: 1: signature created
|
||||||
|
* 0: the nonce generation function failed, or the private key was invalid.
|
||||||
|
* Args: ctx: pointer to a context object, initialized for signing (cannot be NULL)
|
||||||
|
* Out: sig: pointer to an array where the signature will be placed (cannot be NULL)
|
||||||
|
* In: msg32: the 32-byte message hash being signed (cannot be NULL)
|
||||||
|
* seckey: pointer to a 32-byte secret key (cannot be NULL)
|
||||||
|
* noncefp:pointer to a nonce generation function. If NULL, secp256k1_nonce_function_default is used
|
||||||
|
* ndata: pointer to arbitrary data used by the nonce generation function (can be NULL)
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_ecdsa_sign_recoverable(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_ecdsa_recoverable_signature *sig,
|
||||||
|
const unsigned char *msg32,
|
||||||
|
const unsigned char *seckey,
|
||||||
|
secp256k1_nonce_function noncefp,
|
||||||
|
const void *ndata
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
||||||
|
|
||||||
|
/** Recover an ECDSA public key from a signature.
|
||||||
|
*
|
||||||
|
* Returns: 1: public key successfully recovered (which guarantees a correct signature).
|
||||||
|
* 0: otherwise.
|
||||||
|
* Args: ctx: pointer to a context object, initialized for verification (cannot be NULL)
|
||||||
|
* Out: pubkey: pointer to the recovered public key (cannot be NULL)
|
||||||
|
* In: sig: pointer to initialized signature that supports pubkey recovery (cannot be NULL)
|
||||||
|
* msg32: the 32-byte message hash assumed to be signed (cannot be NULL)
|
||||||
|
*/
|
||||||
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdsa_recover(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_pubkey *pubkey,
|
||||||
|
const secp256k1_ecdsa_recoverable_signature *sig,
|
||||||
|
const unsigned char *msg32
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
||||||
|
|
||||||
|
# ifdef __cplusplus
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,173 @@
|
||||||
|
#ifndef _SECP256K1_SCHNORR_
|
||||||
|
# define _SECP256K1_SCHNORR_
|
||||||
|
|
||||||
|
# include "secp256k1.h"
|
||||||
|
|
||||||
|
# ifdef __cplusplus
|
||||||
|
extern "C" {
|
||||||
|
# endif
|
||||||
|
|
||||||
|
/** Create a signature using a custom EC-Schnorr-SHA256 construction. It
|
||||||
|
* produces non-malleable 64-byte signatures which support public key recovery
|
||||||
|
* batch validation, and multiparty signing.
|
||||||
|
* Returns: 1: signature created
|
||||||
|
* 0: the nonce generation function failed, or the private key was
|
||||||
|
* invalid.
|
||||||
|
* Args: ctx: pointer to a context object, initialized for signing
|
||||||
|
* (cannot be NULL)
|
||||||
|
* Out: sig64: pointer to a 64-byte array where the signature will be
|
||||||
|
* placed (cannot be NULL)
|
||||||
|
* In: msg32: the 32-byte message hash being signed (cannot be NULL)
|
||||||
|
* seckey: pointer to a 32-byte secret key (cannot be NULL)
|
||||||
|
* noncefp:pointer to a nonce generation function. If NULL,
|
||||||
|
* secp256k1_nonce_function_default is used
|
||||||
|
* ndata: pointer to arbitrary data used by the nonce generation
|
||||||
|
* function (can be NULL)
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_schnorr_sign(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
unsigned char *sig64,
|
||||||
|
const unsigned char *msg32,
|
||||||
|
const unsigned char *seckey,
|
||||||
|
secp256k1_nonce_function noncefp,
|
||||||
|
const void *ndata
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
||||||
|
|
||||||
|
/** Verify a signature created by secp256k1_schnorr_sign.
|
||||||
|
* Returns: 1: correct signature
|
||||||
|
* 0: incorrect signature
|
||||||
|
* Args: ctx: a secp256k1 context object, initialized for verification.
|
||||||
|
* In: sig64: the 64-byte signature being verified (cannot be NULL)
|
||||||
|
* msg32: the 32-byte message hash being verified (cannot be NULL)
|
||||||
|
* pubkey: the public key to verify with (cannot be NULL)
|
||||||
|
*/
|
||||||
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_schnorr_verify(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
const unsigned char *sig64,
|
||||||
|
const unsigned char *msg32,
|
||||||
|
const secp256k1_pubkey *pubkey
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
||||||
|
|
||||||
|
/** Recover an EC public key from a Schnorr signature created using
|
||||||
|
* secp256k1_schnorr_sign.
|
||||||
|
* Returns: 1: public key successfully recovered (which guarantees a correct
|
||||||
|
* signature).
|
||||||
|
* 0: otherwise.
|
||||||
|
* Args: ctx: pointer to a context object, initialized for
|
||||||
|
* verification (cannot be NULL)
|
||||||
|
* Out: pubkey: pointer to a pubkey to set to the recovered public key
|
||||||
|
* (cannot be NULL).
|
||||||
|
* In: sig64: signature as 64 byte array (cannot be NULL)
|
||||||
|
* msg32: the 32-byte message hash assumed to be signed (cannot
|
||||||
|
* be NULL)
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_schnorr_recover(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_pubkey *pubkey,
|
||||||
|
const unsigned char *sig64,
|
||||||
|
const unsigned char *msg32
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
|
||||||
|
|
||||||
|
/** Generate a nonce pair deterministically for use with
|
||||||
|
* secp256k1_schnorr_partial_sign.
|
||||||
|
* Returns: 1: valid nonce pair was generated.
|
||||||
|
* 0: otherwise (nonce generation function failed)
|
||||||
|
* Args: ctx: pointer to a context object, initialized for signing
|
||||||
|
* (cannot be NULL)
|
||||||
|
* Out: pubnonce: public side of the nonce (cannot be NULL)
|
||||||
|
* privnonce32: private side of the nonce (32 byte) (cannot be NULL)
|
||||||
|
* In: msg32: the 32-byte message hash assumed to be signed (cannot
|
||||||
|
* be NULL)
|
||||||
|
* sec32: the 32-byte private key (cannot be NULL)
|
||||||
|
* noncefp: pointer to a nonce generation function. If NULL,
|
||||||
|
* secp256k1_nonce_function_default is used
|
||||||
|
* noncedata: pointer to arbitrary data used by the nonce generation
|
||||||
|
* function (can be NULL)
|
||||||
|
*
|
||||||
|
* Do not use the output as a private/public key pair for signing/validation.
|
||||||
|
*/
|
||||||
|
SECP256K1_API int secp256k1_schnorr_generate_nonce_pair(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
secp256k1_pubkey *pubnonce,
|
||||||
|
unsigned char *privnonce32,
|
||||||
|
const unsigned char *msg32,
|
||||||
|
const unsigned char *sec32,
|
||||||
|
secp256k1_nonce_function noncefp,
|
||||||
|
const void* noncedata
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
|
/** Produce a partial Schnorr signature, which can be combined using
|
||||||
|
* secp256k1_schnorr_partial_combine, to end up with a full signature that is
|
||||||
|
* verifiable using secp256k1_schnorr_verify.
|
||||||
|
* Returns: 1: signature created successfully.
|
||||||
|
* 0: no valid signature exists with this combination of keys, nonces
|
||||||
|
* and message (chance around 1 in 2^128)
|
||||||
|
* -1: invalid private key, nonce, or public nonces.
|
||||||
|
* Args: ctx: pointer to context object, initialized for signing (cannot
|
||||||
|
* be NULL)
|
||||||
|
* Out: sig64: pointer to 64-byte array to put partial signature in
|
||||||
|
* In: msg32: pointer to 32-byte message to sign
|
||||||
|
* sec32: pointer to 32-byte private key
|
||||||
|
* pubnonce_others: pointer to pubkey containing the sum of the other's
|
||||||
|
* nonces (see secp256k1_ec_pubkey_combine)
|
||||||
|
* secnonce32: pointer to 32-byte array containing our nonce
|
||||||
|
*
|
||||||
|
* The intended procedure for creating a multiparty signature is:
|
||||||
|
* - Each signer S[i] with private key x[i] and public key Q[i] runs
|
||||||
|
* secp256k1_schnorr_generate_nonce_pair to produce a pair (k[i],R[i]) of
|
||||||
|
* private/public nonces.
|
||||||
|
* - All signers communicate their public nonces to each other (revealing your
|
||||||
|
* private nonce can lead to discovery of your private key, so it should be
|
||||||
|
* considered secret).
|
||||||
|
* - All signers combine all the public nonces they received (excluding their
|
||||||
|
* own) using secp256k1_ec_pubkey_combine to obtain an
|
||||||
|
* Rall[i] = sum(R[0..i-1,i+1..n]).
|
||||||
|
* - All signers produce a partial signature using
|
||||||
|
* secp256k1_schnorr_partial_sign, passing in their own private key x[i],
|
||||||
|
* their own private nonce k[i], and the sum of the others' public nonces
|
||||||
|
* Rall[i].
|
||||||
|
* - All signers communicate their partial signatures to each other.
|
||||||
|
* - Someone combines all partial signatures using
|
||||||
|
* secp256k1_schnorr_partial_combine, to obtain a full signature.
|
||||||
|
* - The resulting signature is validatable using secp256k1_schnorr_verify, with
|
||||||
|
* public key equal to the result of secp256k1_ec_pubkey_combine of the
|
||||||
|
* signers' public keys (sum(Q[0..n])).
|
||||||
|
*
|
||||||
|
* Note that secp256k1_schnorr_partial_combine and secp256k1_ec_pubkey_combine
|
||||||
|
* function take their arguments in any order, and it is possible to
|
||||||
|
* pre-combine several inputs already with one call, and add more inputs later
|
||||||
|
* by calling the function again (they are commutative and associative).
|
||||||
|
*/
|
||||||
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_schnorr_partial_sign(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
unsigned char *sig64,
|
||||||
|
const unsigned char *msg32,
|
||||||
|
const unsigned char *sec32,
|
||||||
|
const secp256k1_pubkey *pubnonce_others,
|
||||||
|
const unsigned char *secnonce32
|
||||||
|
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4) SECP256K1_ARG_NONNULL(5) SECP256K1_ARG_NONNULL(6);
|
||||||
|
|
||||||
|
/** Combine multiple Schnorr partial signatures.
|
||||||
|
* Returns: 1: the passed signatures were successfully combined.
|
||||||
|
* 0: the resulting signature is not valid (chance of 1 in 2^256)
|
||||||
|
* -1: some inputs were invalid, or the signatures were not created
|
||||||
|
* using the same set of nonces
|
||||||
|
* Args: ctx: pointer to a context object
|
||||||
|
* Out: sig64: pointer to a 64-byte array to place the combined signature
|
||||||
|
* (cannot be NULL)
|
||||||
|
* In: sig64sin: pointer to an array of n pointers to 64-byte input
|
||||||
|
* signatures
|
||||||
|
* n: the number of signatures to combine (at least 1)
|
||||||
|
*/
|
||||||
|
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_schnorr_partial_combine(
|
||||||
|
const secp256k1_context* ctx,
|
||||||
|
unsigned char *sig64,
|
||||||
|
const unsigned char * const * sig64sin,
|
||||||
|
size_t n
|
||||||
|
) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
|
||||||
|
|
||||||
|
# ifdef __cplusplus
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,32 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2013, 2014 Pieter Wuille *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#ifndef _SECP256K1_BASIC_CONFIG_
|
||||||
|
#define _SECP256K1_BASIC_CONFIG_
|
||||||
|
|
||||||
|
#ifdef USE_BASIC_CONFIG
|
||||||
|
|
||||||
|
#undef USE_ASM_X86_64
|
||||||
|
#undef USE_ENDOMORPHISM
|
||||||
|
#undef USE_FIELD_10X26
|
||||||
|
#undef USE_FIELD_5X52
|
||||||
|
#undef USE_FIELD_INV_BUILTIN
|
||||||
|
#undef USE_FIELD_INV_NUM
|
||||||
|
#undef USE_NUM_GMP
|
||||||
|
#undef USE_NUM_NONE
|
||||||
|
#undef USE_SCALAR_4X64
|
||||||
|
#undef USE_SCALAR_8X32
|
||||||
|
#undef USE_SCALAR_INV_BUILTIN
|
||||||
|
#undef USE_SCALAR_INV_NUM
|
||||||
|
|
||||||
|
#define USE_NUM_NONE 1
|
||||||
|
#define USE_FIELD_INV_BUILTIN 1
|
||||||
|
#define USE_SCALAR_INV_BUILTIN 1
|
||||||
|
#define USE_FIELD_10X26 1
|
||||||
|
#define USE_SCALAR_8X32 1
|
||||||
|
|
||||||
|
#endif // USE_BASIC_CONFIG
|
||||||
|
#endif // _SECP256K1_BASIC_CONFIG_
|
20
src/bench.h
20
src/bench.h
|
@ -20,7 +20,9 @@ static double gettimedouble(void) {
|
||||||
void print_number(double x) {
|
void print_number(double x) {
|
||||||
double y = x;
|
double y = x;
|
||||||
int c = 0;
|
int c = 0;
|
||||||
if (y < 0.0) y = -y;
|
if (y < 0.0) {
|
||||||
|
y = -y;
|
||||||
|
}
|
||||||
while (y < 100.0) {
|
while (y < 100.0) {
|
||||||
y *= 10.0;
|
y *= 10.0;
|
||||||
c++;
|
c++;
|
||||||
|
@ -35,13 +37,21 @@ void run_benchmark(char *name, void (*benchmark)(void*), void (*setup)(void*), v
|
||||||
double max = 0.0;
|
double max = 0.0;
|
||||||
for (i = 0; i < count; i++) {
|
for (i = 0; i < count; i++) {
|
||||||
double begin, total;
|
double begin, total;
|
||||||
if (setup) setup(data);
|
if (setup != NULL) {
|
||||||
|
setup(data);
|
||||||
|
}
|
||||||
begin = gettimedouble();
|
begin = gettimedouble();
|
||||||
benchmark(data);
|
benchmark(data);
|
||||||
total = gettimedouble() - begin;
|
total = gettimedouble() - begin;
|
||||||
if (teardown) teardown(data);
|
if (teardown != NULL) {
|
||||||
if (total < min) min = total;
|
teardown(data);
|
||||||
if (total > max) max = total;
|
}
|
||||||
|
if (total < min) {
|
||||||
|
min = total;
|
||||||
|
}
|
||||||
|
if (total > max) {
|
||||||
|
max = total;
|
||||||
|
}
|
||||||
sum += total;
|
sum += total;
|
||||||
}
|
}
|
||||||
printf("%s: min ", name);
|
printf("%s: min ", name);
|
||||||
|
|
|
@ -0,0 +1,53 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2015 Pieter Wuille, Andrew Poelstra *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
#include "include/secp256k1.h"
|
||||||
|
#include "include/secp256k1_ecdh.h"
|
||||||
|
#include "util.h"
|
||||||
|
#include "bench.h"
|
||||||
|
|
||||||
|
typedef struct {
|
||||||
|
secp256k1_context *ctx;
|
||||||
|
secp256k1_pubkey point;
|
||||||
|
unsigned char scalar[32];
|
||||||
|
} bench_ecdh_t;
|
||||||
|
|
||||||
|
static void bench_ecdh_setup(void* arg) {
|
||||||
|
int i;
|
||||||
|
bench_ecdh_t *data = (bench_ecdh_t*)arg;
|
||||||
|
const unsigned char point[] = {
|
||||||
|
0x03,
|
||||||
|
0x54, 0x94, 0xc1, 0x5d, 0x32, 0x09, 0x97, 0x06,
|
||||||
|
0xc2, 0x39, 0x5f, 0x94, 0x34, 0x87, 0x45, 0xfd,
|
||||||
|
0x75, 0x7c, 0xe3, 0x0e, 0x4e, 0x8c, 0x90, 0xfb,
|
||||||
|
0xa2, 0xba, 0xd1, 0x84, 0xf8, 0x83, 0xc6, 0x9f
|
||||||
|
};
|
||||||
|
|
||||||
|
data->ctx = secp256k1_context_create(0);
|
||||||
|
for (i = 0; i < 32; i++) {
|
||||||
|
data->scalar[i] = i + 1;
|
||||||
|
}
|
||||||
|
CHECK(secp256k1_ec_pubkey_parse(data->ctx, &data->point, point, sizeof(point)) == 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void bench_ecdh(void* arg) {
|
||||||
|
int i;
|
||||||
|
unsigned char res[32];
|
||||||
|
bench_ecdh_t *data = (bench_ecdh_t*)arg;
|
||||||
|
|
||||||
|
for (i = 0; i < 20000; i++) {
|
||||||
|
CHECK(secp256k1_ecdh(data->ctx, res, &data->point, data->scalar) == 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int main(void) {
|
||||||
|
bench_ecdh_t data;
|
||||||
|
|
||||||
|
run_benchmark("ecdh", bench_ecdh, bench_ecdh_setup, NULL, &data, 10, 20000);
|
||||||
|
return 0;
|
||||||
|
}
|
|
@ -13,15 +13,17 @@
|
||||||
#include "field_impl.h"
|
#include "field_impl.h"
|
||||||
#include "group_impl.h"
|
#include "group_impl.h"
|
||||||
#include "scalar_impl.h"
|
#include "scalar_impl.h"
|
||||||
|
#include "ecmult_const_impl.h"
|
||||||
#include "ecmult_impl.h"
|
#include "ecmult_impl.h"
|
||||||
#include "bench.h"
|
#include "bench.h"
|
||||||
|
#include "secp256k1.c"
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
secp256k1_scalar_t scalar_x, scalar_y;
|
secp256k1_scalar scalar_x, scalar_y;
|
||||||
secp256k1_fe_t fe_x, fe_y;
|
secp256k1_fe fe_x, fe_y;
|
||||||
secp256k1_ge_t ge_x, ge_y;
|
secp256k1_ge ge_x, ge_y;
|
||||||
secp256k1_gej_t gej_x, gej_y;
|
secp256k1_gej gej_x, gej_y;
|
||||||
unsigned char data[32];
|
unsigned char data[64];
|
||||||
int wnaf[256];
|
int wnaf[256];
|
||||||
} bench_inv_t;
|
} bench_inv_t;
|
||||||
|
|
||||||
|
@ -51,6 +53,7 @@ void bench_setup(void* arg) {
|
||||||
secp256k1_gej_set_ge(&data->gej_x, &data->ge_x);
|
secp256k1_gej_set_ge(&data->gej_x, &data->ge_x);
|
||||||
secp256k1_gej_set_ge(&data->gej_y, &data->ge_y);
|
secp256k1_gej_set_ge(&data->gej_y, &data->ge_y);
|
||||||
memcpy(data->data, init_x, 32);
|
memcpy(data->data, init_x, 32);
|
||||||
|
memcpy(data->data + 32, init_y, 32);
|
||||||
}
|
}
|
||||||
|
|
||||||
void bench_scalar_add(void* arg) {
|
void bench_scalar_add(void* arg) {
|
||||||
|
@ -95,8 +98,8 @@ void bench_scalar_split(void* arg) {
|
||||||
bench_inv_t *data = (bench_inv_t*)arg;
|
bench_inv_t *data = (bench_inv_t*)arg;
|
||||||
|
|
||||||
for (i = 0; i < 20000; i++) {
|
for (i = 0; i < 20000; i++) {
|
||||||
secp256k1_scalar_t l, r;
|
secp256k1_scalar l, r;
|
||||||
secp256k1_scalar_split_lambda_var(&l, &r, &data->scalar_x);
|
secp256k1_scalar_split_lambda(&l, &r, &data->scalar_x);
|
||||||
secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
|
secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -193,7 +196,7 @@ void bench_group_double_var(void* arg) {
|
||||||
bench_inv_t *data = (bench_inv_t*)arg;
|
bench_inv_t *data = (bench_inv_t*)arg;
|
||||||
|
|
||||||
for (i = 0; i < 200000; i++) {
|
for (i = 0; i < 200000; i++) {
|
||||||
secp256k1_gej_double_var(&data->gej_x, &data->gej_x);
|
secp256k1_gej_double_var(&data->gej_x, &data->gej_x, NULL);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -202,7 +205,7 @@ void bench_group_add_var(void* arg) {
|
||||||
bench_inv_t *data = (bench_inv_t*)arg;
|
bench_inv_t *data = (bench_inv_t*)arg;
|
||||||
|
|
||||||
for (i = 0; i < 200000; i++) {
|
for (i = 0; i < 200000; i++) {
|
||||||
secp256k1_gej_add_var(&data->gej_x, &data->gej_x, &data->gej_y);
|
secp256k1_gej_add_var(&data->gej_x, &data->gej_x, &data->gej_y, NULL);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -220,7 +223,7 @@ void bench_group_add_affine_var(void* arg) {
|
||||||
bench_inv_t *data = (bench_inv_t*)arg;
|
bench_inv_t *data = (bench_inv_t*)arg;
|
||||||
|
|
||||||
for (i = 0; i < 200000; i++) {
|
for (i = 0; i < 200000; i++) {
|
||||||
secp256k1_gej_add_ge_var(&data->gej_x, &data->gej_x, &data->ge_y);
|
secp256k1_gej_add_ge_var(&data->gej_x, &data->gej_x, &data->ge_y, NULL);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -229,7 +232,17 @@ void bench_ecmult_wnaf(void* arg) {
|
||||||
bench_inv_t *data = (bench_inv_t*)arg;
|
bench_inv_t *data = (bench_inv_t*)arg;
|
||||||
|
|
||||||
for (i = 0; i < 20000; i++) {
|
for (i = 0; i < 20000; i++) {
|
||||||
secp256k1_ecmult_wnaf(data->wnaf, &data->scalar_x, WINDOW_A);
|
secp256k1_ecmult_wnaf(data->wnaf, 256, &data->scalar_x, WINDOW_A);
|
||||||
|
secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void bench_wnaf_const(void* arg) {
|
||||||
|
int i;
|
||||||
|
bench_inv_t *data = (bench_inv_t*)arg;
|
||||||
|
|
||||||
|
for (i = 0; i < 20000; i++) {
|
||||||
|
secp256k1_wnaf_const(data->wnaf, data->scalar_x, WINDOW_A);
|
||||||
secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
|
secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -265,11 +278,27 @@ void bench_rfc6979_hmac_sha256(void* arg) {
|
||||||
secp256k1_rfc6979_hmac_sha256_t rng;
|
secp256k1_rfc6979_hmac_sha256_t rng;
|
||||||
|
|
||||||
for (i = 0; i < 20000; i++) {
|
for (i = 0; i < 20000; i++) {
|
||||||
secp256k1_rfc6979_hmac_sha256_initialize(&rng, data->data, 32, data->data, 32, NULL, 0);
|
secp256k1_rfc6979_hmac_sha256_initialize(&rng, data->data, 64);
|
||||||
secp256k1_rfc6979_hmac_sha256_generate(&rng, data->data, 32);
|
secp256k1_rfc6979_hmac_sha256_generate(&rng, data->data, 32);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void bench_context_verify(void* arg) {
|
||||||
|
int i;
|
||||||
|
(void)arg;
|
||||||
|
for (i = 0; i < 20; i++) {
|
||||||
|
secp256k1_context_destroy(secp256k1_context_create(SECP256K1_CONTEXT_VERIFY));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void bench_context_sign(void* arg) {
|
||||||
|
int i;
|
||||||
|
(void)arg;
|
||||||
|
for (i = 0; i < 200; i++) {
|
||||||
|
secp256k1_context_destroy(secp256k1_context_create(SECP256K1_CONTEXT_SIGN));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
int have_flag(int argc, char** argv, char *flag) {
|
int have_flag(int argc, char** argv, char *flag) {
|
||||||
char** argm = argv + argc;
|
char** argm = argv + argc;
|
||||||
|
@ -278,7 +307,9 @@ int have_flag(int argc, char** argv, char *flag) {
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
while (argv != NULL && argv != argm) {
|
while (argv != NULL && argv != argm) {
|
||||||
if (strcmp(*argv, flag) == 0) return 1;
|
if (strcmp(*argv, flag) == 0) {
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
argv++;
|
argv++;
|
||||||
}
|
}
|
||||||
return 0;
|
return 0;
|
||||||
|
@ -309,10 +340,15 @@ int main(int argc, char **argv) {
|
||||||
if (have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_affine", bench_group_add_affine, bench_setup, NULL, &data, 10, 200000);
|
if (have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_affine", bench_group_add_affine, bench_setup, NULL, &data, 10, 200000);
|
||||||
if (have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_affine_var", bench_group_add_affine_var, bench_setup, NULL, &data, 10, 200000);
|
if (have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_affine_var", bench_group_add_affine_var, bench_setup, NULL, &data, 10, 200000);
|
||||||
|
|
||||||
|
if (have_flag(argc, argv, "ecmult") || have_flag(argc, argv, "wnaf")) run_benchmark("wnaf_const", bench_wnaf_const, bench_setup, NULL, &data, 10, 20000);
|
||||||
if (have_flag(argc, argv, "ecmult") || have_flag(argc, argv, "wnaf")) run_benchmark("ecmult_wnaf", bench_ecmult_wnaf, bench_setup, NULL, &data, 10, 20000);
|
if (have_flag(argc, argv, "ecmult") || have_flag(argc, argv, "wnaf")) run_benchmark("ecmult_wnaf", bench_ecmult_wnaf, bench_setup, NULL, &data, 10, 20000);
|
||||||
|
|
||||||
if (have_flag(argc, argv, "hash") || have_flag(argc, argv, "sha256")) run_benchmark("hash_sha256", bench_sha256, bench_setup, NULL, &data, 10, 20000);
|
if (have_flag(argc, argv, "hash") || have_flag(argc, argv, "sha256")) run_benchmark("hash_sha256", bench_sha256, bench_setup, NULL, &data, 10, 20000);
|
||||||
if (have_flag(argc, argv, "hash") || have_flag(argc, argv, "hmac")) run_benchmark("hash_hmac_sha256", bench_hmac_sha256, bench_setup, NULL, &data, 10, 20000);
|
if (have_flag(argc, argv, "hash") || have_flag(argc, argv, "hmac")) run_benchmark("hash_hmac_sha256", bench_hmac_sha256, bench_setup, NULL, &data, 10, 20000);
|
||||||
if (have_flag(argc, argv, "hash") || have_flag(argc, argv, "rng6979")) run_benchmark("hash_rfc6979_hmac_sha256", bench_rfc6979_hmac_sha256, bench_setup, NULL, &data, 10, 20000);
|
if (have_flag(argc, argv, "hash") || have_flag(argc, argv, "rng6979")) run_benchmark("hash_rfc6979_hmac_sha256", bench_rfc6979_hmac_sha256, bench_setup, NULL, &data, 10, 20000);
|
||||||
|
|
||||||
|
if (have_flag(argc, argv, "context") || have_flag(argc, argv, "verify")) run_benchmark("context_verify", bench_context_verify, bench_setup, NULL, &data, 10, 20);
|
||||||
|
if (have_flag(argc, argv, "context") || have_flag(argc, argv, "sign")) run_benchmark("context_sign", bench_context_sign, bench_setup, NULL, &data, 10, 200);
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,15 +1,16 @@
|
||||||
/**********************************************************************
|
/**********************************************************************
|
||||||
* Copyright (c) 2014 Pieter Wuille *
|
* Copyright (c) 2014-2015 Pieter Wuille *
|
||||||
* Distributed under the MIT software license, see the accompanying *
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
**********************************************************************/
|
**********************************************************************/
|
||||||
|
|
||||||
#include "include/secp256k1.h"
|
#include "include/secp256k1.h"
|
||||||
|
#include "include/secp256k1_recovery.h"
|
||||||
#include "util.h"
|
#include "util.h"
|
||||||
#include "bench.h"
|
#include "bench.h"
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
secp256k1_context_t *ctx;
|
secp256k1_context *ctx;
|
||||||
unsigned char msg[32];
|
unsigned char msg[32];
|
||||||
unsigned char sig[64];
|
unsigned char sig[64];
|
||||||
} bench_recover_t;
|
} bench_recover_t;
|
||||||
|
@ -17,16 +18,20 @@ typedef struct {
|
||||||
void bench_recover(void* arg) {
|
void bench_recover(void* arg) {
|
||||||
int i;
|
int i;
|
||||||
bench_recover_t *data = (bench_recover_t*)arg;
|
bench_recover_t *data = (bench_recover_t*)arg;
|
||||||
unsigned char pubkey[33];
|
secp256k1_pubkey pubkey;
|
||||||
|
unsigned char pubkeyc[33];
|
||||||
|
|
||||||
for (i = 0; i < 20000; i++) {
|
for (i = 0; i < 20000; i++) {
|
||||||
int j;
|
int j;
|
||||||
int pubkeylen = 33;
|
size_t pubkeylen = 33;
|
||||||
CHECK(secp256k1_ecdsa_recover_compact(data->ctx, data->msg, data->sig, pubkey, &pubkeylen, 1, i % 2));
|
secp256k1_ecdsa_recoverable_signature sig;
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(data->ctx, &sig, data->sig, i % 2));
|
||||||
|
CHECK(secp256k1_ecdsa_recover(data->ctx, &pubkey, &sig, data->msg));
|
||||||
|
CHECK(secp256k1_ec_pubkey_serialize(data->ctx, pubkeyc, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED));
|
||||||
for (j = 0; j < 32; j++) {
|
for (j = 0; j < 32; j++) {
|
||||||
data->sig[j + 32] = data->msg[j]; /* Move former message to S. */
|
data->sig[j + 32] = data->msg[j]; /* Move former message to S. */
|
||||||
data->msg[j] = data->sig[j]; /* Move former R to message. */
|
data->msg[j] = data->sig[j]; /* Move former R to message. */
|
||||||
data->sig[j] = pubkey[j + 1]; /* Move recovered pubkey X coordinate to R (which must be a valid X coordinate). */
|
data->sig[j] = pubkeyc[j + 1]; /* Move recovered pubkey X coordinate to R (which must be a valid X coordinate). */
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -35,8 +40,12 @@ void bench_recover_setup(void* arg) {
|
||||||
int i;
|
int i;
|
||||||
bench_recover_t *data = (bench_recover_t*)arg;
|
bench_recover_t *data = (bench_recover_t*)arg;
|
||||||
|
|
||||||
for (i = 0; i < 32; i++) data->msg[i] = 1 + i;
|
for (i = 0; i < 32; i++) {
|
||||||
for (i = 0; i < 64; i++) data->sig[i] = 65 + i;
|
data->msg[i] = 1 + i;
|
||||||
|
}
|
||||||
|
for (i = 0; i < 64; i++) {
|
||||||
|
data->sig[i] = 65 + i;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
int main(void) {
|
int main(void) {
|
||||||
|
|
|
@ -0,0 +1,73 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2014 Pieter Wuille *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
#include "include/secp256k1.h"
|
||||||
|
#include "include/secp256k1_schnorr.h"
|
||||||
|
#include "util.h"
|
||||||
|
#include "bench.h"
|
||||||
|
|
||||||
|
typedef struct {
|
||||||
|
unsigned char key[32];
|
||||||
|
unsigned char sig[64];
|
||||||
|
unsigned char pubkey[33];
|
||||||
|
size_t pubkeylen;
|
||||||
|
} benchmark_schnorr_sig_t;
|
||||||
|
|
||||||
|
typedef struct {
|
||||||
|
secp256k1_context *ctx;
|
||||||
|
unsigned char msg[32];
|
||||||
|
benchmark_schnorr_sig_t sigs[64];
|
||||||
|
int numsigs;
|
||||||
|
} benchmark_schnorr_verify_t;
|
||||||
|
|
||||||
|
static void benchmark_schnorr_init(void* arg) {
|
||||||
|
int i, k;
|
||||||
|
benchmark_schnorr_verify_t* data = (benchmark_schnorr_verify_t*)arg;
|
||||||
|
|
||||||
|
for (i = 0; i < 32; i++) {
|
||||||
|
data->msg[i] = 1 + i;
|
||||||
|
}
|
||||||
|
for (k = 0; k < data->numsigs; k++) {
|
||||||
|
secp256k1_pubkey pubkey;
|
||||||
|
for (i = 0; i < 32; i++) {
|
||||||
|
data->sigs[k].key[i] = 33 + i + k;
|
||||||
|
}
|
||||||
|
secp256k1_schnorr_sign(data->ctx, data->sigs[k].sig, data->msg, data->sigs[k].key, NULL, NULL);
|
||||||
|
data->sigs[k].pubkeylen = 33;
|
||||||
|
CHECK(secp256k1_ec_pubkey_create(data->ctx, &pubkey, data->sigs[k].key));
|
||||||
|
CHECK(secp256k1_ec_pubkey_serialize(data->ctx, data->sigs[k].pubkey, &data->sigs[k].pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void benchmark_schnorr_verify(void* arg) {
|
||||||
|
int i;
|
||||||
|
benchmark_schnorr_verify_t* data = (benchmark_schnorr_verify_t*)arg;
|
||||||
|
|
||||||
|
for (i = 0; i < 20000 / data->numsigs; i++) {
|
||||||
|
secp256k1_pubkey pubkey;
|
||||||
|
data->sigs[0].sig[(i >> 8) % 64] ^= (i & 0xFF);
|
||||||
|
CHECK(secp256k1_ec_pubkey_parse(data->ctx, &pubkey, data->sigs[0].pubkey, data->sigs[0].pubkeylen));
|
||||||
|
CHECK(secp256k1_schnorr_verify(data->ctx, data->sigs[0].sig, data->msg, &pubkey) == ((i & 0xFF) == 0));
|
||||||
|
data->sigs[0].sig[(i >> 8) % 64] ^= (i & 0xFF);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
int main(void) {
|
||||||
|
benchmark_schnorr_verify_t data;
|
||||||
|
|
||||||
|
data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
|
||||||
|
|
||||||
|
data.numsigs = 1;
|
||||||
|
run_benchmark("schnorr_verify", benchmark_schnorr_verify, benchmark_schnorr_init, NULL, &data, 10, 20000);
|
||||||
|
|
||||||
|
secp256k1_context_destroy(data.ctx);
|
||||||
|
return 0;
|
||||||
|
}
|
|
@ -9,7 +9,7 @@
|
||||||
#include "bench.h"
|
#include "bench.h"
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
secp256k1_context_t* ctx;
|
secp256k1_context* ctx;
|
||||||
unsigned char msg[32];
|
unsigned char msg[32];
|
||||||
unsigned char key[32];
|
unsigned char key[32];
|
||||||
} bench_sign_t;
|
} bench_sign_t;
|
||||||
|
@ -18,22 +18,28 @@ static void bench_sign_setup(void* arg) {
|
||||||
int i;
|
int i;
|
||||||
bench_sign_t *data = (bench_sign_t*)arg;
|
bench_sign_t *data = (bench_sign_t*)arg;
|
||||||
|
|
||||||
for (i = 0; i < 32; i++) data->msg[i] = i + 1;
|
for (i = 0; i < 32; i++) {
|
||||||
for (i = 0; i < 32; i++) data->key[i] = i + 65;
|
data->msg[i] = i + 1;
|
||||||
|
}
|
||||||
|
for (i = 0; i < 32; i++) {
|
||||||
|
data->key[i] = i + 65;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void bench_sign(void* arg) {
|
static void bench_sign(void* arg) {
|
||||||
int i;
|
int i;
|
||||||
bench_sign_t *data = (bench_sign_t*)arg;
|
bench_sign_t *data = (bench_sign_t*)arg;
|
||||||
|
|
||||||
unsigned char sig[64];
|
unsigned char sig[74];
|
||||||
for (i = 0; i < 20000; i++) {
|
for (i = 0; i < 20000; i++) {
|
||||||
|
size_t siglen = 74;
|
||||||
int j;
|
int j;
|
||||||
int recid = 0;
|
secp256k1_ecdsa_signature signature;
|
||||||
CHECK(secp256k1_ecdsa_sign_compact(data->ctx, data->msg, sig, data->key, NULL, NULL, &recid));
|
CHECK(secp256k1_ecdsa_sign(data->ctx, &signature, data->msg, data->key, NULL, NULL));
|
||||||
|
CHECK(secp256k1_ecdsa_signature_serialize_der(data->ctx, sig, &siglen, &signature));
|
||||||
for (j = 0; j < 32; j++) {
|
for (j = 0; j < 32; j++) {
|
||||||
data->msg[j] = sig[j]; /* Move former R to message. */
|
data->msg[j] = sig[j];
|
||||||
data->key[j] = sig[j + 32]; /* Move former S to key. */
|
data->key[j] = sig[j + 32];
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -12,13 +12,13 @@
|
||||||
#include "bench.h"
|
#include "bench.h"
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
secp256k1_context_t *ctx;
|
secp256k1_context *ctx;
|
||||||
unsigned char msg[32];
|
unsigned char msg[32];
|
||||||
unsigned char key[32];
|
unsigned char key[32];
|
||||||
unsigned char sig[72];
|
unsigned char sig[72];
|
||||||
int siglen;
|
size_t siglen;
|
||||||
unsigned char pubkey[33];
|
unsigned char pubkey[33];
|
||||||
int pubkeylen;
|
size_t pubkeylen;
|
||||||
} benchmark_verify_t;
|
} benchmark_verify_t;
|
||||||
|
|
||||||
static void benchmark_verify(void* arg) {
|
static void benchmark_verify(void* arg) {
|
||||||
|
@ -26,10 +26,14 @@ static void benchmark_verify(void* arg) {
|
||||||
benchmark_verify_t* data = (benchmark_verify_t*)arg;
|
benchmark_verify_t* data = (benchmark_verify_t*)arg;
|
||||||
|
|
||||||
for (i = 0; i < 20000; i++) {
|
for (i = 0; i < 20000; i++) {
|
||||||
|
secp256k1_pubkey pubkey;
|
||||||
|
secp256k1_ecdsa_signature sig;
|
||||||
data->sig[data->siglen - 1] ^= (i & 0xFF);
|
data->sig[data->siglen - 1] ^= (i & 0xFF);
|
||||||
data->sig[data->siglen - 2] ^= ((i >> 8) & 0xFF);
|
data->sig[data->siglen - 2] ^= ((i >> 8) & 0xFF);
|
||||||
data->sig[data->siglen - 3] ^= ((i >> 16) & 0xFF);
|
data->sig[data->siglen - 3] ^= ((i >> 16) & 0xFF);
|
||||||
CHECK(secp256k1_ecdsa_verify(data->ctx, data->msg, data->sig, data->siglen, data->pubkey, data->pubkeylen) == (i == 0));
|
CHECK(secp256k1_ec_pubkey_parse(data->ctx, &pubkey, data->pubkey, data->pubkeylen) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(data->ctx, &sig, data->sig, data->siglen) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_verify(data->ctx, &sig, data->msg, &pubkey) == (i == 0));
|
||||||
data->sig[data->siglen - 1] ^= (i & 0xFF);
|
data->sig[data->siglen - 1] ^= (i & 0xFF);
|
||||||
data->sig[data->siglen - 2] ^= ((i >> 8) & 0xFF);
|
data->sig[data->siglen - 2] ^= ((i >> 8) & 0xFF);
|
||||||
data->sig[data->siglen - 3] ^= ((i >> 16) & 0xFF);
|
data->sig[data->siglen - 3] ^= ((i >> 16) & 0xFF);
|
||||||
|
@ -38,16 +42,24 @@ static void benchmark_verify(void* arg) {
|
||||||
|
|
||||||
int main(void) {
|
int main(void) {
|
||||||
int i;
|
int i;
|
||||||
|
secp256k1_pubkey pubkey;
|
||||||
|
secp256k1_ecdsa_signature sig;
|
||||||
benchmark_verify_t data;
|
benchmark_verify_t data;
|
||||||
|
|
||||||
data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
|
data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
|
||||||
|
|
||||||
for (i = 0; i < 32; i++) data.msg[i] = 1 + i;
|
for (i = 0; i < 32; i++) {
|
||||||
for (i = 0; i < 32; i++) data.key[i] = 33 + i;
|
data.msg[i] = 1 + i;
|
||||||
|
}
|
||||||
|
for (i = 0; i < 32; i++) {
|
||||||
|
data.key[i] = 33 + i;
|
||||||
|
}
|
||||||
data.siglen = 72;
|
data.siglen = 72;
|
||||||
secp256k1_ecdsa_sign(data.ctx, data.msg, data.sig, &data.siglen, data.key, NULL, NULL);
|
CHECK(secp256k1_ecdsa_sign(data.ctx, &sig, data.msg, data.key, NULL, NULL));
|
||||||
|
CHECK(secp256k1_ecdsa_signature_serialize_der(data.ctx, data.sig, &data.siglen, &sig));
|
||||||
|
CHECK(secp256k1_ec_pubkey_create(data.ctx, &pubkey, data.key));
|
||||||
data.pubkeylen = 33;
|
data.pubkeylen = 33;
|
||||||
CHECK(secp256k1_ec_pubkey_create(data.ctx, data.pubkey, &data.pubkeylen, data.key, 1));
|
CHECK(secp256k1_ec_pubkey_serialize(data.ctx, data.pubkey, &data.pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED) == 1);
|
||||||
|
|
||||||
run_benchmark("ecdsa_verify", benchmark_verify, NULL, NULL, &data, 10, 20000);
|
run_benchmark("ecdsa_verify", benchmark_verify, NULL, NULL, &data, 10, 20000);
|
||||||
|
|
||||||
|
|
15
src/ecdsa.h
15
src/ecdsa.h
|
@ -7,18 +7,15 @@
|
||||||
#ifndef _SECP256K1_ECDSA_
|
#ifndef _SECP256K1_ECDSA_
|
||||||
#define _SECP256K1_ECDSA_
|
#define _SECP256K1_ECDSA_
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
|
||||||
#include "scalar.h"
|
#include "scalar.h"
|
||||||
#include "group.h"
|
#include "group.h"
|
||||||
#include "ecmult.h"
|
#include "ecmult.h"
|
||||||
|
|
||||||
typedef struct {
|
static int secp256k1_ecdsa_sig_parse(secp256k1_scalar *r, secp256k1_scalar *s, const unsigned char *sig, size_t size);
|
||||||
secp256k1_scalar_t r, s;
|
static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, size_t *size, const secp256k1_scalar *r, const secp256k1_scalar *s);
|
||||||
} secp256k1_ecdsa_sig_t;
|
static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context *ctx, const secp256k1_scalar* r, const secp256k1_scalar* s, const secp256k1_ge *pubkey, const secp256k1_scalar *message);
|
||||||
|
static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context *ctx, secp256k1_scalar* r, secp256k1_scalar* s, const secp256k1_scalar *seckey, const secp256k1_scalar *message, const secp256k1_scalar *nonce, int *recid);
|
||||||
static int secp256k1_ecdsa_sig_parse(secp256k1_ecdsa_sig_t *r, const unsigned char *sig, int size);
|
|
||||||
static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, int *size, const secp256k1_ecdsa_sig_t *a);
|
|
||||||
static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context_t *ctx, const secp256k1_ecdsa_sig_t *sig, const secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message);
|
|
||||||
static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context_t *ctx, secp256k1_ecdsa_sig_t *sig, const secp256k1_scalar_t *seckey, const secp256k1_scalar_t *message, const secp256k1_scalar_t *nonce, int *recid);
|
|
||||||
static int secp256k1_ecdsa_sig_recover(const secp256k1_ecmult_context_t *ctx, const secp256k1_ecdsa_sig_t *sig, secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message, int recid);
|
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
260
src/ecdsa_impl.h
260
src/ecdsa_impl.h
|
@ -1,5 +1,5 @@
|
||||||
/**********************************************************************
|
/**********************************************************************
|
||||||
* Copyright (c) 2013, 2014 Pieter Wuille *
|
* Copyright (c) 2013-2015 Pieter Wuille *
|
||||||
* Distributed under the MIT software license, see the accompanying *
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
**********************************************************************/
|
**********************************************************************/
|
||||||
|
@ -28,7 +28,7 @@
|
||||||
* sage: '%x' % (EllipticCurve ([F (a), F (b)]).order())
|
* sage: '%x' % (EllipticCurve ([F (a), F (b)]).order())
|
||||||
* 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'
|
* 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'
|
||||||
*/
|
*/
|
||||||
static const secp256k1_fe_t secp256k1_ecdsa_const_order_as_fe = SECP256K1_FE_CONST(
|
static const secp256k1_fe secp256k1_ecdsa_const_order_as_fe = SECP256K1_FE_CONST(
|
||||||
0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL,
|
0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL,
|
||||||
0xBAAEDCE6UL, 0xAF48A03BUL, 0xBFD25E8CUL, 0xD0364141UL
|
0xBAAEDCE6UL, 0xAF48A03BUL, 0xBFD25E8CUL, 0xD0364141UL
|
||||||
);
|
);
|
||||||
|
@ -42,82 +42,150 @@ static const secp256k1_fe_t secp256k1_ecdsa_const_order_as_fe = SECP256K1_FE_CON
|
||||||
* sage: '%x' % (p - EllipticCurve ([F (a), F (b)]).order())
|
* sage: '%x' % (p - EllipticCurve ([F (a), F (b)]).order())
|
||||||
* '14551231950b75fc4402da1722fc9baee'
|
* '14551231950b75fc4402da1722fc9baee'
|
||||||
*/
|
*/
|
||||||
static const secp256k1_fe_t secp256k1_ecdsa_const_p_minus_order = SECP256K1_FE_CONST(
|
static const secp256k1_fe secp256k1_ecdsa_const_p_minus_order = SECP256K1_FE_CONST(
|
||||||
0, 0, 0, 1, 0x45512319UL, 0x50B75FC4UL, 0x402DA172UL, 0x2FC9BAEEUL
|
0, 0, 0, 1, 0x45512319UL, 0x50B75FC4UL, 0x402DA172UL, 0x2FC9BAEEUL
|
||||||
);
|
);
|
||||||
|
|
||||||
static int secp256k1_ecdsa_sig_parse(secp256k1_ecdsa_sig_t *r, const unsigned char *sig, int size) {
|
static int secp256k1_der_read_len(const unsigned char **sigp, const unsigned char *sigend) {
|
||||||
unsigned char ra[32] = {0}, sa[32] = {0};
|
int lenleft, b1;
|
||||||
const unsigned char *rp;
|
size_t ret = 0;
|
||||||
const unsigned char *sp;
|
if (*sigp >= sigend) {
|
||||||
int lenr;
|
return -1;
|
||||||
int lens;
|
}
|
||||||
int overflow;
|
b1 = *((*sigp)++);
|
||||||
if (sig[0] != 0x30) {
|
if (b1 == 0xFF) {
|
||||||
|
/* X.690-0207 8.1.3.5.c the value 0xFF shall not be used. */
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
if ((b1 & 0x80) == 0) {
|
||||||
|
/* X.690-0207 8.1.3.4 short form length octets */
|
||||||
|
return b1;
|
||||||
|
}
|
||||||
|
if (b1 == 0x80) {
|
||||||
|
/* Indefinite length is not allowed in DER. */
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
/* X.690-207 8.1.3.5 long form length octets */
|
||||||
|
lenleft = b1 & 0x7F;
|
||||||
|
if (lenleft > sigend - *sigp) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
if (**sigp == 0) {
|
||||||
|
/* Not the shortest possible length encoding. */
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
if ((size_t)lenleft > sizeof(size_t)) {
|
||||||
|
/* The resulting length would exceed the range of a size_t, so
|
||||||
|
* certainly longer than the passed array size.
|
||||||
|
*/
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
while (lenleft > 0) {
|
||||||
|
if ((ret >> ((sizeof(size_t) - 1) * 8)) != 0) {
|
||||||
|
}
|
||||||
|
ret = (ret << 8) | **sigp;
|
||||||
|
if (ret + lenleft > (size_t)(sigend - *sigp)) {
|
||||||
|
/* Result exceeds the length of the passed array. */
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
(*sigp)++;
|
||||||
|
lenleft--;
|
||||||
|
}
|
||||||
|
if (ret < 128) {
|
||||||
|
/* Not the shortest possible length encoding. */
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int secp256k1_der_parse_integer(secp256k1_scalar *r, const unsigned char **sig, const unsigned char *sigend) {
|
||||||
|
int overflow = 0;
|
||||||
|
unsigned char ra[32] = {0};
|
||||||
|
int rlen;
|
||||||
|
|
||||||
|
if (*sig == sigend || **sig != 0x02) {
|
||||||
|
/* Not a primitive integer (X.690-0207 8.3.1). */
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
lenr = sig[3];
|
(*sig)++;
|
||||||
if (5+lenr >= size) {
|
rlen = secp256k1_der_read_len(sig, sigend);
|
||||||
|
if (rlen <= 0 || (*sig) + rlen > sigend) {
|
||||||
|
/* Exceeds bounds or not at least length 1 (X.690-0207 8.3.1). */
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
lens = sig[lenr+5];
|
if (**sig == 0x00 && rlen > 1 && (((*sig)[1]) & 0x80) == 0x00) {
|
||||||
if (sig[1] != lenr+lens+4) {
|
/* Excessive 0x00 padding. */
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
if (lenr+lens+6 > size) {
|
if (**sig == 0xFF && rlen > 1 && (((*sig)[1]) & 0x80) == 0x80) {
|
||||||
|
/* Excessive 0xFF padding. */
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
if (sig[2] != 0x02) {
|
if ((**sig & 0x80) == 0x80) {
|
||||||
return 0;
|
/* Negative. */
|
||||||
|
overflow = 1;
|
||||||
}
|
}
|
||||||
if (lenr == 0) {
|
while (rlen > 0 && **sig == 0) {
|
||||||
return 0;
|
/* Skip leading zero bytes */
|
||||||
|
rlen--;
|
||||||
|
(*sig)++;
|
||||||
}
|
}
|
||||||
if (sig[lenr+4] != 0x02) {
|
if (rlen > 32) {
|
||||||
return 0;
|
overflow = 1;
|
||||||
}
|
}
|
||||||
if (lens == 0) {
|
if (!overflow) {
|
||||||
return 0;
|
memcpy(ra + 32 - rlen, *sig, rlen);
|
||||||
|
secp256k1_scalar_set_b32(r, ra, &overflow);
|
||||||
}
|
}
|
||||||
sp = sig + 6 + lenr;
|
|
||||||
while (lens > 0 && sp[0] == 0) {
|
|
||||||
lens--;
|
|
||||||
sp++;
|
|
||||||
}
|
|
||||||
if (lens > 32) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
rp = sig + 4;
|
|
||||||
while (lenr > 0 && rp[0] == 0) {
|
|
||||||
lenr--;
|
|
||||||
rp++;
|
|
||||||
}
|
|
||||||
if (lenr > 32) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
memcpy(ra + 32 - lenr, rp, lenr);
|
|
||||||
memcpy(sa + 32 - lens, sp, lens);
|
|
||||||
overflow = 0;
|
|
||||||
secp256k1_scalar_set_b32(&r->r, ra, &overflow);
|
|
||||||
if (overflow) {
|
if (overflow) {
|
||||||
return 0;
|
secp256k1_scalar_set_int(r, 0);
|
||||||
}
|
|
||||||
secp256k1_scalar_set_b32(&r->s, sa, &overflow);
|
|
||||||
if (overflow) {
|
|
||||||
return 0;
|
|
||||||
}
|
}
|
||||||
|
(*sig) += rlen;
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, int *size, const secp256k1_ecdsa_sig_t *a) {
|
static int secp256k1_ecdsa_sig_parse(secp256k1_scalar *rr, secp256k1_scalar *rs, const unsigned char *sig, size_t size) {
|
||||||
|
const unsigned char *sigend = sig + size;
|
||||||
|
int rlen;
|
||||||
|
if (sig == sigend || *(sig++) != 0x30) {
|
||||||
|
/* The encoding doesn't start with a constructed sequence (X.690-0207 8.9.1). */
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
rlen = secp256k1_der_read_len(&sig, sigend);
|
||||||
|
if (rlen < 0 || sig + rlen > sigend) {
|
||||||
|
/* Tuple exceeds bounds */
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (sig + rlen != sigend) {
|
||||||
|
/* Garbage after tuple. */
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!secp256k1_der_parse_integer(rr, &sig, sigend)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (!secp256k1_der_parse_integer(rs, &sig, sigend)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (sig != sigend) {
|
||||||
|
/* Trailing garbage inside tuple. */
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, size_t *size, const secp256k1_scalar* ar, const secp256k1_scalar* as) {
|
||||||
unsigned char r[33] = {0}, s[33] = {0};
|
unsigned char r[33] = {0}, s[33] = {0};
|
||||||
unsigned char *rp = r, *sp = s;
|
unsigned char *rp = r, *sp = s;
|
||||||
int lenR = 33, lenS = 33;
|
size_t lenR = 33, lenS = 33;
|
||||||
secp256k1_scalar_get_b32(&r[1], &a->r);
|
secp256k1_scalar_get_b32(&r[1], ar);
|
||||||
secp256k1_scalar_get_b32(&s[1], &a->s);
|
secp256k1_scalar_get_b32(&s[1], as);
|
||||||
while (lenR > 1 && rp[0] == 0 && rp[1] < 0x80) { lenR--; rp++; }
|
while (lenR > 1 && rp[0] == 0 && rp[1] < 0x80) { lenR--; rp++; }
|
||||||
while (lenS > 1 && sp[0] == 0 && sp[1] < 0x80) { lenS--; sp++; }
|
while (lenS > 1 && sp[0] == 0 && sp[1] < 0x80) { lenS--; sp++; }
|
||||||
if (*size < 6+lenS+lenR) {
|
if (*size < 6+lenS+lenR) {
|
||||||
|
*size = 6 + lenS + lenR;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
*size = 6 + lenS + lenR;
|
*size = 6 + lenS + lenR;
|
||||||
|
@ -132,26 +200,26 @@ static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, int *size, const se
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context_t *ctx, const secp256k1_ecdsa_sig_t *sig, const secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message) {
|
static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context *ctx, const secp256k1_scalar *sigr, const secp256k1_scalar *sigs, const secp256k1_ge *pubkey, const secp256k1_scalar *message) {
|
||||||
unsigned char c[32];
|
unsigned char c[32];
|
||||||
secp256k1_scalar_t sn, u1, u2;
|
secp256k1_scalar sn, u1, u2;
|
||||||
secp256k1_fe_t xr;
|
secp256k1_fe xr;
|
||||||
secp256k1_gej_t pubkeyj;
|
secp256k1_gej pubkeyj;
|
||||||
secp256k1_gej_t pr;
|
secp256k1_gej pr;
|
||||||
|
|
||||||
if (secp256k1_scalar_is_zero(&sig->r) || secp256k1_scalar_is_zero(&sig->s)) {
|
if (secp256k1_scalar_is_zero(sigr) || secp256k1_scalar_is_zero(sigs)) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
secp256k1_scalar_inverse_var(&sn, &sig->s);
|
secp256k1_scalar_inverse_var(&sn, sigs);
|
||||||
secp256k1_scalar_mul(&u1, &sn, message);
|
secp256k1_scalar_mul(&u1, &sn, message);
|
||||||
secp256k1_scalar_mul(&u2, &sn, &sig->r);
|
secp256k1_scalar_mul(&u2, &sn, sigr);
|
||||||
secp256k1_gej_set_ge(&pubkeyj, pubkey);
|
secp256k1_gej_set_ge(&pubkeyj, pubkey);
|
||||||
secp256k1_ecmult(ctx, &pr, &pubkeyj, &u2, &u1);
|
secp256k1_ecmult(ctx, &pr, &pubkeyj, &u2, &u1);
|
||||||
if (secp256k1_gej_is_infinity(&pr)) {
|
if (secp256k1_gej_is_infinity(&pr)) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
secp256k1_scalar_get_b32(c, &sig->r);
|
secp256k1_scalar_get_b32(c, sigr);
|
||||||
secp256k1_fe_set_b32(&xr, c);
|
secp256k1_fe_set_b32(&xr, c);
|
||||||
|
|
||||||
/** We now have the recomputed R point in pr, and its claimed x coordinate (modulo n)
|
/** We now have the recomputed R point in pr, and its claimed x coordinate (modulo n)
|
||||||
|
@ -171,11 +239,11 @@ static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context_t *ctx, con
|
||||||
* secp256k1_gej_eq_x implements the (xr * pr.z^2 mod p == pr.x) test.
|
* secp256k1_gej_eq_x implements the (xr * pr.z^2 mod p == pr.x) test.
|
||||||
*/
|
*/
|
||||||
if (secp256k1_gej_eq_x_var(&xr, &pr)) {
|
if (secp256k1_gej_eq_x_var(&xr, &pr)) {
|
||||||
/* xr.x == xr * xr.z^2 mod p, so the signature is valid. */
|
/* xr * pr.z^2 mod p == pr.x, so the signature is valid. */
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
if (secp256k1_fe_cmp_var(&xr, &secp256k1_ecdsa_const_p_minus_order) >= 0) {
|
if (secp256k1_fe_cmp_var(&xr, &secp256k1_ecdsa_const_p_minus_order) >= 0) {
|
||||||
/* xr + p >= n, so we can skip testing the second case. */
|
/* xr + n >= p, so we can skip testing the second case. */
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
secp256k1_fe_add(&xr, &secp256k1_ecdsa_const_order_as_fe);
|
secp256k1_fe_add(&xr, &secp256k1_ecdsa_const_order_as_fe);
|
||||||
|
@ -186,44 +254,11 @@ static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context_t *ctx, con
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_ecdsa_sig_recover(const secp256k1_ecmult_context_t *ctx, const secp256k1_ecdsa_sig_t *sig, secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message, int recid) {
|
static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context *ctx, secp256k1_scalar *sigr, secp256k1_scalar *sigs, const secp256k1_scalar *seckey, const secp256k1_scalar *message, const secp256k1_scalar *nonce, int *recid) {
|
||||||
unsigned char brx[32];
|
|
||||||
secp256k1_fe_t fx;
|
|
||||||
secp256k1_ge_t x;
|
|
||||||
secp256k1_gej_t xj;
|
|
||||||
secp256k1_scalar_t rn, u1, u2;
|
|
||||||
secp256k1_gej_t qj;
|
|
||||||
|
|
||||||
if (secp256k1_scalar_is_zero(&sig->r) || secp256k1_scalar_is_zero(&sig->s)) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
secp256k1_scalar_get_b32(brx, &sig->r);
|
|
||||||
VERIFY_CHECK(secp256k1_fe_set_b32(&fx, brx)); /* brx comes from a scalar, so is less than the order; certainly less than p */
|
|
||||||
if (recid & 2) {
|
|
||||||
if (secp256k1_fe_cmp_var(&fx, &secp256k1_ecdsa_const_p_minus_order) >= 0) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
secp256k1_fe_add(&fx, &secp256k1_ecdsa_const_order_as_fe);
|
|
||||||
}
|
|
||||||
if (!secp256k1_ge_set_xo_var(&x, &fx, recid & 1)) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
secp256k1_gej_set_ge(&xj, &x);
|
|
||||||
secp256k1_scalar_inverse_var(&rn, &sig->r);
|
|
||||||
secp256k1_scalar_mul(&u1, &rn, message);
|
|
||||||
secp256k1_scalar_negate(&u1, &u1);
|
|
||||||
secp256k1_scalar_mul(&u2, &rn, &sig->s);
|
|
||||||
secp256k1_ecmult(ctx, &qj, &xj, &u2, &u1);
|
|
||||||
secp256k1_ge_set_gej_var(pubkey, &qj);
|
|
||||||
return !secp256k1_gej_is_infinity(&qj);
|
|
||||||
}
|
|
||||||
|
|
||||||
static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context_t *ctx, secp256k1_ecdsa_sig_t *sig, const secp256k1_scalar_t *seckey, const secp256k1_scalar_t *message, const secp256k1_scalar_t *nonce, int *recid) {
|
|
||||||
unsigned char b[32];
|
unsigned char b[32];
|
||||||
secp256k1_gej_t rp;
|
secp256k1_gej rp;
|
||||||
secp256k1_ge_t r;
|
secp256k1_ge r;
|
||||||
secp256k1_scalar_t n;
|
secp256k1_scalar n;
|
||||||
int overflow = 0;
|
int overflow = 0;
|
||||||
|
|
||||||
secp256k1_ecmult_gen(ctx, &rp, nonce);
|
secp256k1_ecmult_gen(ctx, &rp, nonce);
|
||||||
|
@ -231,28 +266,33 @@ static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context_t *ctx, s
|
||||||
secp256k1_fe_normalize(&r.x);
|
secp256k1_fe_normalize(&r.x);
|
||||||
secp256k1_fe_normalize(&r.y);
|
secp256k1_fe_normalize(&r.y);
|
||||||
secp256k1_fe_get_b32(b, &r.x);
|
secp256k1_fe_get_b32(b, &r.x);
|
||||||
secp256k1_scalar_set_b32(&sig->r, b, &overflow);
|
secp256k1_scalar_set_b32(sigr, b, &overflow);
|
||||||
if (secp256k1_scalar_is_zero(&sig->r)) {
|
if (secp256k1_scalar_is_zero(sigr)) {
|
||||||
/* P.x = order is on the curve, so technically sig->r could end up zero, which would be an invalid signature. */
|
/* P.x = order is on the curve, so technically sig->r could end up zero, which would be an invalid signature.
|
||||||
|
* This branch is cryptographically unreachable as hitting it requires finding the discrete log of P.x = N.
|
||||||
|
*/
|
||||||
secp256k1_gej_clear(&rp);
|
secp256k1_gej_clear(&rp);
|
||||||
secp256k1_ge_clear(&r);
|
secp256k1_ge_clear(&r);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
if (recid) {
|
if (recid) {
|
||||||
|
/* The overflow condition is cryptographically unreachable as hitting it requires finding the discrete log
|
||||||
|
* of some P where P.x >= order, and only 1 in about 2^127 points meet this criteria.
|
||||||
|
*/
|
||||||
*recid = (overflow ? 2 : 0) | (secp256k1_fe_is_odd(&r.y) ? 1 : 0);
|
*recid = (overflow ? 2 : 0) | (secp256k1_fe_is_odd(&r.y) ? 1 : 0);
|
||||||
}
|
}
|
||||||
secp256k1_scalar_mul(&n, &sig->r, seckey);
|
secp256k1_scalar_mul(&n, sigr, seckey);
|
||||||
secp256k1_scalar_add(&n, &n, message);
|
secp256k1_scalar_add(&n, &n, message);
|
||||||
secp256k1_scalar_inverse(&sig->s, nonce);
|
secp256k1_scalar_inverse(sigs, nonce);
|
||||||
secp256k1_scalar_mul(&sig->s, &sig->s, &n);
|
secp256k1_scalar_mul(sigs, sigs, &n);
|
||||||
secp256k1_scalar_clear(&n);
|
secp256k1_scalar_clear(&n);
|
||||||
secp256k1_gej_clear(&rp);
|
secp256k1_gej_clear(&rp);
|
||||||
secp256k1_ge_clear(&r);
|
secp256k1_ge_clear(&r);
|
||||||
if (secp256k1_scalar_is_zero(&sig->s)) {
|
if (secp256k1_scalar_is_zero(sigs)) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
if (secp256k1_scalar_is_high(&sig->s)) {
|
if (secp256k1_scalar_is_high(sigs)) {
|
||||||
secp256k1_scalar_negate(&sig->s, &sig->s);
|
secp256k1_scalar_negate(sigs, sigs);
|
||||||
if (recid) {
|
if (recid) {
|
||||||
*recid ^= 1;
|
*recid ^= 1;
|
||||||
}
|
}
|
||||||
|
|
17
src/eckey.h
17
src/eckey.h
|
@ -7,20 +7,19 @@
|
||||||
#ifndef _SECP256K1_ECKEY_
|
#ifndef _SECP256K1_ECKEY_
|
||||||
#define _SECP256K1_ECKEY_
|
#define _SECP256K1_ECKEY_
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
|
||||||
#include "group.h"
|
#include "group.h"
|
||||||
#include "scalar.h"
|
#include "scalar.h"
|
||||||
#include "ecmult.h"
|
#include "ecmult.h"
|
||||||
#include "ecmult_gen.h"
|
#include "ecmult_gen.h"
|
||||||
|
|
||||||
static int secp256k1_eckey_pubkey_parse(secp256k1_ge_t *elem, const unsigned char *pub, int size);
|
static int secp256k1_eckey_pubkey_parse(secp256k1_ge *elem, const unsigned char *pub, size_t size);
|
||||||
static int secp256k1_eckey_pubkey_serialize(secp256k1_ge_t *elem, unsigned char *pub, int *size, int compressed);
|
static int secp256k1_eckey_pubkey_serialize(secp256k1_ge *elem, unsigned char *pub, size_t *size, int compressed);
|
||||||
|
|
||||||
static int secp256k1_eckey_privkey_parse(secp256k1_scalar_t *key, const unsigned char *privkey, int privkeylen);
|
static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar *key, const secp256k1_scalar *tweak);
|
||||||
static int secp256k1_eckey_privkey_serialize(const secp256k1_ecmult_gen_context_t *ctx, unsigned char *privkey, int *privkeylen, const secp256k1_scalar_t *key, int compressed);
|
static int secp256k1_eckey_pubkey_tweak_add(const secp256k1_ecmult_context *ctx, secp256k1_ge *key, const secp256k1_scalar *tweak);
|
||||||
|
static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar *key, const secp256k1_scalar *tweak);
|
||||||
static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar_t *key, const secp256k1_scalar_t *tweak);
|
static int secp256k1_eckey_pubkey_tweak_mul(const secp256k1_ecmult_context *ctx, secp256k1_ge *key, const secp256k1_scalar *tweak);
|
||||||
static int secp256k1_eckey_pubkey_tweak_add(const secp256k1_ecmult_context_t *ctx, secp256k1_ge_t *key, const secp256k1_scalar_t *tweak);
|
|
||||||
static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar_t *key, const secp256k1_scalar_t *tweak);
|
|
||||||
static int secp256k1_eckey_pubkey_tweak_mul(const secp256k1_ecmult_context_t *ctx, secp256k1_ge_t *key, const secp256k1_scalar_t *tweak);
|
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
127
src/eckey_impl.h
127
src/eckey_impl.h
|
@ -14,12 +14,12 @@
|
||||||
#include "group.h"
|
#include "group.h"
|
||||||
#include "ecmult_gen.h"
|
#include "ecmult_gen.h"
|
||||||
|
|
||||||
static int secp256k1_eckey_pubkey_parse(secp256k1_ge_t *elem, const unsigned char *pub, int size) {
|
static int secp256k1_eckey_pubkey_parse(secp256k1_ge *elem, const unsigned char *pub, size_t size) {
|
||||||
if (size == 33 && (pub[0] == 0x02 || pub[0] == 0x03)) {
|
if (size == 33 && (pub[0] == 0x02 || pub[0] == 0x03)) {
|
||||||
secp256k1_fe_t x;
|
secp256k1_fe x;
|
||||||
return secp256k1_fe_set_b32(&x, pub+1) && secp256k1_ge_set_xo_var(elem, &x, pub[0] == 0x03);
|
return secp256k1_fe_set_b32(&x, pub+1) && secp256k1_ge_set_xo_var(elem, &x, pub[0] == 0x03);
|
||||||
} else if (size == 65 && (pub[0] == 0x04 || pub[0] == 0x06 || pub[0] == 0x07)) {
|
} else if (size == 65 && (pub[0] == 0x04 || pub[0] == 0x06 || pub[0] == 0x07)) {
|
||||||
secp256k1_fe_t x, y;
|
secp256k1_fe x, y;
|
||||||
if (!secp256k1_fe_set_b32(&x, pub+1) || !secp256k1_fe_set_b32(&y, pub+33)) {
|
if (!secp256k1_fe_set_b32(&x, pub+1) || !secp256k1_fe_set_b32(&y, pub+33)) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
@ -33,7 +33,7 @@ static int secp256k1_eckey_pubkey_parse(secp256k1_ge_t *elem, const unsigned cha
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_eckey_pubkey_serialize(secp256k1_ge_t *elem, unsigned char *pub, int *size, int compressed) {
|
static int secp256k1_eckey_pubkey_serialize(secp256k1_ge *elem, unsigned char *pub, size_t *size, int compressed) {
|
||||||
if (secp256k1_ge_is_infinity(elem)) {
|
if (secp256k1_ge_is_infinity(elem)) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
@ -51,110 +51,7 @@ static int secp256k1_eckey_pubkey_serialize(secp256k1_ge_t *elem, unsigned char
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_eckey_privkey_parse(secp256k1_scalar_t *key, const unsigned char *privkey, int privkeylen) {
|
static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar *key, const secp256k1_scalar *tweak) {
|
||||||
unsigned char c[32] = {0};
|
|
||||||
const unsigned char *end = privkey + privkeylen;
|
|
||||||
int lenb = 0;
|
|
||||||
int len = 0;
|
|
||||||
int overflow = 0;
|
|
||||||
/* sequence header */
|
|
||||||
if (end < privkey+1 || *privkey != 0x30) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
privkey++;
|
|
||||||
/* sequence length constructor */
|
|
||||||
if (end < privkey+1 || !(*privkey & 0x80)) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
lenb = *privkey & ~0x80; privkey++;
|
|
||||||
if (lenb < 1 || lenb > 2) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
if (end < privkey+lenb) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
/* sequence length */
|
|
||||||
len = privkey[lenb-1] | (lenb > 1 ? privkey[lenb-2] << 8 : 0);
|
|
||||||
privkey += lenb;
|
|
||||||
if (end < privkey+len) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
/* sequence element 0: version number (=1) */
|
|
||||||
if (end < privkey+3 || privkey[0] != 0x02 || privkey[1] != 0x01 || privkey[2] != 0x01) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
privkey += 3;
|
|
||||||
/* sequence element 1: octet string, up to 32 bytes */
|
|
||||||
if (end < privkey+2 || privkey[0] != 0x04 || privkey[1] > 0x20 || end < privkey+2+privkey[1]) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
memcpy(c + 32 - privkey[1], privkey + 2, privkey[1]);
|
|
||||||
secp256k1_scalar_set_b32(key, c, &overflow);
|
|
||||||
memset(c, 0, 32);
|
|
||||||
return !overflow;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int secp256k1_eckey_privkey_serialize(const secp256k1_ecmult_gen_context_t *ctx, unsigned char *privkey, int *privkeylen, const secp256k1_scalar_t *key, int compressed) {
|
|
||||||
secp256k1_gej_t rp;
|
|
||||||
secp256k1_ge_t r;
|
|
||||||
int pubkeylen = 0;
|
|
||||||
secp256k1_ecmult_gen(ctx, &rp, key);
|
|
||||||
secp256k1_ge_set_gej(&r, &rp);
|
|
||||||
if (compressed) {
|
|
||||||
static const unsigned char begin[] = {
|
|
||||||
0x30,0x81,0xD3,0x02,0x01,0x01,0x04,0x20
|
|
||||||
};
|
|
||||||
static const unsigned char middle[] = {
|
|
||||||
0xA0,0x81,0x85,0x30,0x81,0x82,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
|
|
||||||
0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
|
||||||
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
|
||||||
0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
|
|
||||||
0x21,0x02,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
|
|
||||||
0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
|
|
||||||
0x17,0x98,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
|
||||||
0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
|
|
||||||
0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x24,0x03,0x22,0x00
|
|
||||||
};
|
|
||||||
unsigned char *ptr = privkey;
|
|
||||||
memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
|
|
||||||
secp256k1_scalar_get_b32(ptr, key); ptr += 32;
|
|
||||||
memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
|
|
||||||
if (!secp256k1_eckey_pubkey_serialize(&r, ptr, &pubkeylen, 1)) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
ptr += pubkeylen;
|
|
||||||
*privkeylen = ptr - privkey;
|
|
||||||
} else {
|
|
||||||
static const unsigned char begin[] = {
|
|
||||||
0x30,0x82,0x01,0x13,0x02,0x01,0x01,0x04,0x20
|
|
||||||
};
|
|
||||||
static const unsigned char middle[] = {
|
|
||||||
0xA0,0x81,0xA5,0x30,0x81,0xA2,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
|
|
||||||
0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
|
||||||
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
|
||||||
0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
|
|
||||||
0x41,0x04,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
|
|
||||||
0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
|
|
||||||
0x17,0x98,0x48,0x3A,0xDA,0x77,0x26,0xA3,0xC4,0x65,0x5D,0xA4,0xFB,0xFC,0x0E,0x11,
|
|
||||||
0x08,0xA8,0xFD,0x17,0xB4,0x48,0xA6,0x85,0x54,0x19,0x9C,0x47,0xD0,0x8F,0xFB,0x10,
|
|
||||||
0xD4,0xB8,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
|
||||||
0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
|
|
||||||
0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x44,0x03,0x42,0x00
|
|
||||||
};
|
|
||||||
unsigned char *ptr = privkey;
|
|
||||||
memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
|
|
||||||
secp256k1_scalar_get_b32(ptr, key); ptr += 32;
|
|
||||||
memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
|
|
||||||
if (!secp256k1_eckey_pubkey_serialize(&r, ptr, &pubkeylen, 0)) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
ptr += pubkeylen;
|
|
||||||
*privkeylen = ptr - privkey;
|
|
||||||
}
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar_t *key, const secp256k1_scalar_t *tweak) {
|
|
||||||
secp256k1_scalar_add(key, key, tweak);
|
secp256k1_scalar_add(key, key, tweak);
|
||||||
if (secp256k1_scalar_is_zero(key)) {
|
if (secp256k1_scalar_is_zero(key)) {
|
||||||
return 0;
|
return 0;
|
||||||
|
@ -162,9 +59,9 @@ static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar_t *key, const secp
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_eckey_pubkey_tweak_add(const secp256k1_ecmult_context_t *ctx, secp256k1_ge_t *key, const secp256k1_scalar_t *tweak) {
|
static int secp256k1_eckey_pubkey_tweak_add(const secp256k1_ecmult_context *ctx, secp256k1_ge *key, const secp256k1_scalar *tweak) {
|
||||||
secp256k1_gej_t pt;
|
secp256k1_gej pt;
|
||||||
secp256k1_scalar_t one;
|
secp256k1_scalar one;
|
||||||
secp256k1_gej_set_ge(&pt, key);
|
secp256k1_gej_set_ge(&pt, key);
|
||||||
secp256k1_scalar_set_int(&one, 1);
|
secp256k1_scalar_set_int(&one, 1);
|
||||||
secp256k1_ecmult(ctx, &pt, &pt, &one, tweak);
|
secp256k1_ecmult(ctx, &pt, &pt, &one, tweak);
|
||||||
|
@ -176,7 +73,7 @@ static int secp256k1_eckey_pubkey_tweak_add(const secp256k1_ecmult_context_t *ct
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar_t *key, const secp256k1_scalar_t *tweak) {
|
static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar *key, const secp256k1_scalar *tweak) {
|
||||||
if (secp256k1_scalar_is_zero(tweak)) {
|
if (secp256k1_scalar_is_zero(tweak)) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
@ -185,9 +82,9 @@ static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar_t *key, const secp
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_eckey_pubkey_tweak_mul(const secp256k1_ecmult_context_t *ctx, secp256k1_ge_t *key, const secp256k1_scalar_t *tweak) {
|
static int secp256k1_eckey_pubkey_tweak_mul(const secp256k1_ecmult_context *ctx, secp256k1_ge *key, const secp256k1_scalar *tweak) {
|
||||||
secp256k1_scalar_t zero;
|
secp256k1_scalar zero;
|
||||||
secp256k1_gej_t pt;
|
secp256k1_gej pt;
|
||||||
if (secp256k1_scalar_is_zero(tweak)) {
|
if (secp256k1_scalar_is_zero(tweak)) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
20
src/ecmult.h
20
src/ecmult.h
|
@ -12,20 +12,20 @@
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
/* For accelerating the computation of a*P + b*G: */
|
/* For accelerating the computation of a*P + b*G: */
|
||||||
secp256k1_ge_storage_t (*pre_g)[]; /* odd multiples of the generator */
|
secp256k1_ge_storage (*pre_g)[]; /* odd multiples of the generator */
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
secp256k1_ge_storage_t (*pre_g_128)[]; /* odd multiples of 2^128*generator */
|
secp256k1_ge_storage (*pre_g_128)[]; /* odd multiples of 2^128*generator */
|
||||||
#endif
|
#endif
|
||||||
} secp256k1_ecmult_context_t;
|
} secp256k1_ecmult_context;
|
||||||
|
|
||||||
static void secp256k1_ecmult_context_init(secp256k1_ecmult_context_t *ctx);
|
static void secp256k1_ecmult_context_init(secp256k1_ecmult_context *ctx);
|
||||||
static void secp256k1_ecmult_context_build(secp256k1_ecmult_context_t *ctx);
|
static void secp256k1_ecmult_context_build(secp256k1_ecmult_context *ctx, const secp256k1_callback *cb);
|
||||||
static void secp256k1_ecmult_context_clone(secp256k1_ecmult_context_t *dst,
|
static void secp256k1_ecmult_context_clone(secp256k1_ecmult_context *dst,
|
||||||
const secp256k1_ecmult_context_t *src);
|
const secp256k1_ecmult_context *src, const secp256k1_callback *cb);
|
||||||
static void secp256k1_ecmult_context_clear(secp256k1_ecmult_context_t *ctx);
|
static void secp256k1_ecmult_context_clear(secp256k1_ecmult_context *ctx);
|
||||||
static int secp256k1_ecmult_context_is_built(const secp256k1_ecmult_context_t *ctx);
|
static int secp256k1_ecmult_context_is_built(const secp256k1_ecmult_context *ctx);
|
||||||
|
|
||||||
/** Double multiply: R = na*A + ng*G */
|
/** Double multiply: R = na*A + ng*G */
|
||||||
static void secp256k1_ecmult(const secp256k1_ecmult_context_t *ctx, secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_scalar_t *na, const secp256k1_scalar_t *ng);
|
static void secp256k1_ecmult(const secp256k1_ecmult_context *ctx, secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_scalar *na, const secp256k1_scalar *ng);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -0,0 +1,15 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2015 Andrew Poelstra *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#ifndef _SECP256K1_ECMULT_CONST_
|
||||||
|
#define _SECP256K1_ECMULT_CONST_
|
||||||
|
|
||||||
|
#include "scalar.h"
|
||||||
|
#include "group.h"
|
||||||
|
|
||||||
|
static void secp256k1_ecmult_const(secp256k1_gej *r, const secp256k1_ge *a, const secp256k1_scalar *q);
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,260 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2015 Pieter Wuille, Andrew Poelstra *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#ifndef _SECP256K1_ECMULT_CONST_IMPL_
|
||||||
|
#define _SECP256K1_ECMULT_CONST_IMPL_
|
||||||
|
|
||||||
|
#include "scalar.h"
|
||||||
|
#include "group.h"
|
||||||
|
#include "ecmult_const.h"
|
||||||
|
#include "ecmult_impl.h"
|
||||||
|
|
||||||
|
#ifdef USE_ENDOMORPHISM
|
||||||
|
#define WNAF_BITS 128
|
||||||
|
#else
|
||||||
|
#define WNAF_BITS 256
|
||||||
|
#endif
|
||||||
|
#define WNAF_SIZE(w) ((WNAF_BITS + (w) - 1) / (w))
|
||||||
|
|
||||||
|
/* This is like `ECMULT_TABLE_GET_GE` but is constant time */
|
||||||
|
#define ECMULT_CONST_TABLE_GET_GE(r,pre,n,w) do { \
|
||||||
|
int m; \
|
||||||
|
int abs_n = (n) * (((n) > 0) * 2 - 1); \
|
||||||
|
int idx_n = abs_n / 2; \
|
||||||
|
secp256k1_fe neg_y; \
|
||||||
|
VERIFY_CHECK(((n) & 1) == 1); \
|
||||||
|
VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); \
|
||||||
|
VERIFY_CHECK((n) <= ((1 << ((w)-1)) - 1)); \
|
||||||
|
VERIFY_SETUP(secp256k1_fe_clear(&(r)->x)); \
|
||||||
|
VERIFY_SETUP(secp256k1_fe_clear(&(r)->y)); \
|
||||||
|
for (m = 0; m < ECMULT_TABLE_SIZE(w); m++) { \
|
||||||
|
/* This loop is used to avoid secret data in array indices. See
|
||||||
|
* the comment in ecmult_gen_impl.h for rationale. */ \
|
||||||
|
secp256k1_fe_cmov(&(r)->x, &(pre)[m].x, m == idx_n); \
|
||||||
|
secp256k1_fe_cmov(&(r)->y, &(pre)[m].y, m == idx_n); \
|
||||||
|
} \
|
||||||
|
(r)->infinity = 0; \
|
||||||
|
secp256k1_fe_negate(&neg_y, &(r)->y, 1); \
|
||||||
|
secp256k1_fe_cmov(&(r)->y, &neg_y, (n) != abs_n); \
|
||||||
|
} while(0)
|
||||||
|
|
||||||
|
|
||||||
|
/** Convert a number to WNAF notation. The number becomes represented by sum(2^{wi} * wnaf[i], i=0..return_val)
|
||||||
|
* with the following guarantees:
|
||||||
|
* - each wnaf[i] an odd integer between -(1 << w) and (1 << w)
|
||||||
|
* - each wnaf[i] is nonzero
|
||||||
|
* - the number of words set is returned; this is always (WNAF_BITS + w - 1) / w
|
||||||
|
*
|
||||||
|
* Adapted from `The Width-w NAF Method Provides Small Memory and Fast Elliptic Scalar
|
||||||
|
* Multiplications Secure against Side Channel Attacks`, Okeya and Tagaki. M. Joye (Ed.)
|
||||||
|
* CT-RSA 2003, LNCS 2612, pp. 328-443, 2003. Springer-Verlagy Berlin Heidelberg 2003
|
||||||
|
*
|
||||||
|
* Numbers reference steps of `Algorithm SPA-resistant Width-w NAF with Odd Scalar` on pp. 335
|
||||||
|
*/
|
||||||
|
static int secp256k1_wnaf_const(int *wnaf, secp256k1_scalar s, int w) {
|
||||||
|
int global_sign;
|
||||||
|
int skew = 0;
|
||||||
|
int word = 0;
|
||||||
|
/* 1 2 3 */
|
||||||
|
int u_last;
|
||||||
|
int u;
|
||||||
|
|
||||||
|
#ifdef USE_ENDOMORPHISM
|
||||||
|
int flip;
|
||||||
|
int bit;
|
||||||
|
secp256k1_scalar neg_s;
|
||||||
|
int not_neg_one;
|
||||||
|
/* If we are using the endomorphism, we cannot handle even numbers by negating
|
||||||
|
* them, since we are working with 128-bit numbers whose negations would be 256
|
||||||
|
* bits, eliminating the performance advantage. Instead we use a technique from
|
||||||
|
* Section 4.2 of the Okeya/Tagaki paper, which is to add either 1 (for even)
|
||||||
|
* or 2 (for odd) to the number we are encoding, then compensating after the
|
||||||
|
* multiplication. */
|
||||||
|
/* Negative 128-bit numbers will be negated, since otherwise they are 256-bit */
|
||||||
|
flip = secp256k1_scalar_is_high(&s);
|
||||||
|
/* We add 1 to even numbers, 2 to odd ones, noting that negation flips parity */
|
||||||
|
bit = flip ^ (s.d[0] & 1);
|
||||||
|
/* We check for negative one, since adding 2 to it will cause an overflow */
|
||||||
|
secp256k1_scalar_negate(&neg_s, &s);
|
||||||
|
not_neg_one = !secp256k1_scalar_is_one(&neg_s);
|
||||||
|
secp256k1_scalar_cadd_bit(&s, bit, not_neg_one);
|
||||||
|
/* If we had negative one, flip == 1, s.d[0] == 0, bit == 1, so caller expects
|
||||||
|
* that we added two to it and flipped it. In fact for -1 these operations are
|
||||||
|
* identical. We only flipped, but since skewing is required (in the sense that
|
||||||
|
* the skew must be 1 or 2, never zero) and flipping is not, we need to change
|
||||||
|
* our flags to claim that we only skewed. */
|
||||||
|
global_sign = secp256k1_scalar_cond_negate(&s, flip);
|
||||||
|
global_sign *= not_neg_one * 2 - 1;
|
||||||
|
skew = 1 << bit;
|
||||||
|
#else
|
||||||
|
/* Otherwise, we just negate to force oddness */
|
||||||
|
int is_even = secp256k1_scalar_is_even(&s);
|
||||||
|
global_sign = secp256k1_scalar_cond_negate(&s, is_even);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* 4 */
|
||||||
|
u_last = secp256k1_scalar_shr_int(&s, w);
|
||||||
|
while (word * w < WNAF_BITS) {
|
||||||
|
int sign;
|
||||||
|
int even;
|
||||||
|
|
||||||
|
/* 4.1 4.4 */
|
||||||
|
u = secp256k1_scalar_shr_int(&s, w);
|
||||||
|
/* 4.2 */
|
||||||
|
even = ((u & 1) == 0);
|
||||||
|
sign = 2 * (u_last > 0) - 1;
|
||||||
|
u += sign * even;
|
||||||
|
u_last -= sign * even * (1 << w);
|
||||||
|
|
||||||
|
/* 4.3, adapted for global sign change */
|
||||||
|
wnaf[word++] = u_last * global_sign;
|
||||||
|
|
||||||
|
u_last = u;
|
||||||
|
}
|
||||||
|
wnaf[word] = u * global_sign;
|
||||||
|
|
||||||
|
VERIFY_CHECK(secp256k1_scalar_is_zero(&s));
|
||||||
|
VERIFY_CHECK(word == WNAF_SIZE(w));
|
||||||
|
return skew;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void secp256k1_ecmult_const(secp256k1_gej *r, const secp256k1_ge *a, const secp256k1_scalar *scalar) {
|
||||||
|
secp256k1_ge pre_a[ECMULT_TABLE_SIZE(WINDOW_A)];
|
||||||
|
secp256k1_ge tmpa;
|
||||||
|
secp256k1_fe Z;
|
||||||
|
|
||||||
|
#ifdef USE_ENDOMORPHISM
|
||||||
|
secp256k1_ge pre_a_lam[ECMULT_TABLE_SIZE(WINDOW_A)];
|
||||||
|
int wnaf_1[1 + WNAF_SIZE(WINDOW_A - 1)];
|
||||||
|
int wnaf_lam[1 + WNAF_SIZE(WINDOW_A - 1)];
|
||||||
|
int skew_1;
|
||||||
|
int skew_lam;
|
||||||
|
secp256k1_scalar q_1, q_lam;
|
||||||
|
#else
|
||||||
|
int wnaf[1 + WNAF_SIZE(WINDOW_A - 1)];
|
||||||
|
#endif
|
||||||
|
|
||||||
|
int i;
|
||||||
|
secp256k1_scalar sc = *scalar;
|
||||||
|
|
||||||
|
/* build wnaf representation for q. */
|
||||||
|
#ifdef USE_ENDOMORPHISM
|
||||||
|
/* split q into q_1 and q_lam (where q = q_1 + q_lam*lambda, and q_1 and q_lam are ~128 bit) */
|
||||||
|
secp256k1_scalar_split_lambda(&q_1, &q_lam, &sc);
|
||||||
|
/* no need for zero correction when using endomorphism since even
|
||||||
|
* numbers have one added to them anyway */
|
||||||
|
skew_1 = secp256k1_wnaf_const(wnaf_1, q_1, WINDOW_A - 1);
|
||||||
|
skew_lam = secp256k1_wnaf_const(wnaf_lam, q_lam, WINDOW_A - 1);
|
||||||
|
#else
|
||||||
|
int is_zero = secp256k1_scalar_is_zero(scalar);
|
||||||
|
/* the wNAF ladder cannot handle zero, so bump this to one .. we will
|
||||||
|
* correct the result after the fact */
|
||||||
|
sc.d[0] += is_zero;
|
||||||
|
VERIFY_CHECK(!secp256k1_scalar_is_zero(&sc));
|
||||||
|
|
||||||
|
secp256k1_wnaf_const(wnaf, sc, WINDOW_A - 1);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* Calculate odd multiples of a.
|
||||||
|
* All multiples are brought to the same Z 'denominator', which is stored
|
||||||
|
* in Z. Due to secp256k1' isomorphism we can do all operations pretending
|
||||||
|
* that the Z coordinate was 1, use affine addition formulae, and correct
|
||||||
|
* the Z coordinate of the result once at the end.
|
||||||
|
*/
|
||||||
|
secp256k1_gej_set_ge(r, a);
|
||||||
|
secp256k1_ecmult_odd_multiples_table_globalz_windowa(pre_a, &Z, r);
|
||||||
|
for (i = 0; i < ECMULT_TABLE_SIZE(WINDOW_A); i++) {
|
||||||
|
secp256k1_fe_normalize_weak(&pre_a[i].y);
|
||||||
|
}
|
||||||
|
#ifdef USE_ENDOMORPHISM
|
||||||
|
for (i = 0; i < ECMULT_TABLE_SIZE(WINDOW_A); i++) {
|
||||||
|
secp256k1_ge_mul_lambda(&pre_a_lam[i], &pre_a[i]);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* first loop iteration (separated out so we can directly set r, rather
|
||||||
|
* than having it start at infinity, get doubled several times, then have
|
||||||
|
* its new value added to it) */
|
||||||
|
#ifdef USE_ENDOMORPHISM
|
||||||
|
i = wnaf_1[WNAF_SIZE(WINDOW_A - 1)];
|
||||||
|
VERIFY_CHECK(i != 0);
|
||||||
|
ECMULT_CONST_TABLE_GET_GE(&tmpa, pre_a, i, WINDOW_A);
|
||||||
|
secp256k1_gej_set_ge(r, &tmpa);
|
||||||
|
|
||||||
|
i = wnaf_lam[WNAF_SIZE(WINDOW_A - 1)];
|
||||||
|
VERIFY_CHECK(i != 0);
|
||||||
|
ECMULT_CONST_TABLE_GET_GE(&tmpa, pre_a_lam, i, WINDOW_A);
|
||||||
|
secp256k1_gej_add_ge(r, r, &tmpa);
|
||||||
|
#else
|
||||||
|
i = wnaf[WNAF_SIZE(WINDOW_A - 1)];
|
||||||
|
VERIFY_CHECK(i != 0);
|
||||||
|
ECMULT_CONST_TABLE_GET_GE(&tmpa, pre_a, i, WINDOW_A);
|
||||||
|
secp256k1_gej_set_ge(r, &tmpa);
|
||||||
|
#endif
|
||||||
|
/* remaining loop iterations */
|
||||||
|
for (i = WNAF_SIZE(WINDOW_A - 1) - 1; i >= 0; i--) {
|
||||||
|
int n;
|
||||||
|
int j;
|
||||||
|
for (j = 0; j < WINDOW_A - 1; ++j) {
|
||||||
|
secp256k1_gej_double_nonzero(r, r, NULL);
|
||||||
|
}
|
||||||
|
#ifdef USE_ENDOMORPHISM
|
||||||
|
n = wnaf_1[i];
|
||||||
|
ECMULT_CONST_TABLE_GET_GE(&tmpa, pre_a, n, WINDOW_A);
|
||||||
|
VERIFY_CHECK(n != 0);
|
||||||
|
secp256k1_gej_add_ge(r, r, &tmpa);
|
||||||
|
|
||||||
|
n = wnaf_lam[i];
|
||||||
|
ECMULT_CONST_TABLE_GET_GE(&tmpa, pre_a_lam, n, WINDOW_A);
|
||||||
|
VERIFY_CHECK(n != 0);
|
||||||
|
secp256k1_gej_add_ge(r, r, &tmpa);
|
||||||
|
#else
|
||||||
|
n = wnaf[i];
|
||||||
|
VERIFY_CHECK(n != 0);
|
||||||
|
ECMULT_CONST_TABLE_GET_GE(&tmpa, pre_a, n, WINDOW_A);
|
||||||
|
secp256k1_gej_add_ge(r, r, &tmpa);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
secp256k1_fe_mul(&r->z, &r->z, &Z);
|
||||||
|
|
||||||
|
#ifdef USE_ENDOMORPHISM
|
||||||
|
{
|
||||||
|
/* Correct for wNAF skew */
|
||||||
|
secp256k1_ge correction = *a;
|
||||||
|
secp256k1_ge_storage correction_1_stor;
|
||||||
|
secp256k1_ge_storage correction_lam_stor;
|
||||||
|
secp256k1_ge_storage a2_stor;
|
||||||
|
secp256k1_gej tmpj;
|
||||||
|
secp256k1_gej_set_ge(&tmpj, &correction);
|
||||||
|
secp256k1_gej_double_var(&tmpj, &tmpj, NULL);
|
||||||
|
secp256k1_ge_set_gej(&correction, &tmpj);
|
||||||
|
secp256k1_ge_to_storage(&correction_1_stor, a);
|
||||||
|
secp256k1_ge_to_storage(&correction_lam_stor, a);
|
||||||
|
secp256k1_ge_to_storage(&a2_stor, &correction);
|
||||||
|
|
||||||
|
/* For odd numbers this is 2a (so replace it), for even ones a (so no-op) */
|
||||||
|
secp256k1_ge_storage_cmov(&correction_1_stor, &a2_stor, skew_1 == 2);
|
||||||
|
secp256k1_ge_storage_cmov(&correction_lam_stor, &a2_stor, skew_lam == 2);
|
||||||
|
|
||||||
|
/* Apply the correction */
|
||||||
|
secp256k1_ge_from_storage(&correction, &correction_1_stor);
|
||||||
|
secp256k1_ge_neg(&correction, &correction);
|
||||||
|
secp256k1_gej_add_ge(r, r, &correction);
|
||||||
|
|
||||||
|
secp256k1_ge_from_storage(&correction, &correction_lam_stor);
|
||||||
|
secp256k1_ge_neg(&correction, &correction);
|
||||||
|
secp256k1_ge_mul_lambda(&correction, &correction);
|
||||||
|
secp256k1_gej_add_ge(r, r, &correction);
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
/* correct for zero */
|
||||||
|
r->infinity |= is_zero;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
|
@ -23,21 +23,21 @@ typedef struct {
|
||||||
* None of the resulting prec group elements have a known scalar, and neither do any of
|
* None of the resulting prec group elements have a known scalar, and neither do any of
|
||||||
* the intermediate sums while computing a*G.
|
* the intermediate sums while computing a*G.
|
||||||
*/
|
*/
|
||||||
secp256k1_ge_storage_t (*prec)[64][16]; /* prec[j][i] = 16^j * i * G + U_i */
|
secp256k1_ge_storage (*prec)[64][16]; /* prec[j][i] = 16^j * i * G + U_i */
|
||||||
secp256k1_scalar_t blind;
|
secp256k1_scalar blind;
|
||||||
secp256k1_gej_t initial;
|
secp256k1_gej initial;
|
||||||
} secp256k1_ecmult_gen_context_t;
|
} secp256k1_ecmult_gen_context;
|
||||||
|
|
||||||
static void secp256k1_ecmult_gen_context_init(secp256k1_ecmult_gen_context_t* ctx);
|
static void secp256k1_ecmult_gen_context_init(secp256k1_ecmult_gen_context* ctx);
|
||||||
static void secp256k1_ecmult_gen_context_build(secp256k1_ecmult_gen_context_t* ctx);
|
static void secp256k1_ecmult_gen_context_build(secp256k1_ecmult_gen_context* ctx, const secp256k1_callback* cb);
|
||||||
static void secp256k1_ecmult_gen_context_clone(secp256k1_ecmult_gen_context_t *dst,
|
static void secp256k1_ecmult_gen_context_clone(secp256k1_ecmult_gen_context *dst,
|
||||||
const secp256k1_ecmult_gen_context_t* src);
|
const secp256k1_ecmult_gen_context* src, const secp256k1_callback* cb);
|
||||||
static void secp256k1_ecmult_gen_context_clear(secp256k1_ecmult_gen_context_t* ctx);
|
static void secp256k1_ecmult_gen_context_clear(secp256k1_ecmult_gen_context* ctx);
|
||||||
static int secp256k1_ecmult_gen_context_is_built(const secp256k1_ecmult_gen_context_t* ctx);
|
static int secp256k1_ecmult_gen_context_is_built(const secp256k1_ecmult_gen_context* ctx);
|
||||||
|
|
||||||
/** Multiply with the generator: R = a*G */
|
/** Multiply with the generator: R = a*G */
|
||||||
static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context_t* ctx, secp256k1_gej_t *r, const secp256k1_scalar_t *a);
|
static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context* ctx, secp256k1_gej *r, const secp256k1_scalar *a);
|
||||||
|
|
||||||
static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context_t *ctx, const unsigned char *seed32);
|
static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context *ctx, const unsigned char *seed32);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -11,22 +11,26 @@
|
||||||
#include "group.h"
|
#include "group.h"
|
||||||
#include "ecmult_gen.h"
|
#include "ecmult_gen.h"
|
||||||
#include "hash_impl.h"
|
#include "hash_impl.h"
|
||||||
|
#ifdef USE_ECMULT_STATIC_PRECOMPUTATION
|
||||||
static void secp256k1_ecmult_gen_context_init(secp256k1_ecmult_gen_context_t *ctx) {
|
#include "ecmult_static_context.h"
|
||||||
|
#endif
|
||||||
|
static void secp256k1_ecmult_gen_context_init(secp256k1_ecmult_gen_context *ctx) {
|
||||||
ctx->prec = NULL;
|
ctx->prec = NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ecmult_gen_context_build(secp256k1_ecmult_gen_context_t *ctx) {
|
static void secp256k1_ecmult_gen_context_build(secp256k1_ecmult_gen_context *ctx, const secp256k1_callback* cb) {
|
||||||
secp256k1_ge_t prec[1024];
|
#ifndef USE_ECMULT_STATIC_PRECOMPUTATION
|
||||||
secp256k1_gej_t gj;
|
secp256k1_ge prec[1024];
|
||||||
secp256k1_gej_t nums_gej;
|
secp256k1_gej gj;
|
||||||
|
secp256k1_gej nums_gej;
|
||||||
int i, j;
|
int i, j;
|
||||||
|
#endif
|
||||||
|
|
||||||
if (ctx->prec != NULL) {
|
if (ctx->prec != NULL) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
#ifndef USE_ECMULT_STATIC_PRECOMPUTATION
|
||||||
ctx->prec = (secp256k1_ge_storage_t (*)[64][16])checked_malloc(sizeof(*ctx->prec));
|
ctx->prec = (secp256k1_ge_storage (*)[64][16])checked_malloc(cb, sizeof(*ctx->prec));
|
||||||
|
|
||||||
/* get the generator */
|
/* get the generator */
|
||||||
secp256k1_gej_set_ge(&gj, &secp256k1_ge_const_g);
|
secp256k1_gej_set_ge(&gj, &secp256k1_ge_const_g);
|
||||||
|
@ -34,77 +38,93 @@ static void secp256k1_ecmult_gen_context_build(secp256k1_ecmult_gen_context_t *c
|
||||||
/* Construct a group element with no known corresponding scalar (nothing up my sleeve). */
|
/* Construct a group element with no known corresponding scalar (nothing up my sleeve). */
|
||||||
{
|
{
|
||||||
static const unsigned char nums_b32[33] = "The scalar for this x is unknown";
|
static const unsigned char nums_b32[33] = "The scalar for this x is unknown";
|
||||||
secp256k1_fe_t nums_x;
|
secp256k1_fe nums_x;
|
||||||
secp256k1_ge_t nums_ge;
|
secp256k1_ge nums_ge;
|
||||||
VERIFY_CHECK(secp256k1_fe_set_b32(&nums_x, nums_b32));
|
int r;
|
||||||
VERIFY_CHECK(secp256k1_ge_set_xo_var(&nums_ge, &nums_x, 0));
|
r = secp256k1_fe_set_b32(&nums_x, nums_b32);
|
||||||
|
(void)r;
|
||||||
|
VERIFY_CHECK(r);
|
||||||
|
r = secp256k1_ge_set_xo_var(&nums_ge, &nums_x, 0);
|
||||||
|
(void)r;
|
||||||
|
VERIFY_CHECK(r);
|
||||||
secp256k1_gej_set_ge(&nums_gej, &nums_ge);
|
secp256k1_gej_set_ge(&nums_gej, &nums_ge);
|
||||||
/* Add G to make the bits in x uniformly distributed. */
|
/* Add G to make the bits in x uniformly distributed. */
|
||||||
secp256k1_gej_add_ge_var(&nums_gej, &nums_gej, &secp256k1_ge_const_g);
|
secp256k1_gej_add_ge_var(&nums_gej, &nums_gej, &secp256k1_ge_const_g, NULL);
|
||||||
}
|
}
|
||||||
|
|
||||||
/* compute prec. */
|
/* compute prec. */
|
||||||
{
|
{
|
||||||
secp256k1_gej_t precj[1024]; /* Jacobian versions of prec. */
|
secp256k1_gej precj[1024]; /* Jacobian versions of prec. */
|
||||||
secp256k1_gej_t gbase;
|
secp256k1_gej gbase;
|
||||||
secp256k1_gej_t numsbase;
|
secp256k1_gej numsbase;
|
||||||
gbase = gj; /* 16^j * G */
|
gbase = gj; /* 16^j * G */
|
||||||
numsbase = nums_gej; /* 2^j * nums. */
|
numsbase = nums_gej; /* 2^j * nums. */
|
||||||
for (j = 0; j < 64; j++) {
|
for (j = 0; j < 64; j++) {
|
||||||
/* Set precj[j*16 .. j*16+15] to (numsbase, numsbase + gbase, ..., numsbase + 15*gbase). */
|
/* Set precj[j*16 .. j*16+15] to (numsbase, numsbase + gbase, ..., numsbase + 15*gbase). */
|
||||||
precj[j*16] = numsbase;
|
precj[j*16] = numsbase;
|
||||||
for (i = 1; i < 16; i++) {
|
for (i = 1; i < 16; i++) {
|
||||||
secp256k1_gej_add_var(&precj[j*16 + i], &precj[j*16 + i - 1], &gbase);
|
secp256k1_gej_add_var(&precj[j*16 + i], &precj[j*16 + i - 1], &gbase, NULL);
|
||||||
}
|
}
|
||||||
/* Multiply gbase by 16. */
|
/* Multiply gbase by 16. */
|
||||||
for (i = 0; i < 4; i++) {
|
for (i = 0; i < 4; i++) {
|
||||||
secp256k1_gej_double_var(&gbase, &gbase);
|
secp256k1_gej_double_var(&gbase, &gbase, NULL);
|
||||||
}
|
}
|
||||||
/* Multiply numbase by 2. */
|
/* Multiply numbase by 2. */
|
||||||
secp256k1_gej_double_var(&numsbase, &numsbase);
|
secp256k1_gej_double_var(&numsbase, &numsbase, NULL);
|
||||||
if (j == 62) {
|
if (j == 62) {
|
||||||
/* In the last iteration, numsbase is (1 - 2^j) * nums instead. */
|
/* In the last iteration, numsbase is (1 - 2^j) * nums instead. */
|
||||||
secp256k1_gej_neg(&numsbase, &numsbase);
|
secp256k1_gej_neg(&numsbase, &numsbase);
|
||||||
secp256k1_gej_add_var(&numsbase, &numsbase, &nums_gej);
|
secp256k1_gej_add_var(&numsbase, &numsbase, &nums_gej, NULL);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
secp256k1_ge_set_all_gej_var(1024, prec, precj);
|
secp256k1_ge_set_all_gej_var(1024, prec, precj, cb);
|
||||||
}
|
}
|
||||||
for (j = 0; j < 64; j++) {
|
for (j = 0; j < 64; j++) {
|
||||||
for (i = 0; i < 16; i++) {
|
for (i = 0; i < 16; i++) {
|
||||||
secp256k1_ge_to_storage(&(*ctx->prec)[j][i], &prec[j*16 + i]);
|
secp256k1_ge_to_storage(&(*ctx->prec)[j][i], &prec[j*16 + i]);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
#else
|
||||||
|
(void)cb;
|
||||||
|
ctx->prec = (secp256k1_ge_storage (*)[64][16])secp256k1_ecmult_static_context;
|
||||||
|
#endif
|
||||||
secp256k1_ecmult_gen_blind(ctx, NULL);
|
secp256k1_ecmult_gen_blind(ctx, NULL);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_ecmult_gen_context_is_built(const secp256k1_ecmult_gen_context_t* ctx) {
|
static int secp256k1_ecmult_gen_context_is_built(const secp256k1_ecmult_gen_context* ctx) {
|
||||||
return ctx->prec != NULL;
|
return ctx->prec != NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ecmult_gen_context_clone(secp256k1_ecmult_gen_context_t *dst,
|
static void secp256k1_ecmult_gen_context_clone(secp256k1_ecmult_gen_context *dst,
|
||||||
const secp256k1_ecmult_gen_context_t *src) {
|
const secp256k1_ecmult_gen_context *src, const secp256k1_callback* cb) {
|
||||||
if (src->prec == NULL) {
|
if (src->prec == NULL) {
|
||||||
dst->prec = NULL;
|
dst->prec = NULL;
|
||||||
} else {
|
} else {
|
||||||
dst->prec = (secp256k1_ge_storage_t (*)[64][16])checked_malloc(sizeof(*dst->prec));
|
#ifndef USE_ECMULT_STATIC_PRECOMPUTATION
|
||||||
|
dst->prec = (secp256k1_ge_storage (*)[64][16])checked_malloc(cb, sizeof(*dst->prec));
|
||||||
memcpy(dst->prec, src->prec, sizeof(*dst->prec));
|
memcpy(dst->prec, src->prec, sizeof(*dst->prec));
|
||||||
|
#else
|
||||||
|
(void)cb;
|
||||||
|
dst->prec = src->prec;
|
||||||
|
#endif
|
||||||
dst->initial = src->initial;
|
dst->initial = src->initial;
|
||||||
dst->blind = src->blind;
|
dst->blind = src->blind;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ecmult_gen_context_clear(secp256k1_ecmult_gen_context_t *ctx) {
|
static void secp256k1_ecmult_gen_context_clear(secp256k1_ecmult_gen_context *ctx) {
|
||||||
|
#ifndef USE_ECMULT_STATIC_PRECOMPUTATION
|
||||||
free(ctx->prec);
|
free(ctx->prec);
|
||||||
|
#endif
|
||||||
secp256k1_scalar_clear(&ctx->blind);
|
secp256k1_scalar_clear(&ctx->blind);
|
||||||
secp256k1_gej_clear(&ctx->initial);
|
secp256k1_gej_clear(&ctx->initial);
|
||||||
ctx->prec = NULL;
|
ctx->prec = NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context_t *ctx, secp256k1_gej_t *r, const secp256k1_scalar_t *gn) {
|
static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context *ctx, secp256k1_gej *r, const secp256k1_scalar *gn) {
|
||||||
secp256k1_ge_t add;
|
secp256k1_ge add;
|
||||||
secp256k1_ge_storage_t adds;
|
secp256k1_ge_storage adds;
|
||||||
secp256k1_scalar_t gnb;
|
secp256k1_scalar gnb;
|
||||||
int bits;
|
int bits;
|
||||||
int i, j;
|
int i, j;
|
||||||
memset(&adds, 0, sizeof(adds));
|
memset(&adds, 0, sizeof(adds));
|
||||||
|
@ -136,14 +156,15 @@ static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context_t *ctx, secp
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Setup blinding values for secp256k1_ecmult_gen. */
|
/* Setup blinding values for secp256k1_ecmult_gen. */
|
||||||
static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context_t *ctx, const unsigned char *seed32) {
|
static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context *ctx, const unsigned char *seed32) {
|
||||||
secp256k1_scalar_t b;
|
secp256k1_scalar b;
|
||||||
secp256k1_gej_t gb;
|
secp256k1_gej gb;
|
||||||
secp256k1_fe_t s;
|
secp256k1_fe s;
|
||||||
unsigned char nonce32[32];
|
unsigned char nonce32[32];
|
||||||
secp256k1_rfc6979_hmac_sha256_t rng;
|
secp256k1_rfc6979_hmac_sha256_t rng;
|
||||||
int retry;
|
int retry;
|
||||||
if (!seed32) {
|
unsigned char keydata[64] = {0};
|
||||||
|
if (seed32 == NULL) {
|
||||||
/* When seed is NULL, reset the initial point and blinding value. */
|
/* When seed is NULL, reset the initial point and blinding value. */
|
||||||
secp256k1_gej_set_ge(&ctx->initial, &secp256k1_ge_const_g);
|
secp256k1_gej_set_ge(&ctx->initial, &secp256k1_ge_const_g);
|
||||||
secp256k1_gej_neg(&ctx->initial, &ctx->initial);
|
secp256k1_gej_neg(&ctx->initial, &ctx->initial);
|
||||||
|
@ -155,13 +176,18 @@ static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context_t *ctx, cons
|
||||||
* and guards against weak or adversarial seeds. This is a simpler and safer interface than
|
* and guards against weak or adversarial seeds. This is a simpler and safer interface than
|
||||||
* asking the caller for blinding values directly and expecting them to retry on failure.
|
* asking the caller for blinding values directly and expecting them to retry on failure.
|
||||||
*/
|
*/
|
||||||
secp256k1_rfc6979_hmac_sha256_initialize(&rng, seed32 ? seed32 : nonce32, 32, nonce32, 32, NULL, 0);
|
memcpy(keydata, nonce32, 32);
|
||||||
|
if (seed32 != NULL) {
|
||||||
|
memcpy(keydata + 32, seed32, 32);
|
||||||
|
}
|
||||||
|
secp256k1_rfc6979_hmac_sha256_initialize(&rng, keydata, seed32 ? 64 : 32);
|
||||||
|
memset(keydata, 0, sizeof(keydata));
|
||||||
/* Retry for out of range results to achieve uniformity. */
|
/* Retry for out of range results to achieve uniformity. */
|
||||||
do {
|
do {
|
||||||
secp256k1_rfc6979_hmac_sha256_generate(&rng, nonce32, 32);
|
secp256k1_rfc6979_hmac_sha256_generate(&rng, nonce32, 32);
|
||||||
retry = !secp256k1_fe_set_b32(&s, nonce32);
|
retry = !secp256k1_fe_set_b32(&s, nonce32);
|
||||||
retry |= secp256k1_fe_is_zero(&s);
|
retry |= secp256k1_fe_is_zero(&s);
|
||||||
} while (retry);
|
} while (retry); /* This branch true is cryptographically unreachable. Requires sha256_hmac output > Fp. */
|
||||||
/* Randomize the projection to defend against multiplier sidechannels. */
|
/* Randomize the projection to defend against multiplier sidechannels. */
|
||||||
secp256k1_gej_rescale(&ctx->initial, &s);
|
secp256k1_gej_rescale(&ctx->initial, &s);
|
||||||
secp256k1_fe_clear(&s);
|
secp256k1_fe_clear(&s);
|
||||||
|
@ -170,7 +196,7 @@ static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context_t *ctx, cons
|
||||||
secp256k1_scalar_set_b32(&b, nonce32, &retry);
|
secp256k1_scalar_set_b32(&b, nonce32, &retry);
|
||||||
/* A blinding value of 0 works, but would undermine the projection hardening. */
|
/* A blinding value of 0 works, but would undermine the projection hardening. */
|
||||||
retry |= secp256k1_scalar_is_zero(&b);
|
retry |= secp256k1_scalar_is_zero(&b);
|
||||||
} while (retry);
|
} while (retry); /* This branch true is cryptographically unreachable. Requires sha256_hmac output > order. */
|
||||||
secp256k1_rfc6979_hmac_sha256_finalize(&rng);
|
secp256k1_rfc6979_hmac_sha256_finalize(&rng);
|
||||||
memset(nonce32, 0, 32);
|
memset(nonce32, 0, 32);
|
||||||
secp256k1_ecmult_gen(ctx, &gb, &b);
|
secp256k1_ecmult_gen(ctx, &gb, &b);
|
||||||
|
|
|
@ -24,62 +24,107 @@
|
||||||
#define WINDOW_G 16
|
#define WINDOW_G 16
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/** Fill a table 'pre' with precomputed odd multiples of a. W determines the size of the table.
|
|
||||||
* pre will contains the values [1*a,3*a,5*a,...,(2^(w-1)-1)*a], so it needs place for
|
|
||||||
* 2^(w-2) entries.
|
|
||||||
*
|
|
||||||
* There are two versions of this function:
|
|
||||||
* - secp256k1_ecmult_precomp_wnaf_gej, which operates on group elements in jacobian notation,
|
|
||||||
* fast to precompute, but slower to use in later additions.
|
|
||||||
* - secp256k1_ecmult_precomp_wnaf_ge, which operates on group elements in affine notations,
|
|
||||||
* (much) slower to precompute, but a bit faster to use in later additions.
|
|
||||||
* To compute a*P + b*G, we use the jacobian version for P, and the affine version for G, as
|
|
||||||
* G is constant, so it only needs to be done once in advance.
|
|
||||||
*/
|
|
||||||
static void secp256k1_ecmult_table_precomp_gej_var(secp256k1_gej_t *pre, const secp256k1_gej_t *a, int w) {
|
|
||||||
secp256k1_gej_t d;
|
|
||||||
int i;
|
|
||||||
pre[0] = *a;
|
|
||||||
secp256k1_gej_double_var(&d, &pre[0]);
|
|
||||||
for (i = 1; i < (1 << (w-2)); i++) {
|
|
||||||
secp256k1_gej_add_var(&pre[i], &d, &pre[i-1]);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void secp256k1_ecmult_table_precomp_ge_storage_var(secp256k1_ge_storage_t *pre, const secp256k1_gej_t *a, int w) {
|
|
||||||
secp256k1_gej_t d;
|
|
||||||
int i;
|
|
||||||
const int table_size = 1 << (w-2);
|
|
||||||
secp256k1_gej_t *prej = (secp256k1_gej_t *)checked_malloc(sizeof(secp256k1_gej_t) * table_size);
|
|
||||||
secp256k1_ge_t *prea = (secp256k1_ge_t *)checked_malloc(sizeof(secp256k1_ge_t) * table_size);
|
|
||||||
prej[0] = *a;
|
|
||||||
secp256k1_gej_double_var(&d, a);
|
|
||||||
for (i = 1; i < table_size; i++) {
|
|
||||||
secp256k1_gej_add_var(&prej[i], &d, &prej[i-1]);
|
|
||||||
}
|
|
||||||
secp256k1_ge_set_all_gej_var(table_size, prea, prej);
|
|
||||||
for (i = 0; i < table_size; i++) {
|
|
||||||
secp256k1_ge_to_storage(&pre[i], &prea[i]);
|
|
||||||
}
|
|
||||||
free(prej);
|
|
||||||
free(prea);
|
|
||||||
}
|
|
||||||
|
|
||||||
/** The number of entries a table with precomputed multiples needs to have. */
|
/** The number of entries a table with precomputed multiples needs to have. */
|
||||||
#define ECMULT_TABLE_SIZE(w) (1 << ((w)-2))
|
#define ECMULT_TABLE_SIZE(w) (1 << ((w)-2))
|
||||||
|
|
||||||
|
/** Fill a table 'prej' with precomputed odd multiples of a. Prej will contain
|
||||||
|
* the values [1*a,3*a,...,(2*n-1)*a], so it space for n values. zr[0] will
|
||||||
|
* contain prej[0].z / a.z. The other zr[i] values = prej[i].z / prej[i-1].z.
|
||||||
|
* Prej's Z values are undefined, except for the last value.
|
||||||
|
*/
|
||||||
|
static void secp256k1_ecmult_odd_multiples_table(int n, secp256k1_gej *prej, secp256k1_fe *zr, const secp256k1_gej *a) {
|
||||||
|
secp256k1_gej d;
|
||||||
|
secp256k1_ge a_ge, d_ge;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
VERIFY_CHECK(!a->infinity);
|
||||||
|
|
||||||
|
secp256k1_gej_double_var(&d, a, NULL);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Perform the additions on an isomorphism where 'd' is affine: drop the z coordinate
|
||||||
|
* of 'd', and scale the 1P starting value's x/y coordinates without changing its z.
|
||||||
|
*/
|
||||||
|
d_ge.x = d.x;
|
||||||
|
d_ge.y = d.y;
|
||||||
|
d_ge.infinity = 0;
|
||||||
|
|
||||||
|
secp256k1_ge_set_gej_zinv(&a_ge, a, &d.z);
|
||||||
|
prej[0].x = a_ge.x;
|
||||||
|
prej[0].y = a_ge.y;
|
||||||
|
prej[0].z = a->z;
|
||||||
|
prej[0].infinity = 0;
|
||||||
|
|
||||||
|
zr[0] = d.z;
|
||||||
|
for (i = 1; i < n; i++) {
|
||||||
|
secp256k1_gej_add_ge_var(&prej[i], &prej[i-1], &d_ge, &zr[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Each point in 'prej' has a z coordinate too small by a factor of 'd.z'. Only
|
||||||
|
* the final point's z coordinate is actually used though, so just update that.
|
||||||
|
*/
|
||||||
|
secp256k1_fe_mul(&prej[n-1].z, &prej[n-1].z, &d.z);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Fill a table 'pre' with precomputed odd multiples of a.
|
||||||
|
*
|
||||||
|
* There are two versions of this function:
|
||||||
|
* - secp256k1_ecmult_odd_multiples_table_globalz_windowa which brings its
|
||||||
|
* resulting point set to a single constant Z denominator, stores the X and Y
|
||||||
|
* coordinates as ge_storage points in pre, and stores the global Z in rz.
|
||||||
|
* It only operates on tables sized for WINDOW_A wnaf multiples.
|
||||||
|
* - secp256k1_ecmult_odd_multiples_table_storage_var, which converts its
|
||||||
|
* resulting point set to actually affine points, and stores those in pre.
|
||||||
|
* It operates on tables of any size, but uses heap-allocated temporaries.
|
||||||
|
*
|
||||||
|
* To compute a*P + b*G, we compute a table for P using the first function,
|
||||||
|
* and for G using the second (which requires an inverse, but it only needs to
|
||||||
|
* happen once).
|
||||||
|
*/
|
||||||
|
static void secp256k1_ecmult_odd_multiples_table_globalz_windowa(secp256k1_ge *pre, secp256k1_fe *globalz, const secp256k1_gej *a) {
|
||||||
|
secp256k1_gej prej[ECMULT_TABLE_SIZE(WINDOW_A)];
|
||||||
|
secp256k1_fe zr[ECMULT_TABLE_SIZE(WINDOW_A)];
|
||||||
|
|
||||||
|
/* Compute the odd multiples in Jacobian form. */
|
||||||
|
secp256k1_ecmult_odd_multiples_table(ECMULT_TABLE_SIZE(WINDOW_A), prej, zr, a);
|
||||||
|
/* Bring them to the same Z denominator. */
|
||||||
|
secp256k1_ge_globalz_set_table_gej(ECMULT_TABLE_SIZE(WINDOW_A), pre, globalz, prej, zr);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void secp256k1_ecmult_odd_multiples_table_storage_var(int n, secp256k1_ge_storage *pre, const secp256k1_gej *a, const secp256k1_callback *cb) {
|
||||||
|
secp256k1_gej *prej = (secp256k1_gej*)checked_malloc(cb, sizeof(secp256k1_gej) * n);
|
||||||
|
secp256k1_ge *prea = (secp256k1_ge*)checked_malloc(cb, sizeof(secp256k1_ge) * n);
|
||||||
|
secp256k1_fe *zr = (secp256k1_fe*)checked_malloc(cb, sizeof(secp256k1_fe) * n);
|
||||||
|
int i;
|
||||||
|
|
||||||
|
/* Compute the odd multiples in Jacobian form. */
|
||||||
|
secp256k1_ecmult_odd_multiples_table(n, prej, zr, a);
|
||||||
|
/* Convert them in batch to affine coordinates. */
|
||||||
|
secp256k1_ge_set_table_gej_var(n, prea, prej, zr);
|
||||||
|
/* Convert them to compact storage form. */
|
||||||
|
for (i = 0; i < n; i++) {
|
||||||
|
secp256k1_ge_to_storage(&pre[i], &prea[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
free(prea);
|
||||||
|
free(prej);
|
||||||
|
free(zr);
|
||||||
|
}
|
||||||
|
|
||||||
/** The following two macro retrieves a particular odd multiple from a table
|
/** The following two macro retrieves a particular odd multiple from a table
|
||||||
* of precomputed multiples. */
|
* of precomputed multiples. */
|
||||||
#define ECMULT_TABLE_GET_GEJ(r,pre,n,w) do { \
|
#define ECMULT_TABLE_GET_GE(r,pre,n,w) do { \
|
||||||
VERIFY_CHECK(((n) & 1) == 1); \
|
VERIFY_CHECK(((n) & 1) == 1); \
|
||||||
VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); \
|
VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); \
|
||||||
VERIFY_CHECK((n) <= ((1 << ((w)-1)) - 1)); \
|
VERIFY_CHECK((n) <= ((1 << ((w)-1)) - 1)); \
|
||||||
if ((n) > 0) { \
|
if ((n) > 0) { \
|
||||||
*(r) = (pre)[((n)-1)/2]; \
|
*(r) = (pre)[((n)-1)/2]; \
|
||||||
} else { \
|
} else { \
|
||||||
secp256k1_gej_neg((r), &(pre)[(-(n)-1)/2]); \
|
secp256k1_ge_neg((r), &(pre)[(-(n)-1)/2]); \
|
||||||
} \
|
} \
|
||||||
} while(0)
|
} while(0)
|
||||||
|
|
||||||
#define ECMULT_TABLE_GET_GE_STORAGE(r,pre,n,w) do { \
|
#define ECMULT_TABLE_GET_GE_STORAGE(r,pre,n,w) do { \
|
||||||
VERIFY_CHECK(((n) & 1) == 1); \
|
VERIFY_CHECK(((n) & 1) == 1); \
|
||||||
VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); \
|
VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); \
|
||||||
|
@ -92,15 +137,15 @@ static void secp256k1_ecmult_table_precomp_ge_storage_var(secp256k1_ge_storage_t
|
||||||
} \
|
} \
|
||||||
} while(0)
|
} while(0)
|
||||||
|
|
||||||
static void secp256k1_ecmult_context_init(secp256k1_ecmult_context_t *ctx) {
|
static void secp256k1_ecmult_context_init(secp256k1_ecmult_context *ctx) {
|
||||||
ctx->pre_g = NULL;
|
ctx->pre_g = NULL;
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
ctx->pre_g_128 = NULL;
|
ctx->pre_g_128 = NULL;
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ecmult_context_build(secp256k1_ecmult_context_t *ctx) {
|
static void secp256k1_ecmult_context_build(secp256k1_ecmult_context *ctx, const secp256k1_callback *cb) {
|
||||||
secp256k1_gej_t gj;
|
secp256k1_gej gj;
|
||||||
|
|
||||||
if (ctx->pre_g != NULL) {
|
if (ctx->pre_g != NULL) {
|
||||||
return;
|
return;
|
||||||
|
@ -109,35 +154,35 @@ static void secp256k1_ecmult_context_build(secp256k1_ecmult_context_t *ctx) {
|
||||||
/* get the generator */
|
/* get the generator */
|
||||||
secp256k1_gej_set_ge(&gj, &secp256k1_ge_const_g);
|
secp256k1_gej_set_ge(&gj, &secp256k1_ge_const_g);
|
||||||
|
|
||||||
ctx->pre_g = (secp256k1_ge_storage_t (*)[])checked_malloc(sizeof((*ctx->pre_g)[0]) * ECMULT_TABLE_SIZE(WINDOW_G));
|
ctx->pre_g = (secp256k1_ge_storage (*)[])checked_malloc(cb, sizeof((*ctx->pre_g)[0]) * ECMULT_TABLE_SIZE(WINDOW_G));
|
||||||
|
|
||||||
/* precompute the tables with odd multiples */
|
/* precompute the tables with odd multiples */
|
||||||
secp256k1_ecmult_table_precomp_ge_storage_var(*ctx->pre_g, &gj, WINDOW_G);
|
secp256k1_ecmult_odd_multiples_table_storage_var(ECMULT_TABLE_SIZE(WINDOW_G), *ctx->pre_g, &gj, cb);
|
||||||
|
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
{
|
{
|
||||||
secp256k1_gej_t g_128j;
|
secp256k1_gej g_128j;
|
||||||
int i;
|
int i;
|
||||||
|
|
||||||
ctx->pre_g_128 = (secp256k1_ge_storage_t (*)[])checked_malloc(sizeof((*ctx->pre_g_128)[0]) * ECMULT_TABLE_SIZE(WINDOW_G));
|
ctx->pre_g_128 = (secp256k1_ge_storage (*)[])checked_malloc(cb, sizeof((*ctx->pre_g_128)[0]) * ECMULT_TABLE_SIZE(WINDOW_G));
|
||||||
|
|
||||||
/* calculate 2^128*generator */
|
/* calculate 2^128*generator */
|
||||||
g_128j = gj;
|
g_128j = gj;
|
||||||
for (i = 0; i < 128; i++) {
|
for (i = 0; i < 128; i++) {
|
||||||
secp256k1_gej_double_var(&g_128j, &g_128j);
|
secp256k1_gej_double_var(&g_128j, &g_128j, NULL);
|
||||||
}
|
}
|
||||||
secp256k1_ecmult_table_precomp_ge_storage_var(*ctx->pre_g_128, &g_128j, WINDOW_G);
|
secp256k1_ecmult_odd_multiples_table_storage_var(ECMULT_TABLE_SIZE(WINDOW_G), *ctx->pre_g_128, &g_128j, cb);
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ecmult_context_clone(secp256k1_ecmult_context_t *dst,
|
static void secp256k1_ecmult_context_clone(secp256k1_ecmult_context *dst,
|
||||||
const secp256k1_ecmult_context_t *src) {
|
const secp256k1_ecmult_context *src, const secp256k1_callback *cb) {
|
||||||
if (src->pre_g == NULL) {
|
if (src->pre_g == NULL) {
|
||||||
dst->pre_g = NULL;
|
dst->pre_g = NULL;
|
||||||
} else {
|
} else {
|
||||||
size_t size = sizeof((*dst->pre_g)[0]) * ECMULT_TABLE_SIZE(WINDOW_G);
|
size_t size = sizeof((*dst->pre_g)[0]) * ECMULT_TABLE_SIZE(WINDOW_G);
|
||||||
dst->pre_g = (secp256k1_ge_storage_t (*)[])checked_malloc(size);
|
dst->pre_g = (secp256k1_ge_storage (*)[])checked_malloc(cb, size);
|
||||||
memcpy(dst->pre_g, src->pre_g, size);
|
memcpy(dst->pre_g, src->pre_g, size);
|
||||||
}
|
}
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
|
@ -145,17 +190,17 @@ static void secp256k1_ecmult_context_clone(secp256k1_ecmult_context_t *dst,
|
||||||
dst->pre_g_128 = NULL;
|
dst->pre_g_128 = NULL;
|
||||||
} else {
|
} else {
|
||||||
size_t size = sizeof((*dst->pre_g_128)[0]) * ECMULT_TABLE_SIZE(WINDOW_G);
|
size_t size = sizeof((*dst->pre_g_128)[0]) * ECMULT_TABLE_SIZE(WINDOW_G);
|
||||||
dst->pre_g_128 = (secp256k1_ge_storage_t (*)[])checked_malloc(size);
|
dst->pre_g_128 = (secp256k1_ge_storage (*)[])checked_malloc(cb, size);
|
||||||
memcpy(dst->pre_g_128, src->pre_g_128, size);
|
memcpy(dst->pre_g_128, src->pre_g_128, size);
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_ecmult_context_is_built(const secp256k1_ecmult_context_t *ctx) {
|
static int secp256k1_ecmult_context_is_built(const secp256k1_ecmult_context *ctx) {
|
||||||
return ctx->pre_g != NULL;
|
return ctx->pre_g != NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ecmult_context_clear(secp256k1_ecmult_context_t *ctx) {
|
static void secp256k1_ecmult_context_clear(secp256k1_ecmult_context *ctx) {
|
||||||
free(ctx->pre_g);
|
free(ctx->pre_g);
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
free(ctx->pre_g_128);
|
free(ctx->pre_g_128);
|
||||||
|
@ -168,54 +213,68 @@ static void secp256k1_ecmult_context_clear(secp256k1_ecmult_context_t *ctx) {
|
||||||
* - each wnaf[i] is either 0, or an odd integer between -(1<<(w-1) - 1) and (1<<(w-1) - 1)
|
* - each wnaf[i] is either 0, or an odd integer between -(1<<(w-1) - 1) and (1<<(w-1) - 1)
|
||||||
* - two non-zero entries in wnaf are separated by at least w-1 zeroes.
|
* - two non-zero entries in wnaf are separated by at least w-1 zeroes.
|
||||||
* - the number of set values in wnaf is returned. This number is at most 256, and at most one more
|
* - the number of set values in wnaf is returned. This number is at most 256, and at most one more
|
||||||
* - than the number of bits in the (absolute value) of the input.
|
* than the number of bits in the (absolute value) of the input.
|
||||||
*/
|
*/
|
||||||
static int secp256k1_ecmult_wnaf(int *wnaf, const secp256k1_scalar_t *a, int w) {
|
static int secp256k1_ecmult_wnaf(int *wnaf, int len, const secp256k1_scalar *a, int w) {
|
||||||
secp256k1_scalar_t s = *a;
|
secp256k1_scalar s = *a;
|
||||||
int set_bits = 0;
|
int last_set_bit = -1;
|
||||||
int bit = 0;
|
int bit = 0;
|
||||||
int sign = 1;
|
int sign = 1;
|
||||||
|
int carry = 0;
|
||||||
|
|
||||||
|
VERIFY_CHECK(wnaf != NULL);
|
||||||
|
VERIFY_CHECK(0 <= len && len <= 256);
|
||||||
|
VERIFY_CHECK(a != NULL);
|
||||||
|
VERIFY_CHECK(2 <= w && w <= 31);
|
||||||
|
|
||||||
|
memset(wnaf, 0, len * sizeof(wnaf[0]));
|
||||||
|
|
||||||
if (secp256k1_scalar_get_bits(&s, 255, 1)) {
|
if (secp256k1_scalar_get_bits(&s, 255, 1)) {
|
||||||
secp256k1_scalar_negate(&s, &s);
|
secp256k1_scalar_negate(&s, &s);
|
||||||
sign = -1;
|
sign = -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
while (bit < 256) {
|
while (bit < len) {
|
||||||
int now;
|
int now;
|
||||||
int word;
|
int word;
|
||||||
if (secp256k1_scalar_get_bits(&s, bit, 1) == 0) {
|
if (secp256k1_scalar_get_bits(&s, bit, 1) == (unsigned int)carry) {
|
||||||
bit++;
|
bit++;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
while (set_bits < bit) {
|
|
||||||
wnaf[set_bits++] = 0;
|
|
||||||
}
|
|
||||||
now = w;
|
now = w;
|
||||||
if (bit + now > 256) {
|
if (now > len - bit) {
|
||||||
now = 256 - bit;
|
now = len - bit;
|
||||||
}
|
|
||||||
word = secp256k1_scalar_get_bits_var(&s, bit, now);
|
|
||||||
if (word & (1 << (w-1))) {
|
|
||||||
secp256k1_scalar_add_bit(&s, bit + w);
|
|
||||||
wnaf[set_bits++] = sign * (word - (1 << w));
|
|
||||||
} else {
|
|
||||||
wnaf[set_bits++] = sign * word;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
word = secp256k1_scalar_get_bits_var(&s, bit, now) + carry;
|
||||||
|
|
||||||
|
carry = (word >> (w-1)) & 1;
|
||||||
|
word -= carry << w;
|
||||||
|
|
||||||
|
wnaf[bit] = sign * word;
|
||||||
|
last_set_bit = bit;
|
||||||
|
|
||||||
bit += now;
|
bit += now;
|
||||||
}
|
}
|
||||||
return set_bits;
|
#ifdef VERIFY
|
||||||
|
CHECK(carry == 0);
|
||||||
|
while (bit < 256) {
|
||||||
|
CHECK(secp256k1_scalar_get_bits(&s, bit++, 1) == 0);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
return last_set_bit + 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ecmult(const secp256k1_ecmult_context_t *ctx, secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_scalar_t *na, const secp256k1_scalar_t *ng) {
|
static void secp256k1_ecmult(const secp256k1_ecmult_context *ctx, secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_scalar *na, const secp256k1_scalar *ng) {
|
||||||
secp256k1_gej_t tmpj;
|
secp256k1_ge pre_a[ECMULT_TABLE_SIZE(WINDOW_A)];
|
||||||
secp256k1_gej_t pre_a[ECMULT_TABLE_SIZE(WINDOW_A)];
|
secp256k1_ge tmpa;
|
||||||
secp256k1_ge_t tmpa;
|
secp256k1_fe Z;
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
secp256k1_gej_t pre_a_lam[ECMULT_TABLE_SIZE(WINDOW_A)];
|
secp256k1_ge pre_a_lam[ECMULT_TABLE_SIZE(WINDOW_A)];
|
||||||
secp256k1_scalar_t na_1, na_lam;
|
secp256k1_scalar na_1, na_lam;
|
||||||
/* Splitted G factors. */
|
/* Splitted G factors. */
|
||||||
secp256k1_scalar_t ng_1, ng_128;
|
secp256k1_scalar ng_1, ng_128;
|
||||||
int wnaf_na_1[130];
|
int wnaf_na_1[130];
|
||||||
int wnaf_na_lam[130];
|
int wnaf_na_lam[130];
|
||||||
int bits_na_1;
|
int bits_na_1;
|
||||||
|
@ -227,7 +286,7 @@ static void secp256k1_ecmult(const secp256k1_ecmult_context_t *ctx, secp256k1_ge
|
||||||
#else
|
#else
|
||||||
int wnaf_na[256];
|
int wnaf_na[256];
|
||||||
int bits_na;
|
int bits_na;
|
||||||
int wnaf_ng[257];
|
int wnaf_ng[256];
|
||||||
int bits_ng;
|
int bits_ng;
|
||||||
#endif
|
#endif
|
||||||
int i;
|
int i;
|
||||||
|
@ -235,11 +294,11 @@ static void secp256k1_ecmult(const secp256k1_ecmult_context_t *ctx, secp256k1_ge
|
||||||
|
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
/* split na into na_1 and na_lam (where na = na_1 + na_lam*lambda, and na_1 and na_lam are ~128 bit) */
|
/* split na into na_1 and na_lam (where na = na_1 + na_lam*lambda, and na_1 and na_lam are ~128 bit) */
|
||||||
secp256k1_scalar_split_lambda_var(&na_1, &na_lam, na);
|
secp256k1_scalar_split_lambda(&na_1, &na_lam, na);
|
||||||
|
|
||||||
/* build wnaf representation for na_1 and na_lam. */
|
/* build wnaf representation for na_1 and na_lam. */
|
||||||
bits_na_1 = secp256k1_ecmult_wnaf(wnaf_na_1, &na_1, WINDOW_A);
|
bits_na_1 = secp256k1_ecmult_wnaf(wnaf_na_1, 130, &na_1, WINDOW_A);
|
||||||
bits_na_lam = secp256k1_ecmult_wnaf(wnaf_na_lam, &na_lam, WINDOW_A);
|
bits_na_lam = secp256k1_ecmult_wnaf(wnaf_na_lam, 130, &na_lam, WINDOW_A);
|
||||||
VERIFY_CHECK(bits_na_1 <= 130);
|
VERIFY_CHECK(bits_na_1 <= 130);
|
||||||
VERIFY_CHECK(bits_na_lam <= 130);
|
VERIFY_CHECK(bits_na_lam <= 130);
|
||||||
bits = bits_na_1;
|
bits = bits_na_1;
|
||||||
|
@ -248,24 +307,33 @@ static void secp256k1_ecmult(const secp256k1_ecmult_context_t *ctx, secp256k1_ge
|
||||||
}
|
}
|
||||||
#else
|
#else
|
||||||
/* build wnaf representation for na. */
|
/* build wnaf representation for na. */
|
||||||
bits_na = secp256k1_ecmult_wnaf(wnaf_na, na, WINDOW_A);
|
bits_na = secp256k1_ecmult_wnaf(wnaf_na, 256, na, WINDOW_A);
|
||||||
bits = bits_na;
|
bits = bits_na;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* calculate odd multiples of a */
|
/* Calculate odd multiples of a.
|
||||||
secp256k1_ecmult_table_precomp_gej_var(pre_a, a, WINDOW_A);
|
* All multiples are brought to the same Z 'denominator', which is stored
|
||||||
|
* in Z. Due to secp256k1' isomorphism we can do all operations pretending
|
||||||
|
* that the Z coordinate was 1, use affine addition formulae, and correct
|
||||||
|
* the Z coordinate of the result once at the end.
|
||||||
|
* The exception is the precomputed G table points, which are actually
|
||||||
|
* affine. Compared to the base used for other points, they have a Z ratio
|
||||||
|
* of 1/Z, so we can use secp256k1_gej_add_zinv_var, which uses the same
|
||||||
|
* isomorphism to efficiently add with a known Z inverse.
|
||||||
|
*/
|
||||||
|
secp256k1_ecmult_odd_multiples_table_globalz_windowa(pre_a, &Z, a);
|
||||||
|
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
for (i = 0; i < ECMULT_TABLE_SIZE(WINDOW_A); i++) {
|
for (i = 0; i < ECMULT_TABLE_SIZE(WINDOW_A); i++) {
|
||||||
secp256k1_gej_mul_lambda(&pre_a_lam[i], &pre_a[i]);
|
secp256k1_ge_mul_lambda(&pre_a_lam[i], &pre_a[i]);
|
||||||
}
|
}
|
||||||
|
|
||||||
/* split ng into ng_1 and ng_128 (where gn = gn_1 + gn_128*2^128, and gn_1 and gn_128 are ~128 bit) */
|
/* split ng into ng_1 and ng_128 (where gn = gn_1 + gn_128*2^128, and gn_1 and gn_128 are ~128 bit) */
|
||||||
secp256k1_scalar_split_128(&ng_1, &ng_128, ng);
|
secp256k1_scalar_split_128(&ng_1, &ng_128, ng);
|
||||||
|
|
||||||
/* Build wnaf representation for ng_1 and ng_128 */
|
/* Build wnaf representation for ng_1 and ng_128 */
|
||||||
bits_ng_1 = secp256k1_ecmult_wnaf(wnaf_ng_1, &ng_1, WINDOW_G);
|
bits_ng_1 = secp256k1_ecmult_wnaf(wnaf_ng_1, 129, &ng_1, WINDOW_G);
|
||||||
bits_ng_128 = secp256k1_ecmult_wnaf(wnaf_ng_128, &ng_128, WINDOW_G);
|
bits_ng_128 = secp256k1_ecmult_wnaf(wnaf_ng_128, 129, &ng_128, WINDOW_G);
|
||||||
if (bits_ng_1 > bits) {
|
if (bits_ng_1 > bits) {
|
||||||
bits = bits_ng_1;
|
bits = bits_ng_1;
|
||||||
}
|
}
|
||||||
|
@ -273,7 +341,7 @@ static void secp256k1_ecmult(const secp256k1_ecmult_context_t *ctx, secp256k1_ge
|
||||||
bits = bits_ng_128;
|
bits = bits_ng_128;
|
||||||
}
|
}
|
||||||
#else
|
#else
|
||||||
bits_ng = secp256k1_ecmult_wnaf(wnaf_ng, ng, WINDOW_G);
|
bits_ng = secp256k1_ecmult_wnaf(wnaf_ng, 256, ng, WINDOW_G);
|
||||||
if (bits_ng > bits) {
|
if (bits_ng > bits) {
|
||||||
bits = bits_ng;
|
bits = bits_ng;
|
||||||
}
|
}
|
||||||
|
@ -281,37 +349,41 @@ static void secp256k1_ecmult(const secp256k1_ecmult_context_t *ctx, secp256k1_ge
|
||||||
|
|
||||||
secp256k1_gej_set_infinity(r);
|
secp256k1_gej_set_infinity(r);
|
||||||
|
|
||||||
for (i = bits-1; i >= 0; i--) {
|
for (i = bits - 1; i >= 0; i--) {
|
||||||
int n;
|
int n;
|
||||||
secp256k1_gej_double_var(r, r);
|
secp256k1_gej_double_var(r, r, NULL);
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
if (i < bits_na_1 && (n = wnaf_na_1[i])) {
|
if (i < bits_na_1 && (n = wnaf_na_1[i])) {
|
||||||
ECMULT_TABLE_GET_GEJ(&tmpj, pre_a, n, WINDOW_A);
|
ECMULT_TABLE_GET_GE(&tmpa, pre_a, n, WINDOW_A);
|
||||||
secp256k1_gej_add_var(r, r, &tmpj);
|
secp256k1_gej_add_ge_var(r, r, &tmpa, NULL);
|
||||||
}
|
}
|
||||||
if (i < bits_na_lam && (n = wnaf_na_lam[i])) {
|
if (i < bits_na_lam && (n = wnaf_na_lam[i])) {
|
||||||
ECMULT_TABLE_GET_GEJ(&tmpj, pre_a_lam, n, WINDOW_A);
|
ECMULT_TABLE_GET_GE(&tmpa, pre_a_lam, n, WINDOW_A);
|
||||||
secp256k1_gej_add_var(r, r, &tmpj);
|
secp256k1_gej_add_ge_var(r, r, &tmpa, NULL);
|
||||||
}
|
}
|
||||||
if (i < bits_ng_1 && (n = wnaf_ng_1[i])) {
|
if (i < bits_ng_1 && (n = wnaf_ng_1[i])) {
|
||||||
ECMULT_TABLE_GET_GE_STORAGE(&tmpa, *ctx->pre_g, n, WINDOW_G);
|
ECMULT_TABLE_GET_GE_STORAGE(&tmpa, *ctx->pre_g, n, WINDOW_G);
|
||||||
secp256k1_gej_add_ge_var(r, r, &tmpa);
|
secp256k1_gej_add_zinv_var(r, r, &tmpa, &Z);
|
||||||
}
|
}
|
||||||
if (i < bits_ng_128 && (n = wnaf_ng_128[i])) {
|
if (i < bits_ng_128 && (n = wnaf_ng_128[i])) {
|
||||||
ECMULT_TABLE_GET_GE_STORAGE(&tmpa, *ctx->pre_g_128, n, WINDOW_G);
|
ECMULT_TABLE_GET_GE_STORAGE(&tmpa, *ctx->pre_g_128, n, WINDOW_G);
|
||||||
secp256k1_gej_add_ge_var(r, r, &tmpa);
|
secp256k1_gej_add_zinv_var(r, r, &tmpa, &Z);
|
||||||
}
|
}
|
||||||
#else
|
#else
|
||||||
if (i < bits_na && (n = wnaf_na[i])) {
|
if (i < bits_na && (n = wnaf_na[i])) {
|
||||||
ECMULT_TABLE_GET_GEJ(&tmpj, pre_a, n, WINDOW_A);
|
ECMULT_TABLE_GET_GE(&tmpa, pre_a, n, WINDOW_A);
|
||||||
secp256k1_gej_add_var(r, r, &tmpj);
|
secp256k1_gej_add_ge_var(r, r, &tmpa, NULL);
|
||||||
}
|
}
|
||||||
if (i < bits_ng && (n = wnaf_ng[i])) {
|
if (i < bits_ng && (n = wnaf_ng[i])) {
|
||||||
ECMULT_TABLE_GET_GE_STORAGE(&tmpa, *ctx->pre_g, n, WINDOW_G);
|
ECMULT_TABLE_GET_GE_STORAGE(&tmpa, *ctx->pre_g, n, WINDOW_G);
|
||||||
secp256k1_gej_add_ge_var(r, r, &tmpa);
|
secp256k1_gej_add_zinv_var(r, r, &tmpa, &Z);
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if (!r->infinity) {
|
||||||
|
secp256k1_fe_mul(&r->z, &r->z, &Z);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
62
src/field.h
62
src/field.h
|
@ -10,7 +10,7 @@
|
||||||
/** Field element module.
|
/** Field element module.
|
||||||
*
|
*
|
||||||
* Field elements can be represented in several ways, but code accessing
|
* Field elements can be represented in several ways, but code accessing
|
||||||
* it (and implementations) need to take certain properaties into account:
|
* it (and implementations) need to take certain properties into account:
|
||||||
* - Each field element can be normalized or not.
|
* - Each field element can be normalized or not.
|
||||||
* - Each field element has a magnitude, which represents how far away
|
* - Each field element has a magnitude, which represents how far away
|
||||||
* its representation is away from normalization. Normalized elements
|
* its representation is away from normalization. Normalized elements
|
||||||
|
@ -31,89 +31,91 @@
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/** Normalize a field element. */
|
/** Normalize a field element. */
|
||||||
static void secp256k1_fe_normalize(secp256k1_fe_t *r);
|
static void secp256k1_fe_normalize(secp256k1_fe *r);
|
||||||
|
|
||||||
/** Weakly normalize a field element: reduce it magnitude to 1, but don't fully normalize. */
|
/** Weakly normalize a field element: reduce it magnitude to 1, but don't fully normalize. */
|
||||||
static void secp256k1_fe_normalize_weak(secp256k1_fe_t *r);
|
static void secp256k1_fe_normalize_weak(secp256k1_fe *r);
|
||||||
|
|
||||||
/** Normalize a field element, without constant-time guarantee. */
|
/** Normalize a field element, without constant-time guarantee. */
|
||||||
static void secp256k1_fe_normalize_var(secp256k1_fe_t *r);
|
static void secp256k1_fe_normalize_var(secp256k1_fe *r);
|
||||||
|
|
||||||
/** Verify whether a field element represents zero i.e. would normalize to a zero value. The field
|
/** Verify whether a field element represents zero i.e. would normalize to a zero value. The field
|
||||||
* implementation may optionally normalize the input, but this should not be relied upon. */
|
* implementation may optionally normalize the input, but this should not be relied upon. */
|
||||||
static int secp256k1_fe_normalizes_to_zero(secp256k1_fe_t *r);
|
static int secp256k1_fe_normalizes_to_zero(secp256k1_fe *r);
|
||||||
|
|
||||||
/** Verify whether a field element represents zero i.e. would normalize to a zero value. The field
|
/** Verify whether a field element represents zero i.e. would normalize to a zero value. The field
|
||||||
* implementation may optionally normalize the input, but this should not be relied upon. */
|
* implementation may optionally normalize the input, but this should not be relied upon. */
|
||||||
static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe_t *r);
|
static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe *r);
|
||||||
|
|
||||||
/** Set a field element equal to a small integer. Resulting field element is normalized. */
|
/** Set a field element equal to a small integer. Resulting field element is normalized. */
|
||||||
static void secp256k1_fe_set_int(secp256k1_fe_t *r, int a);
|
static void secp256k1_fe_set_int(secp256k1_fe *r, int a);
|
||||||
|
|
||||||
/** Verify whether a field element is zero. Requires the input to be normalized. */
|
/** Verify whether a field element is zero. Requires the input to be normalized. */
|
||||||
static int secp256k1_fe_is_zero(const secp256k1_fe_t *a);
|
static int secp256k1_fe_is_zero(const secp256k1_fe *a);
|
||||||
|
|
||||||
/** Check the "oddness" of a field element. Requires the input to be normalized. */
|
/** Check the "oddness" of a field element. Requires the input to be normalized. */
|
||||||
static int secp256k1_fe_is_odd(const secp256k1_fe_t *a);
|
static int secp256k1_fe_is_odd(const secp256k1_fe *a);
|
||||||
|
|
||||||
/** Compare two field elements. Requires magnitude-1 inputs. */
|
/** Compare two field elements. Requires magnitude-1 inputs. */
|
||||||
static int secp256k1_fe_equal_var(const secp256k1_fe_t *a, const secp256k1_fe_t *b);
|
static int secp256k1_fe_equal_var(const secp256k1_fe *a, const secp256k1_fe *b);
|
||||||
|
|
||||||
/** Compare two field elements. Requires both inputs to be normalized */
|
/** Compare two field elements. Requires both inputs to be normalized */
|
||||||
static int secp256k1_fe_cmp_var(const secp256k1_fe_t *a, const secp256k1_fe_t *b);
|
static int secp256k1_fe_cmp_var(const secp256k1_fe *a, const secp256k1_fe *b);
|
||||||
|
|
||||||
/** Set a field element equal to 32-byte big endian value. If succesful, the resulting field element is normalized. */
|
/** Set a field element equal to 32-byte big endian value. If successful, the resulting field element is normalized. */
|
||||||
static int secp256k1_fe_set_b32(secp256k1_fe_t *r, const unsigned char *a);
|
static int secp256k1_fe_set_b32(secp256k1_fe *r, const unsigned char *a);
|
||||||
|
|
||||||
/** Convert a field element to a 32-byte big endian value. Requires the input to be normalized */
|
/** Convert a field element to a 32-byte big endian value. Requires the input to be normalized */
|
||||||
static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe_t *a);
|
static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe *a);
|
||||||
|
|
||||||
/** Set a field element equal to the additive inverse of another. Takes a maximum magnitude of the input
|
/** Set a field element equal to the additive inverse of another. Takes a maximum magnitude of the input
|
||||||
* as an argument. The magnitude of the output is one higher. */
|
* as an argument. The magnitude of the output is one higher. */
|
||||||
static void secp256k1_fe_negate(secp256k1_fe_t *r, const secp256k1_fe_t *a, int m);
|
static void secp256k1_fe_negate(secp256k1_fe *r, const secp256k1_fe *a, int m);
|
||||||
|
|
||||||
/** Multiplies the passed field element with a small integer constant. Multiplies the magnitude by that
|
/** Multiplies the passed field element with a small integer constant. Multiplies the magnitude by that
|
||||||
* small integer. */
|
* small integer. */
|
||||||
static void secp256k1_fe_mul_int(secp256k1_fe_t *r, int a);
|
static void secp256k1_fe_mul_int(secp256k1_fe *r, int a);
|
||||||
|
|
||||||
/** Adds a field element to another. The result has the sum of the inputs' magnitudes as magnitude. */
|
/** Adds a field element to another. The result has the sum of the inputs' magnitudes as magnitude. */
|
||||||
static void secp256k1_fe_add(secp256k1_fe_t *r, const secp256k1_fe_t *a);
|
static void secp256k1_fe_add(secp256k1_fe *r, const secp256k1_fe *a);
|
||||||
|
|
||||||
/** Sets a field element to be the product of two others. Requires the inputs' magnitudes to be at most 8.
|
/** Sets a field element to be the product of two others. Requires the inputs' magnitudes to be at most 8.
|
||||||
* The output magnitude is 1 (but not guaranteed to be normalized). */
|
* The output magnitude is 1 (but not guaranteed to be normalized). */
|
||||||
static void secp256k1_fe_mul(secp256k1_fe_t *r, const secp256k1_fe_t *a, const secp256k1_fe_t * SECP256K1_RESTRICT b);
|
static void secp256k1_fe_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b);
|
||||||
|
|
||||||
/** Sets a field element to be the square of another. Requires the input's magnitude to be at most 8.
|
/** Sets a field element to be the square of another. Requires the input's magnitude to be at most 8.
|
||||||
* The output magnitude is 1 (but not guaranteed to be normalized). */
|
* The output magnitude is 1 (but not guaranteed to be normalized). */
|
||||||
static void secp256k1_fe_sqr(secp256k1_fe_t *r, const secp256k1_fe_t *a);
|
static void secp256k1_fe_sqr(secp256k1_fe *r, const secp256k1_fe *a);
|
||||||
|
|
||||||
/** Sets a field element to be the (modular) square root (if any exist) of another. Requires the
|
/** If a has a square root, it is computed in r and 1 is returned. If a does not
|
||||||
* input's magnitude to be at most 8. The output magnitude is 1 (but not guaranteed to be
|
* have a square root, the root of its negation is computed and 0 is returned.
|
||||||
* normalized). Return value indicates whether a square root was found. */
|
* The input's magnitude can be at most 8. The output magnitude is 1 (but not
|
||||||
static int secp256k1_fe_sqrt_var(secp256k1_fe_t *r, const secp256k1_fe_t *a);
|
* guaranteed to be normalized). The result in r will always be a square
|
||||||
|
* itself. */
|
||||||
|
static int secp256k1_fe_sqrt_var(secp256k1_fe *r, const secp256k1_fe *a);
|
||||||
|
|
||||||
/** Sets a field element to be the (modular) inverse of another. Requires the input's magnitude to be
|
/** Sets a field element to be the (modular) inverse of another. Requires the input's magnitude to be
|
||||||
* at most 8. The output magnitude is 1 (but not guaranteed to be normalized). */
|
* at most 8. The output magnitude is 1 (but not guaranteed to be normalized). */
|
||||||
static void secp256k1_fe_inv(secp256k1_fe_t *r, const secp256k1_fe_t *a);
|
static void secp256k1_fe_inv(secp256k1_fe *r, const secp256k1_fe *a);
|
||||||
|
|
||||||
/** Potentially faster version of secp256k1_fe_inv, without constant-time guarantee. */
|
/** Potentially faster version of secp256k1_fe_inv, without constant-time guarantee. */
|
||||||
static void secp256k1_fe_inv_var(secp256k1_fe_t *r, const secp256k1_fe_t *a);
|
static void secp256k1_fe_inv_var(secp256k1_fe *r, const secp256k1_fe *a);
|
||||||
|
|
||||||
/** Calculate the (modular) inverses of a batch of field elements. Requires the inputs' magnitudes to be
|
/** Calculate the (modular) inverses of a batch of field elements. Requires the inputs' magnitudes to be
|
||||||
* at most 8. The output magnitudes are 1 (but not guaranteed to be normalized). The inputs and
|
* at most 8. The output magnitudes are 1 (but not guaranteed to be normalized). The inputs and
|
||||||
* outputs must not overlap in memory. */
|
* outputs must not overlap in memory. */
|
||||||
static void secp256k1_fe_inv_all_var(size_t len, secp256k1_fe_t *r, const secp256k1_fe_t *a);
|
static void secp256k1_fe_inv_all_var(size_t len, secp256k1_fe *r, const secp256k1_fe *a);
|
||||||
|
|
||||||
/** Convert a field element to the storage type. */
|
/** Convert a field element to the storage type. */
|
||||||
static void secp256k1_fe_to_storage(secp256k1_fe_storage_t *r, const secp256k1_fe_t*);
|
static void secp256k1_fe_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a);
|
||||||
|
|
||||||
/** Convert a field element back from the storage type. */
|
/** Convert a field element back from the storage type. */
|
||||||
static void secp256k1_fe_from_storage(secp256k1_fe_t *r, const secp256k1_fe_storage_t*);
|
static void secp256k1_fe_from_storage(secp256k1_fe *r, const secp256k1_fe_storage *a);
|
||||||
|
|
||||||
/** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */
|
/** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */
|
||||||
static void secp256k1_fe_storage_cmov(secp256k1_fe_storage_t *r, const secp256k1_fe_storage_t *a, int flag);
|
static void secp256k1_fe_storage_cmov(secp256k1_fe_storage *r, const secp256k1_fe_storage *a, int flag);
|
||||||
|
|
||||||
/** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */
|
/** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */
|
||||||
static void secp256k1_fe_cmov(secp256k1_fe_t *r, const secp256k1_fe_t *a, int flag);
|
static void secp256k1_fe_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -16,20 +16,20 @@ typedef struct {
|
||||||
int magnitude;
|
int magnitude;
|
||||||
int normalized;
|
int normalized;
|
||||||
#endif
|
#endif
|
||||||
} secp256k1_fe_t;
|
} secp256k1_fe;
|
||||||
|
|
||||||
/* Unpacks a constant into a overlapping multi-limbed FE element. */
|
/* Unpacks a constant into a overlapping multi-limbed FE element. */
|
||||||
#define SECP256K1_FE_CONST_INNER(d7, d6, d5, d4, d3, d2, d1, d0) { \
|
#define SECP256K1_FE_CONST_INNER(d7, d6, d5, d4, d3, d2, d1, d0) { \
|
||||||
(d0) & 0x3FFFFFFUL, \
|
(d0) & 0x3FFFFFFUL, \
|
||||||
((d0) >> 26) | ((d1) & 0xFFFFFUL) << 6, \
|
(((uint32_t)d0) >> 26) | (((uint32_t)(d1) & 0xFFFFFUL) << 6), \
|
||||||
((d1) >> 20) | ((d2) & 0x3FFFUL) << 12, \
|
(((uint32_t)d1) >> 20) | (((uint32_t)(d2) & 0x3FFFUL) << 12), \
|
||||||
((d2) >> 14) | ((d3) & 0xFFUL) << 18, \
|
(((uint32_t)d2) >> 14) | (((uint32_t)(d3) & 0xFFUL) << 18), \
|
||||||
((d3) >> 8) | ((d4) & 0x3) << 24, \
|
(((uint32_t)d3) >> 8) | (((uint32_t)(d4) & 0x3UL) << 24), \
|
||||||
((d4) >> 2) & 0x3FFFFFFUL, \
|
(((uint32_t)d4) >> 2) & 0x3FFFFFFUL, \
|
||||||
((d4) >> 28) | ((d5) & 0x3FFFFFUL) << 4, \
|
(((uint32_t)d4) >> 28) | (((uint32_t)(d5) & 0x3FFFFFUL) << 4), \
|
||||||
((d5) >> 22) | ((d6) & 0xFFFF) << 10, \
|
(((uint32_t)d5) >> 22) | (((uint32_t)(d6) & 0xFFFFUL) << 10), \
|
||||||
((d6) >> 16) | ((d7) & 0x3FF) << 16, \
|
(((uint32_t)d6) >> 16) | (((uint32_t)(d7) & 0x3FFUL) << 16), \
|
||||||
((d7) >> 10) \
|
(((uint32_t)d7) >> 10) \
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
|
@ -40,8 +40,8 @@ typedef struct {
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
uint32_t n[8];
|
uint32_t n[8];
|
||||||
} secp256k1_fe_storage_t;
|
} secp256k1_fe_storage;
|
||||||
|
|
||||||
#define SECP256K1_FE_STORAGE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{ (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }}
|
#define SECP256K1_FE_STORAGE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{ (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }}
|
||||||
|
#define SECP256K1_FE_STORAGE_CONST_GET(d) d.n[7], d.n[6], d.n[5], d.n[4],d.n[3], d.n[2], d.n[1], d.n[0]
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -14,7 +14,7 @@
|
||||||
#include "field.h"
|
#include "field.h"
|
||||||
|
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
static void secp256k1_fe_verify(const secp256k1_fe_t *a) {
|
static void secp256k1_fe_verify(const secp256k1_fe *a) {
|
||||||
const uint32_t *d = a->n;
|
const uint32_t *d = a->n;
|
||||||
int m = a->normalized ? 1 : 2 * a->magnitude, r = 1;
|
int m = a->normalized ? 1 : 2 * a->magnitude, r = 1;
|
||||||
r &= (d[0] <= 0x3FFFFFFUL * m);
|
r &= (d[0] <= 0x3FFFFFFUL * m);
|
||||||
|
@ -41,12 +41,12 @@ static void secp256k1_fe_verify(const secp256k1_fe_t *a) {
|
||||||
VERIFY_CHECK(r == 1);
|
VERIFY_CHECK(r == 1);
|
||||||
}
|
}
|
||||||
#else
|
#else
|
||||||
static void secp256k1_fe_verify(const secp256k1_fe_t *a) {
|
static void secp256k1_fe_verify(const secp256k1_fe *a) {
|
||||||
(void)a;
|
(void)a;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
static void secp256k1_fe_normalize(secp256k1_fe_t *r) {
|
static void secp256k1_fe_normalize(secp256k1_fe *r) {
|
||||||
uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
|
uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
|
||||||
t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
|
t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
|
||||||
|
|
||||||
|
@ -101,7 +101,7 @@ static void secp256k1_fe_normalize(secp256k1_fe_t *r) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_fe_normalize_weak(secp256k1_fe_t *r) {
|
static void secp256k1_fe_normalize_weak(secp256k1_fe *r) {
|
||||||
uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
|
uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
|
||||||
t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
|
t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
|
||||||
|
|
||||||
|
@ -132,7 +132,7 @@ static void secp256k1_fe_normalize_weak(secp256k1_fe_t *r) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_fe_normalize_var(secp256k1_fe_t *r) {
|
static void secp256k1_fe_normalize_var(secp256k1_fe *r) {
|
||||||
uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
|
uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
|
||||||
t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
|
t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
|
||||||
|
|
||||||
|
@ -188,7 +188,7 @@ static void secp256k1_fe_normalize_var(secp256k1_fe_t *r) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_fe_normalizes_to_zero(secp256k1_fe_t *r) {
|
static int secp256k1_fe_normalizes_to_zero(secp256k1_fe *r) {
|
||||||
uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
|
uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
|
||||||
t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
|
t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
|
||||||
|
|
||||||
|
@ -217,7 +217,7 @@ static int secp256k1_fe_normalizes_to_zero(secp256k1_fe_t *r) {
|
||||||
return (z0 == 0) | (z1 == 0x3FFFFFFUL);
|
return (z0 == 0) | (z1 == 0x3FFFFFFUL);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe_t *r) {
|
static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe *r) {
|
||||||
uint32_t t0, t1, t2, t3, t4, t5, t6, t7, t8, t9;
|
uint32_t t0, t1, t2, t3, t4, t5, t6, t7, t8, t9;
|
||||||
uint32_t z0, z1;
|
uint32_t z0, z1;
|
||||||
uint32_t x;
|
uint32_t x;
|
||||||
|
@ -252,7 +252,7 @@ static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe_t *r) {
|
||||||
t9 &= 0x03FFFFFUL;
|
t9 &= 0x03FFFFFUL;
|
||||||
t1 += (x << 6);
|
t1 += (x << 6);
|
||||||
|
|
||||||
t1 += (t0 >> 26); t0 = z0;
|
t1 += (t0 >> 26);
|
||||||
t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL; z0 |= t1; z1 &= t1 ^ 0x40UL;
|
t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL; z0 |= t1; z1 &= t1 ^ 0x40UL;
|
||||||
t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; z0 |= t2; z1 &= t2;
|
t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; z0 |= t2; z1 &= t2;
|
||||||
t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; z0 |= t3; z1 &= t3;
|
t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; z0 |= t3; z1 &= t3;
|
||||||
|
@ -269,7 +269,7 @@ static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe_t *r) {
|
||||||
return (z0 == 0) | (z1 == 0x3FFFFFFUL);
|
return (z0 == 0) | (z1 == 0x3FFFFFFUL);
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe_t *r, int a) {
|
SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe *r, int a) {
|
||||||
r->n[0] = a;
|
r->n[0] = a;
|
||||||
r->n[1] = r->n[2] = r->n[3] = r->n[4] = r->n[5] = r->n[6] = r->n[7] = r->n[8] = r->n[9] = 0;
|
r->n[1] = r->n[2] = r->n[3] = r->n[4] = r->n[5] = r->n[6] = r->n[7] = r->n[8] = r->n[9] = 0;
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
|
@ -279,7 +279,7 @@ SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe_t *r, int a) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe_t *a) {
|
SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe *a) {
|
||||||
const uint32_t *t = a->n;
|
const uint32_t *t = a->n;
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->normalized);
|
VERIFY_CHECK(a->normalized);
|
||||||
|
@ -288,7 +288,7 @@ SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe_t *a) {
|
||||||
return (t[0] | t[1] | t[2] | t[3] | t[4] | t[5] | t[6] | t[7] | t[8] | t[9]) == 0;
|
return (t[0] | t[1] | t[2] | t[3] | t[4] | t[5] | t[6] | t[7] | t[8] | t[9]) == 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe_t *a) {
|
SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe *a) {
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->normalized);
|
VERIFY_CHECK(a->normalized);
|
||||||
secp256k1_fe_verify(a);
|
secp256k1_fe_verify(a);
|
||||||
|
@ -296,7 +296,7 @@ SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe_t *a) {
|
||||||
return a->n[0] & 1;
|
return a->n[0] & 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe_t *a) {
|
SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) {
|
||||||
int i;
|
int i;
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
a->magnitude = 0;
|
a->magnitude = 0;
|
||||||
|
@ -307,7 +307,7 @@ SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe_t *a) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_fe_cmp_var(const secp256k1_fe_t *a, const secp256k1_fe_t *b) {
|
static int secp256k1_fe_cmp_var(const secp256k1_fe *a, const secp256k1_fe *b) {
|
||||||
int i;
|
int i;
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->normalized);
|
VERIFY_CHECK(a->normalized);
|
||||||
|
@ -326,7 +326,7 @@ static int secp256k1_fe_cmp_var(const secp256k1_fe_t *a, const secp256k1_fe_t *b
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_fe_set_b32(secp256k1_fe_t *r, const unsigned char *a) {
|
static int secp256k1_fe_set_b32(secp256k1_fe *r, const unsigned char *a) {
|
||||||
int i;
|
int i;
|
||||||
r->n[0] = r->n[1] = r->n[2] = r->n[3] = r->n[4] = 0;
|
r->n[0] = r->n[1] = r->n[2] = r->n[3] = r->n[4] = 0;
|
||||||
r->n[5] = r->n[6] = r->n[7] = r->n[8] = r->n[9] = 0;
|
r->n[5] = r->n[6] = r->n[7] = r->n[8] = r->n[9] = 0;
|
||||||
|
@ -350,7 +350,7 @@ static int secp256k1_fe_set_b32(secp256k1_fe_t *r, const unsigned char *a) {
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Convert a field element to a 32-byte big endian value. Requires the input to be normalized */
|
/** Convert a field element to a 32-byte big endian value. Requires the input to be normalized */
|
||||||
static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe_t *a) {
|
static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe *a) {
|
||||||
int i;
|
int i;
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->normalized);
|
VERIFY_CHECK(a->normalized);
|
||||||
|
@ -368,7 +368,7 @@ static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe_t *a) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe_t *r, const secp256k1_fe_t *a, int m) {
|
SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe *r, const secp256k1_fe *a, int m) {
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->magnitude <= m);
|
VERIFY_CHECK(a->magnitude <= m);
|
||||||
secp256k1_fe_verify(a);
|
secp256k1_fe_verify(a);
|
||||||
|
@ -390,7 +390,7 @@ SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe_t *r, const secp25
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe_t *r, int a) {
|
SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe *r, int a) {
|
||||||
r->n[0] *= a;
|
r->n[0] *= a;
|
||||||
r->n[1] *= a;
|
r->n[1] *= a;
|
||||||
r->n[2] *= a;
|
r->n[2] *= a;
|
||||||
|
@ -408,7 +408,7 @@ SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe_t *r, int a) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe *r, const secp256k1_fe *a) {
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
secp256k1_fe_verify(a);
|
secp256k1_fe_verify(a);
|
||||||
#endif
|
#endif
|
||||||
|
@ -1039,7 +1039,7 @@ SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint32_t *r, const uint32_t
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
static void secp256k1_fe_mul(secp256k1_fe_t *r, const secp256k1_fe_t *a, const secp256k1_fe_t * SECP256K1_RESTRICT b) {
|
static void secp256k1_fe_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b) {
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->magnitude <= 8);
|
VERIFY_CHECK(a->magnitude <= 8);
|
||||||
VERIFY_CHECK(b->magnitude <= 8);
|
VERIFY_CHECK(b->magnitude <= 8);
|
||||||
|
@ -1055,7 +1055,7 @@ static void secp256k1_fe_mul(secp256k1_fe_t *r, const secp256k1_fe_t *a, const s
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_fe_sqr(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
static void secp256k1_fe_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->magnitude <= 8);
|
VERIFY_CHECK(a->magnitude <= 8);
|
||||||
secp256k1_fe_verify(a);
|
secp256k1_fe_verify(a);
|
||||||
|
@ -1068,7 +1068,7 @@ static void secp256k1_fe_sqr(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe_t *r, const secp256k1_fe_t *a, int flag) {
|
static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag) {
|
||||||
uint32_t mask0, mask1;
|
uint32_t mask0, mask1;
|
||||||
mask0 = flag + ~((uint32_t)0);
|
mask0 = flag + ~((uint32_t)0);
|
||||||
mask1 = ~mask0;
|
mask1 = ~mask0;
|
||||||
|
@ -1083,12 +1083,14 @@ static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe_t *r, const secp256k
|
||||||
r->n[8] = (r->n[8] & mask0) | (a->n[8] & mask1);
|
r->n[8] = (r->n[8] & mask0) | (a->n[8] & mask1);
|
||||||
r->n[9] = (r->n[9] & mask0) | (a->n[9] & mask1);
|
r->n[9] = (r->n[9] & mask0) | (a->n[9] & mask1);
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
r->magnitude = (r->magnitude & mask0) | (a->magnitude & mask1);
|
if (a->magnitude > r->magnitude) {
|
||||||
r->normalized = (r->normalized & mask0) | (a->normalized & mask1);
|
r->magnitude = a->magnitude;
|
||||||
|
}
|
||||||
|
r->normalized &= a->normalized;
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_storage_t *r, const secp256k1_fe_storage_t *a, int flag) {
|
static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_storage *r, const secp256k1_fe_storage *a, int flag) {
|
||||||
uint32_t mask0, mask1;
|
uint32_t mask0, mask1;
|
||||||
mask0 = flag + ~((uint32_t)0);
|
mask0 = flag + ~((uint32_t)0);
|
||||||
mask1 = ~mask0;
|
mask1 = ~mask0;
|
||||||
|
@ -1102,7 +1104,7 @@ static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_storage_t *r
|
||||||
r->n[7] = (r->n[7] & mask0) | (a->n[7] & mask1);
|
r->n[7] = (r->n[7] & mask0) | (a->n[7] & mask1);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_fe_to_storage(secp256k1_fe_storage_t *r, const secp256k1_fe_t *a) {
|
static void secp256k1_fe_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a) {
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->normalized);
|
VERIFY_CHECK(a->normalized);
|
||||||
#endif
|
#endif
|
||||||
|
@ -1116,7 +1118,7 @@ static void secp256k1_fe_to_storage(secp256k1_fe_storage_t *r, const secp256k1_f
|
||||||
r->n[7] = a->n[8] >> 16 | a->n[9] << 10;
|
r->n[7] = a->n[8] >> 16 | a->n[9] << 10;
|
||||||
}
|
}
|
||||||
|
|
||||||
static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe_t *r, const secp256k1_fe_storage_t *a) {
|
static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe *r, const secp256k1_fe_storage *a) {
|
||||||
r->n[0] = a->n[0] & 0x3FFFFFFUL;
|
r->n[0] = a->n[0] & 0x3FFFFFFUL;
|
||||||
r->n[1] = a->n[0] >> 26 | ((a->n[1] << 6) & 0x3FFFFFFUL);
|
r->n[1] = a->n[0] >> 26 | ((a->n[1] << 6) & 0x3FFFFFFUL);
|
||||||
r->n[2] = a->n[1] >> 20 | ((a->n[2] << 12) & 0x3FFFFFFUL);
|
r->n[2] = a->n[1] >> 20 | ((a->n[2] << 12) & 0x3FFFFFFUL);
|
||||||
|
|
|
@ -16,15 +16,15 @@ typedef struct {
|
||||||
int magnitude;
|
int magnitude;
|
||||||
int normalized;
|
int normalized;
|
||||||
#endif
|
#endif
|
||||||
} secp256k1_fe_t;
|
} secp256k1_fe;
|
||||||
|
|
||||||
/* Unpacks a constant into a overlapping multi-limbed FE element. */
|
/* Unpacks a constant into a overlapping multi-limbed FE element. */
|
||||||
#define SECP256K1_FE_CONST_INNER(d7, d6, d5, d4, d3, d2, d1, d0) { \
|
#define SECP256K1_FE_CONST_INNER(d7, d6, d5, d4, d3, d2, d1, d0) { \
|
||||||
(d0) | ((uint64_t)(d1) & 0xFFFFFUL) << 32, \
|
(d0) | (((uint64_t)(d1) & 0xFFFFFUL) << 32), \
|
||||||
((d1) >> 20) | ((uint64_t)(d2)) << 12 | ((uint64_t)(d3) & 0xFFUL) << 44, \
|
((uint64_t)(d1) >> 20) | (((uint64_t)(d2)) << 12) | (((uint64_t)(d3) & 0xFFUL) << 44), \
|
||||||
((d3) >> 8) | ((uint64_t)(d4) & 0xFFFFFFFUL) << 24, \
|
((uint64_t)(d3) >> 8) | (((uint64_t)(d4) & 0xFFFFFFFUL) << 24), \
|
||||||
((d4) >> 28) | ((uint64_t)(d5)) << 4 | ((uint64_t)(d6) & 0xFFFFUL) << 36, \
|
((uint64_t)(d4) >> 28) | (((uint64_t)(d5)) << 4) | (((uint64_t)(d6) & 0xFFFFUL) << 36), \
|
||||||
((d6) >> 16) | ((uint64_t)(d7)) << 16 \
|
((uint64_t)(d6) >> 16) | (((uint64_t)(d7)) << 16) \
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
|
@ -35,13 +35,13 @@ typedef struct {
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
uint64_t n[4];
|
uint64_t n[4];
|
||||||
} secp256k1_fe_storage_t;
|
} secp256k1_fe_storage;
|
||||||
|
|
||||||
#define SECP256K1_FE_STORAGE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{ \
|
#define SECP256K1_FE_STORAGE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{ \
|
||||||
(d0) | ((uint64_t)(d1)) << 32, \
|
(d0) | (((uint64_t)(d1)) << 32), \
|
||||||
(d2) | ((uint64_t)(d3)) << 32, \
|
(d2) | (((uint64_t)(d3)) << 32), \
|
||||||
(d4) | ((uint64_t)(d5)) << 32, \
|
(d4) | (((uint64_t)(d5)) << 32), \
|
||||||
(d6) | ((uint64_t)(d7)) << 32 \
|
(d6) | (((uint64_t)(d7)) << 32) \
|
||||||
}}
|
}}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -31,7 +31,7 @@
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
static void secp256k1_fe_verify(const secp256k1_fe_t *a) {
|
static void secp256k1_fe_verify(const secp256k1_fe *a) {
|
||||||
const uint64_t *d = a->n;
|
const uint64_t *d = a->n;
|
||||||
int m = a->normalized ? 1 : 2 * a->magnitude, r = 1;
|
int m = a->normalized ? 1 : 2 * a->magnitude, r = 1;
|
||||||
/* secp256k1 'p' value defined in "Standards for Efficient Cryptography" (SEC2) 2.7.1. */
|
/* secp256k1 'p' value defined in "Standards for Efficient Cryptography" (SEC2) 2.7.1. */
|
||||||
|
@ -51,12 +51,12 @@ static void secp256k1_fe_verify(const secp256k1_fe_t *a) {
|
||||||
VERIFY_CHECK(r == 1);
|
VERIFY_CHECK(r == 1);
|
||||||
}
|
}
|
||||||
#else
|
#else
|
||||||
static void secp256k1_fe_verify(const secp256k1_fe_t *a) {
|
static void secp256k1_fe_verify(const secp256k1_fe *a) {
|
||||||
(void)a;
|
(void)a;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
static void secp256k1_fe_normalize(secp256k1_fe_t *r) {
|
static void secp256k1_fe_normalize(secp256k1_fe *r) {
|
||||||
uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
|
uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
|
||||||
|
|
||||||
/* Reduce t4 at the start so there will be at most a single carry from the first pass */
|
/* Reduce t4 at the start so there will be at most a single carry from the first pass */
|
||||||
|
@ -99,7 +99,7 @@ static void secp256k1_fe_normalize(secp256k1_fe_t *r) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_fe_normalize_weak(secp256k1_fe_t *r) {
|
static void secp256k1_fe_normalize_weak(secp256k1_fe *r) {
|
||||||
uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
|
uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
|
||||||
|
|
||||||
/* Reduce t4 at the start so there will be at most a single carry from the first pass */
|
/* Reduce t4 at the start so there will be at most a single carry from the first pass */
|
||||||
|
@ -123,7 +123,7 @@ static void secp256k1_fe_normalize_weak(secp256k1_fe_t *r) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_fe_normalize_var(secp256k1_fe_t *r) {
|
static void secp256k1_fe_normalize_var(secp256k1_fe *r) {
|
||||||
uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
|
uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
|
||||||
|
|
||||||
/* Reduce t4 at the start so there will be at most a single carry from the first pass */
|
/* Reduce t4 at the start so there will be at most a single carry from the first pass */
|
||||||
|
@ -167,7 +167,7 @@ static void secp256k1_fe_normalize_var(secp256k1_fe_t *r) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_fe_normalizes_to_zero(secp256k1_fe_t *r) {
|
static int secp256k1_fe_normalizes_to_zero(secp256k1_fe *r) {
|
||||||
uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
|
uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
|
||||||
|
|
||||||
/* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
|
/* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
|
||||||
|
@ -190,7 +190,7 @@ static int secp256k1_fe_normalizes_to_zero(secp256k1_fe_t *r) {
|
||||||
return (z0 == 0) | (z1 == 0xFFFFFFFFFFFFFULL);
|
return (z0 == 0) | (z1 == 0xFFFFFFFFFFFFFULL);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe_t *r) {
|
static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe *r) {
|
||||||
uint64_t t0, t1, t2, t3, t4;
|
uint64_t t0, t1, t2, t3, t4;
|
||||||
uint64_t z0, z1;
|
uint64_t z0, z1;
|
||||||
uint64_t x;
|
uint64_t x;
|
||||||
|
@ -219,7 +219,7 @@ static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe_t *r) {
|
||||||
|
|
||||||
t4 &= 0x0FFFFFFFFFFFFULL;
|
t4 &= 0x0FFFFFFFFFFFFULL;
|
||||||
|
|
||||||
t1 += (t0 >> 52); t0 = z0;
|
t1 += (t0 >> 52);
|
||||||
t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; z0 |= t1; z1 &= t1;
|
t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; z0 |= t1; z1 &= t1;
|
||||||
t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; z0 |= t2; z1 &= t2;
|
t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; z0 |= t2; z1 &= t2;
|
||||||
t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; z0 |= t3; z1 &= t3;
|
t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; z0 |= t3; z1 &= t3;
|
||||||
|
@ -231,7 +231,7 @@ static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe_t *r) {
|
||||||
return (z0 == 0) | (z1 == 0xFFFFFFFFFFFFFULL);
|
return (z0 == 0) | (z1 == 0xFFFFFFFFFFFFFULL);
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe_t *r, int a) {
|
SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe *r, int a) {
|
||||||
r->n[0] = a;
|
r->n[0] = a;
|
||||||
r->n[1] = r->n[2] = r->n[3] = r->n[4] = 0;
|
r->n[1] = r->n[2] = r->n[3] = r->n[4] = 0;
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
|
@ -241,7 +241,7 @@ SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe_t *r, int a) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe_t *a) {
|
SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe *a) {
|
||||||
const uint64_t *t = a->n;
|
const uint64_t *t = a->n;
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->normalized);
|
VERIFY_CHECK(a->normalized);
|
||||||
|
@ -250,7 +250,7 @@ SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe_t *a) {
|
||||||
return (t[0] | t[1] | t[2] | t[3] | t[4]) == 0;
|
return (t[0] | t[1] | t[2] | t[3] | t[4]) == 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe_t *a) {
|
SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe *a) {
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->normalized);
|
VERIFY_CHECK(a->normalized);
|
||||||
secp256k1_fe_verify(a);
|
secp256k1_fe_verify(a);
|
||||||
|
@ -258,7 +258,7 @@ SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe_t *a) {
|
||||||
return a->n[0] & 1;
|
return a->n[0] & 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe_t *a) {
|
SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) {
|
||||||
int i;
|
int i;
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
a->magnitude = 0;
|
a->magnitude = 0;
|
||||||
|
@ -269,7 +269,7 @@ SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe_t *a) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_fe_cmp_var(const secp256k1_fe_t *a, const secp256k1_fe_t *b) {
|
static int secp256k1_fe_cmp_var(const secp256k1_fe *a, const secp256k1_fe *b) {
|
||||||
int i;
|
int i;
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->normalized);
|
VERIFY_CHECK(a->normalized);
|
||||||
|
@ -288,7 +288,7 @@ static int secp256k1_fe_cmp_var(const secp256k1_fe_t *a, const secp256k1_fe_t *b
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_fe_set_b32(secp256k1_fe_t *r, const unsigned char *a) {
|
static int secp256k1_fe_set_b32(secp256k1_fe *r, const unsigned char *a) {
|
||||||
int i;
|
int i;
|
||||||
r->n[0] = r->n[1] = r->n[2] = r->n[3] = r->n[4] = 0;
|
r->n[0] = r->n[1] = r->n[2] = r->n[3] = r->n[4] = 0;
|
||||||
for (i=0; i<32; i++) {
|
for (i=0; i<32; i++) {
|
||||||
|
@ -311,7 +311,7 @@ static int secp256k1_fe_set_b32(secp256k1_fe_t *r, const unsigned char *a) {
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Convert a field element to a 32-byte big endian value. Requires the input to be normalized */
|
/** Convert a field element to a 32-byte big endian value. Requires the input to be normalized */
|
||||||
static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe_t *a) {
|
static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe *a) {
|
||||||
int i;
|
int i;
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->normalized);
|
VERIFY_CHECK(a->normalized);
|
||||||
|
@ -329,7 +329,7 @@ static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe_t *a) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe_t *r, const secp256k1_fe_t *a, int m) {
|
SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe *r, const secp256k1_fe *a, int m) {
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->magnitude <= m);
|
VERIFY_CHECK(a->magnitude <= m);
|
||||||
secp256k1_fe_verify(a);
|
secp256k1_fe_verify(a);
|
||||||
|
@ -346,7 +346,7 @@ SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe_t *r, const secp25
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe_t *r, int a) {
|
SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe *r, int a) {
|
||||||
r->n[0] *= a;
|
r->n[0] *= a;
|
||||||
r->n[1] *= a;
|
r->n[1] *= a;
|
||||||
r->n[2] *= a;
|
r->n[2] *= a;
|
||||||
|
@ -359,7 +359,7 @@ SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe_t *r, int a) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe *r, const secp256k1_fe *a) {
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
secp256k1_fe_verify(a);
|
secp256k1_fe_verify(a);
|
||||||
#endif
|
#endif
|
||||||
|
@ -375,7 +375,7 @@ SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe_t *r, const secp256k1
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_fe_mul(secp256k1_fe_t *r, const secp256k1_fe_t *a, const secp256k1_fe_t * SECP256K1_RESTRICT b) {
|
static void secp256k1_fe_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b) {
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->magnitude <= 8);
|
VERIFY_CHECK(a->magnitude <= 8);
|
||||||
VERIFY_CHECK(b->magnitude <= 8);
|
VERIFY_CHECK(b->magnitude <= 8);
|
||||||
|
@ -391,7 +391,7 @@ static void secp256k1_fe_mul(secp256k1_fe_t *r, const secp256k1_fe_t *a, const s
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_fe_sqr(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
static void secp256k1_fe_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->magnitude <= 8);
|
VERIFY_CHECK(a->magnitude <= 8);
|
||||||
secp256k1_fe_verify(a);
|
secp256k1_fe_verify(a);
|
||||||
|
@ -404,7 +404,7 @@ static void secp256k1_fe_sqr(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe_t *r, const secp256k1_fe_t *a, int flag) {
|
static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag) {
|
||||||
uint64_t mask0, mask1;
|
uint64_t mask0, mask1;
|
||||||
mask0 = flag + ~((uint64_t)0);
|
mask0 = flag + ~((uint64_t)0);
|
||||||
mask1 = ~mask0;
|
mask1 = ~mask0;
|
||||||
|
@ -414,12 +414,14 @@ static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe_t *r, const secp256k
|
||||||
r->n[3] = (r->n[3] & mask0) | (a->n[3] & mask1);
|
r->n[3] = (r->n[3] & mask0) | (a->n[3] & mask1);
|
||||||
r->n[4] = (r->n[4] & mask0) | (a->n[4] & mask1);
|
r->n[4] = (r->n[4] & mask0) | (a->n[4] & mask1);
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
r->magnitude = (r->magnitude & mask0) | (a->magnitude & mask1);
|
if (a->magnitude > r->magnitude) {
|
||||||
r->normalized = (r->normalized & mask0) | (a->normalized & mask1);
|
r->magnitude = a->magnitude;
|
||||||
|
}
|
||||||
|
r->normalized &= a->normalized;
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_storage_t *r, const secp256k1_fe_storage_t *a, int flag) {
|
static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_storage *r, const secp256k1_fe_storage *a, int flag) {
|
||||||
uint64_t mask0, mask1;
|
uint64_t mask0, mask1;
|
||||||
mask0 = flag + ~((uint64_t)0);
|
mask0 = flag + ~((uint64_t)0);
|
||||||
mask1 = ~mask0;
|
mask1 = ~mask0;
|
||||||
|
@ -429,7 +431,7 @@ static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_storage_t *r
|
||||||
r->n[3] = (r->n[3] & mask0) | (a->n[3] & mask1);
|
r->n[3] = (r->n[3] & mask0) | (a->n[3] & mask1);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_fe_to_storage(secp256k1_fe_storage_t *r, const secp256k1_fe_t *a) {
|
static void secp256k1_fe_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a) {
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
VERIFY_CHECK(a->normalized);
|
VERIFY_CHECK(a->normalized);
|
||||||
#endif
|
#endif
|
||||||
|
@ -439,7 +441,7 @@ static void secp256k1_fe_to_storage(secp256k1_fe_storage_t *r, const secp256k1_f
|
||||||
r->n[3] = a->n[3] >> 36 | a->n[4] << 16;
|
r->n[3] = a->n[3] >> 36 | a->n[4] << 16;
|
||||||
}
|
}
|
||||||
|
|
||||||
static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe_t *r, const secp256k1_fe_storage_t *a) {
|
static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe *r, const secp256k1_fe_storage *a) {
|
||||||
r->n[0] = a->n[0] & 0xFFFFFFFFFFFFFULL;
|
r->n[0] = a->n[0] & 0xFFFFFFFFFFFFFULL;
|
||||||
r->n[1] = a->n[0] >> 52 | ((a->n[1] << 12) & 0xFFFFFFFFFFFFFULL);
|
r->n[1] = a->n[0] >> 52 | ((a->n[1] << 12) & 0xFFFFFFFFFFFFFULL);
|
||||||
r->n[2] = a->n[1] >> 40 | ((a->n[2] << 24) & 0xFFFFFFFFFFFFFULL);
|
r->n[2] = a->n[1] >> 40 | ((a->n[2] << 24) & 0xFFFFFFFFFFFFFULL);
|
||||||
|
|
|
@ -21,15 +21,24 @@
|
||||||
#error "Please select field implementation"
|
#error "Please select field implementation"
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_fe_equal_var(const secp256k1_fe_t *a, const secp256k1_fe_t *b) {
|
SECP256K1_INLINE static int secp256k1_fe_equal_var(const secp256k1_fe *a, const secp256k1_fe *b) {
|
||||||
secp256k1_fe_t na;
|
secp256k1_fe na;
|
||||||
secp256k1_fe_negate(&na, a, 1);
|
secp256k1_fe_negate(&na, a, 1);
|
||||||
secp256k1_fe_add(&na, b);
|
secp256k1_fe_add(&na, b);
|
||||||
return secp256k1_fe_normalizes_to_zero_var(&na);
|
return secp256k1_fe_normalizes_to_zero_var(&na);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_fe_sqrt_var(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
static int secp256k1_fe_sqrt_var(secp256k1_fe *r, const secp256k1_fe *a) {
|
||||||
secp256k1_fe_t x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
|
/** Given that p is congruent to 3 mod 4, we can compute the square root of
|
||||||
|
* a mod p as the (p+1)/4'th power of a.
|
||||||
|
*
|
||||||
|
* As (p+1)/4 is an even number, it will have the same result for a and for
|
||||||
|
* (-a). Only one of these two numbers actually has a square root however,
|
||||||
|
* so we test at the end by squaring and comparing to the input.
|
||||||
|
* Also because (p+1)/4 is an even number, the computed square root is
|
||||||
|
* itself always a square (a ** ((p+1)/4) is the square of a ** ((p+1)/8)).
|
||||||
|
*/
|
||||||
|
secp256k1_fe x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
|
||||||
int j;
|
int j;
|
||||||
|
|
||||||
/** The binary representation of (p + 1)/4 has 3 blocks of 1s, with lengths in
|
/** The binary representation of (p + 1)/4 has 3 blocks of 1s, with lengths in
|
||||||
|
@ -117,8 +126,8 @@ static int secp256k1_fe_sqrt_var(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
||||||
return secp256k1_fe_equal_var(&t1, a);
|
return secp256k1_fe_equal_var(&t1, a);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_fe_inv(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
static void secp256k1_fe_inv(secp256k1_fe *r, const secp256k1_fe *a) {
|
||||||
secp256k1_fe_t x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
|
secp256k1_fe x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
|
||||||
int j;
|
int j;
|
||||||
|
|
||||||
/** The binary representation of (p - 2) has 5 blocks of 1s, with lengths in
|
/** The binary representation of (p - 2) has 5 blocks of 1s, with lengths in
|
||||||
|
@ -207,11 +216,15 @@ static void secp256k1_fe_inv(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
||||||
secp256k1_fe_mul(r, a, &t1);
|
secp256k1_fe_mul(r, a, &t1);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_fe_inv_var(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
static void secp256k1_fe_inv_var(secp256k1_fe *r, const secp256k1_fe *a) {
|
||||||
#if defined(USE_FIELD_INV_BUILTIN)
|
#if defined(USE_FIELD_INV_BUILTIN)
|
||||||
secp256k1_fe_inv(r, a);
|
secp256k1_fe_inv(r, a);
|
||||||
#elif defined(USE_FIELD_INV_NUM)
|
#elif defined(USE_FIELD_INV_NUM)
|
||||||
secp256k1_num_t n, m;
|
secp256k1_num n, m;
|
||||||
|
static const secp256k1_fe negone = SECP256K1_FE_CONST(
|
||||||
|
0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL,
|
||||||
|
0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL, 0xFFFFFC2EUL
|
||||||
|
);
|
||||||
/* secp256k1 field prime, value p defined in "Standards for Efficient Cryptography" (SEC2) 2.7.1. */
|
/* secp256k1 field prime, value p defined in "Standards for Efficient Cryptography" (SEC2) 2.7.1. */
|
||||||
static const unsigned char prime[32] = {
|
static const unsigned char prime[32] = {
|
||||||
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
||||||
|
@ -220,21 +233,28 @@ static void secp256k1_fe_inv_var(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
||||||
0xFF,0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F
|
0xFF,0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F
|
||||||
};
|
};
|
||||||
unsigned char b[32];
|
unsigned char b[32];
|
||||||
secp256k1_fe_t c = *a;
|
int res;
|
||||||
|
secp256k1_fe c = *a;
|
||||||
secp256k1_fe_normalize_var(&c);
|
secp256k1_fe_normalize_var(&c);
|
||||||
secp256k1_fe_get_b32(b, &c);
|
secp256k1_fe_get_b32(b, &c);
|
||||||
secp256k1_num_set_bin(&n, b, 32);
|
secp256k1_num_set_bin(&n, b, 32);
|
||||||
secp256k1_num_set_bin(&m, prime, 32);
|
secp256k1_num_set_bin(&m, prime, 32);
|
||||||
secp256k1_num_mod_inverse(&n, &n, &m);
|
secp256k1_num_mod_inverse(&n, &n, &m);
|
||||||
secp256k1_num_get_bin(b, 32, &n);
|
secp256k1_num_get_bin(b, 32, &n);
|
||||||
VERIFY_CHECK(secp256k1_fe_set_b32(r, b));
|
res = secp256k1_fe_set_b32(r, b);
|
||||||
|
(void)res;
|
||||||
|
VERIFY_CHECK(res);
|
||||||
|
/* Verify the result is the (unique) valid inverse using non-GMP code. */
|
||||||
|
secp256k1_fe_mul(&c, &c, r);
|
||||||
|
secp256k1_fe_add(&c, &negone);
|
||||||
|
CHECK(secp256k1_fe_normalizes_to_zero_var(&c));
|
||||||
#else
|
#else
|
||||||
#error "Please select field inverse implementation"
|
#error "Please select field inverse implementation"
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_fe_inv_all_var(size_t len, secp256k1_fe_t *r, const secp256k1_fe_t *a) {
|
static void secp256k1_fe_inv_all_var(size_t len, secp256k1_fe *r, const secp256k1_fe *a) {
|
||||||
secp256k1_fe_t u;
|
secp256k1_fe u;
|
||||||
size_t i;
|
size_t i;
|
||||||
if (len < 1) {
|
if (len < 1) {
|
||||||
return;
|
return;
|
||||||
|
@ -252,7 +272,7 @@ static void secp256k1_fe_inv_all_var(size_t len, secp256k1_fe_t *r, const secp25
|
||||||
secp256k1_fe_inv_var(&u, &r[--i]);
|
secp256k1_fe_inv_var(&u, &r[--i]);
|
||||||
|
|
||||||
while (i > 0) {
|
while (i > 0) {
|
||||||
int j = i--;
|
size_t j = i--;
|
||||||
secp256k1_fe_mul(&r[j], &r[i], &u);
|
secp256k1_fe_mul(&r[j], &r[i], &u);
|
||||||
secp256k1_fe_mul(&u, &u, &a[j]);
|
secp256k1_fe_mul(&u, &u, &a[j]);
|
||||||
}
|
}
|
||||||
|
|
|
@ -0,0 +1,74 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2013, 2014, 2015 Thomas Daede, Cory Fields *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#define USE_BASIC_CONFIG 1
|
||||||
|
|
||||||
|
#include "basic-config.h"
|
||||||
|
#include "include/secp256k1.h"
|
||||||
|
#include "field_impl.h"
|
||||||
|
#include "scalar_impl.h"
|
||||||
|
#include "group_impl.h"
|
||||||
|
#include "ecmult_gen_impl.h"
|
||||||
|
|
||||||
|
static void default_error_callback_fn(const char* str, void* data) {
|
||||||
|
(void)data;
|
||||||
|
fprintf(stderr, "[libsecp256k1] internal consistency check failed: %s\n", str);
|
||||||
|
abort();
|
||||||
|
}
|
||||||
|
|
||||||
|
static const secp256k1_callback default_error_callback = {
|
||||||
|
default_error_callback_fn,
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
int main(int argc, char **argv) {
|
||||||
|
secp256k1_ecmult_gen_context ctx;
|
||||||
|
int inner;
|
||||||
|
int outer;
|
||||||
|
FILE* fp;
|
||||||
|
|
||||||
|
(void)argc;
|
||||||
|
(void)argv;
|
||||||
|
|
||||||
|
fp = fopen("src/ecmult_static_context.h","w");
|
||||||
|
if (fp == NULL) {
|
||||||
|
fprintf(stderr, "Could not open src/ecmult_static_context.h for writing!\n");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
fprintf(fp, "#ifndef _SECP256K1_ECMULT_STATIC_CONTEXT_\n");
|
||||||
|
fprintf(fp, "#define _SECP256K1_ECMULT_STATIC_CONTEXT_\n");
|
||||||
|
fprintf(fp, "#include \"group.h\"\n");
|
||||||
|
fprintf(fp, "#define SC SECP256K1_GE_STORAGE_CONST\n");
|
||||||
|
fprintf(fp, "static const secp256k1_ge_storage secp256k1_ecmult_static_context[64][16] = {\n");
|
||||||
|
|
||||||
|
secp256k1_ecmult_gen_context_init(&ctx);
|
||||||
|
secp256k1_ecmult_gen_context_build(&ctx, &default_error_callback);
|
||||||
|
for(outer = 0; outer != 64; outer++) {
|
||||||
|
fprintf(fp,"{\n");
|
||||||
|
for(inner = 0; inner != 16; inner++) {
|
||||||
|
fprintf(fp," SC(%uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu)", SECP256K1_GE_STORAGE_CONST_GET((*ctx.prec)[outer][inner]));
|
||||||
|
if (inner != 15) {
|
||||||
|
fprintf(fp,",\n");
|
||||||
|
} else {
|
||||||
|
fprintf(fp,"\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (outer != 63) {
|
||||||
|
fprintf(fp,"},\n");
|
||||||
|
} else {
|
||||||
|
fprintf(fp,"}\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fprintf(fp,"};\n");
|
||||||
|
secp256k1_ecmult_gen_context_clear(&ctx);
|
||||||
|
|
||||||
|
fprintf(fp, "#undef SC\n");
|
||||||
|
fprintf(fp, "#endif\n");
|
||||||
|
fclose(fp);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
106
src/group.h
106
src/group.h
|
@ -12,110 +12,130 @@
|
||||||
|
|
||||||
/** A group element of the secp256k1 curve, in affine coordinates. */
|
/** A group element of the secp256k1 curve, in affine coordinates. */
|
||||||
typedef struct {
|
typedef struct {
|
||||||
secp256k1_fe_t x;
|
secp256k1_fe x;
|
||||||
secp256k1_fe_t y;
|
secp256k1_fe y;
|
||||||
int infinity; /* whether this represents the point at infinity */
|
int infinity; /* whether this represents the point at infinity */
|
||||||
} secp256k1_ge_t;
|
} secp256k1_ge;
|
||||||
|
|
||||||
#define SECP256K1_GE_CONST(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {SECP256K1_FE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_CONST((i),(j),(k),(l),(m),(n),(o),(p)), 0}
|
#define SECP256K1_GE_CONST(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {SECP256K1_FE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_CONST((i),(j),(k),(l),(m),(n),(o),(p)), 0}
|
||||||
#define SECP256K1_GE_CONST_INFINITY {SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), 1}
|
#define SECP256K1_GE_CONST_INFINITY {SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), 1}
|
||||||
|
|
||||||
/** A group element of the secp256k1 curve, in jacobian coordinates. */
|
/** A group element of the secp256k1 curve, in jacobian coordinates. */
|
||||||
typedef struct {
|
typedef struct {
|
||||||
secp256k1_fe_t x; /* actual X: x/z^2 */
|
secp256k1_fe x; /* actual X: x/z^2 */
|
||||||
secp256k1_fe_t y; /* actual Y: y/z^3 */
|
secp256k1_fe y; /* actual Y: y/z^3 */
|
||||||
secp256k1_fe_t z;
|
secp256k1_fe z;
|
||||||
int infinity; /* whether this represents the point at infinity */
|
int infinity; /* whether this represents the point at infinity */
|
||||||
} secp256k1_gej_t;
|
} secp256k1_gej;
|
||||||
|
|
||||||
#define SECP256K1_GEJ_CONST(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {SECP256K1_FE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_CONST((i),(j),(k),(l),(m),(n),(o),(p)), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 1), 0}
|
#define SECP256K1_GEJ_CONST(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {SECP256K1_FE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_CONST((i),(j),(k),(l),(m),(n),(o),(p)), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 1), 0}
|
||||||
#define SECP256K1_GEJ_CONST_INFINITY {SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), 1}
|
#define SECP256K1_GEJ_CONST_INFINITY {SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), 1}
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
secp256k1_fe_storage_t x;
|
secp256k1_fe_storage x;
|
||||||
secp256k1_fe_storage_t y;
|
secp256k1_fe_storage y;
|
||||||
} secp256k1_ge_storage_t;
|
} secp256k1_ge_storage;
|
||||||
|
|
||||||
#define SECP256K1_GE_STORAGE_CONST(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {SECP256K1_FE_STORAGE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_STORAGE_CONST((i),(j),(k),(l),(m),(n),(o),(p))}
|
#define SECP256K1_GE_STORAGE_CONST(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {SECP256K1_FE_STORAGE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_STORAGE_CONST((i),(j),(k),(l),(m),(n),(o),(p))}
|
||||||
|
|
||||||
/** Set a group element equal to the point at infinity */
|
#define SECP256K1_GE_STORAGE_CONST_GET(t) SECP256K1_FE_STORAGE_CONST_GET(t.x), SECP256K1_FE_STORAGE_CONST_GET(t.y)
|
||||||
static void secp256k1_ge_set_infinity(secp256k1_ge_t *r);
|
|
||||||
|
|
||||||
/** Set a group element equal to the point with given X and Y coordinates */
|
/** Set a group element equal to the point with given X and Y coordinates */
|
||||||
static void secp256k1_ge_set_xy(secp256k1_ge_t *r, const secp256k1_fe_t *x, const secp256k1_fe_t *y);
|
static void secp256k1_ge_set_xy(secp256k1_ge *r, const secp256k1_fe *x, const secp256k1_fe *y);
|
||||||
|
|
||||||
|
/** Set a group element (affine) equal to the point with the given X coordinate
|
||||||
|
* and a Y coordinate that is a quadratic residue modulo p. The return value
|
||||||
|
* is true iff a coordinate with the given X coordinate exists.
|
||||||
|
*/
|
||||||
|
static int secp256k1_ge_set_xquad_var(secp256k1_ge *r, const secp256k1_fe *x);
|
||||||
|
|
||||||
/** Set a group element (affine) equal to the point with the given X coordinate, and given oddness
|
/** Set a group element (affine) equal to the point with the given X coordinate, and given oddness
|
||||||
* for Y. Return value indicates whether the result is valid. */
|
* for Y. Return value indicates whether the result is valid. */
|
||||||
static int secp256k1_ge_set_xo_var(secp256k1_ge_t *r, const secp256k1_fe_t *x, int odd);
|
static int secp256k1_ge_set_xo_var(secp256k1_ge *r, const secp256k1_fe *x, int odd);
|
||||||
|
|
||||||
/** Check whether a group element is the point at infinity. */
|
/** Check whether a group element is the point at infinity. */
|
||||||
static int secp256k1_ge_is_infinity(const secp256k1_ge_t *a);
|
static int secp256k1_ge_is_infinity(const secp256k1_ge *a);
|
||||||
|
|
||||||
/** Check whether a group element is valid (i.e., on the curve). */
|
/** Check whether a group element is valid (i.e., on the curve). */
|
||||||
static int secp256k1_ge_is_valid_var(const secp256k1_ge_t *a);
|
static int secp256k1_ge_is_valid_var(const secp256k1_ge *a);
|
||||||
|
|
||||||
static void secp256k1_ge_neg(secp256k1_ge_t *r, const secp256k1_ge_t *a);
|
static void secp256k1_ge_neg(secp256k1_ge *r, const secp256k1_ge *a);
|
||||||
|
|
||||||
/** Set a group element equal to another which is given in jacobian coordinates */
|
/** Set a group element equal to another which is given in jacobian coordinates */
|
||||||
static void secp256k1_ge_set_gej(secp256k1_ge_t *r, secp256k1_gej_t *a);
|
static void secp256k1_ge_set_gej(secp256k1_ge *r, secp256k1_gej *a);
|
||||||
|
|
||||||
/** Set a batch of group elements equal to the inputs given in jacobian coordinates */
|
/** Set a batch of group elements equal to the inputs given in jacobian coordinates */
|
||||||
static void secp256k1_ge_set_all_gej_var(size_t len, secp256k1_ge_t *r, const secp256k1_gej_t *a);
|
static void secp256k1_ge_set_all_gej_var(size_t len, secp256k1_ge *r, const secp256k1_gej *a, const secp256k1_callback *cb);
|
||||||
|
|
||||||
|
/** Set a batch of group elements equal to the inputs given in jacobian
|
||||||
|
* coordinates (with known z-ratios). zr must contain the known z-ratios such
|
||||||
|
* that mul(a[i].z, zr[i+1]) == a[i+1].z. zr[0] is ignored. */
|
||||||
|
static void secp256k1_ge_set_table_gej_var(size_t len, secp256k1_ge *r, const secp256k1_gej *a, const secp256k1_fe *zr);
|
||||||
|
|
||||||
|
/** Bring a batch inputs given in jacobian coordinates (with known z-ratios) to
|
||||||
|
* the same global z "denominator". zr must contain the known z-ratios such
|
||||||
|
* that mul(a[i].z, zr[i+1]) == a[i+1].z. zr[0] is ignored. The x and y
|
||||||
|
* coordinates of the result are stored in r, the common z coordinate is
|
||||||
|
* stored in globalz. */
|
||||||
|
static void secp256k1_ge_globalz_set_table_gej(size_t len, secp256k1_ge *r, secp256k1_fe *globalz, const secp256k1_gej *a, const secp256k1_fe *zr);
|
||||||
|
|
||||||
/** Set a group element (jacobian) equal to the point at infinity. */
|
/** Set a group element (jacobian) equal to the point at infinity. */
|
||||||
static void secp256k1_gej_set_infinity(secp256k1_gej_t *r);
|
static void secp256k1_gej_set_infinity(secp256k1_gej *r);
|
||||||
|
|
||||||
/** Set a group element (jacobian) equal to the point with given X and Y coordinates. */
|
|
||||||
static void secp256k1_gej_set_xy(secp256k1_gej_t *r, const secp256k1_fe_t *x, const secp256k1_fe_t *y);
|
|
||||||
|
|
||||||
/** Set a group element (jacobian) equal to another which is given in affine coordinates. */
|
/** Set a group element (jacobian) equal to another which is given in affine coordinates. */
|
||||||
static void secp256k1_gej_set_ge(secp256k1_gej_t *r, const secp256k1_ge_t *a);
|
static void secp256k1_gej_set_ge(secp256k1_gej *r, const secp256k1_ge *a);
|
||||||
|
|
||||||
/** Compare the X coordinate of a group element (jacobian). */
|
/** Compare the X coordinate of a group element (jacobian). */
|
||||||
static int secp256k1_gej_eq_x_var(const secp256k1_fe_t *x, const secp256k1_gej_t *a);
|
static int secp256k1_gej_eq_x_var(const secp256k1_fe *x, const secp256k1_gej *a);
|
||||||
|
|
||||||
/** Set r equal to the inverse of a (i.e., mirrored around the X axis) */
|
/** Set r equal to the inverse of a (i.e., mirrored around the X axis) */
|
||||||
static void secp256k1_gej_neg(secp256k1_gej_t *r, const secp256k1_gej_t *a);
|
static void secp256k1_gej_neg(secp256k1_gej *r, const secp256k1_gej *a);
|
||||||
|
|
||||||
/** Check whether a group element is the point at infinity. */
|
/** Check whether a group element is the point at infinity. */
|
||||||
static int secp256k1_gej_is_infinity(const secp256k1_gej_t *a);
|
static int secp256k1_gej_is_infinity(const secp256k1_gej *a);
|
||||||
|
|
||||||
/** Set r equal to the double of a. */
|
/** Set r equal to the double of a. If rzr is not-NULL, r->z = a->z * *rzr (where infinity means an implicit z = 0).
|
||||||
static void secp256k1_gej_double_var(secp256k1_gej_t *r, const secp256k1_gej_t *a);
|
* a may not be zero. Constant time. */
|
||||||
|
static void secp256k1_gej_double_nonzero(secp256k1_gej *r, const secp256k1_gej *a, secp256k1_fe *rzr);
|
||||||
|
|
||||||
/** Set r equal to the sum of a and b. */
|
/** Set r equal to the double of a. If rzr is not-NULL, r->z = a->z * *rzr (where infinity means an implicit z = 0). */
|
||||||
static void secp256k1_gej_add_var(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_gej_t *b);
|
static void secp256k1_gej_double_var(secp256k1_gej *r, const secp256k1_gej *a, secp256k1_fe *rzr);
|
||||||
|
|
||||||
|
/** Set r equal to the sum of a and b. If rzr is non-NULL, r->z = a->z * *rzr (a cannot be infinity in that case). */
|
||||||
|
static void secp256k1_gej_add_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_gej *b, secp256k1_fe *rzr);
|
||||||
|
|
||||||
/** Set r equal to the sum of a and b (with b given in affine coordinates, and not infinity). */
|
/** Set r equal to the sum of a and b (with b given in affine coordinates, and not infinity). */
|
||||||
static void secp256k1_gej_add_ge(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_ge_t *b);
|
static void secp256k1_gej_add_ge(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b);
|
||||||
|
|
||||||
/** Set r equal to the sum of a and b (with b given in affine coordinates). This is more efficient
|
/** Set r equal to the sum of a and b (with b given in affine coordinates). This is more efficient
|
||||||
than secp256k1_gej_add_var. It is identical to secp256k1_gej_add_ge but without constant-time
|
than secp256k1_gej_add_var. It is identical to secp256k1_gej_add_ge but without constant-time
|
||||||
guarantee, and b is allowed to be infinity. */
|
guarantee, and b is allowed to be infinity. If rzr is non-NULL, r->z = a->z * *rzr (a cannot be infinity in that case). */
|
||||||
static void secp256k1_gej_add_ge_var(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_ge_t *b);
|
static void secp256k1_gej_add_ge_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b, secp256k1_fe *rzr);
|
||||||
|
|
||||||
|
/** Set r equal to the sum of a and b (with the inverse of b's Z coordinate passed as bzinv). */
|
||||||
|
static void secp256k1_gej_add_zinv_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b, const secp256k1_fe *bzinv);
|
||||||
|
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
/** Set r to be equal to lambda times a, where lambda is chosen in a way such that this is very fast. */
|
/** Set r to be equal to lambda times a, where lambda is chosen in a way such that this is very fast. */
|
||||||
static void secp256k1_gej_mul_lambda(secp256k1_gej_t *r, const secp256k1_gej_t *a);
|
static void secp256k1_ge_mul_lambda(secp256k1_ge *r, const secp256k1_ge *a);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/** Clear a secp256k1_gej_t to prevent leaking sensitive information. */
|
/** Clear a secp256k1_gej to prevent leaking sensitive information. */
|
||||||
static void secp256k1_gej_clear(secp256k1_gej_t *r);
|
static void secp256k1_gej_clear(secp256k1_gej *r);
|
||||||
|
|
||||||
/** Clear a secp256k1_ge_t to prevent leaking sensitive information. */
|
/** Clear a secp256k1_ge to prevent leaking sensitive information. */
|
||||||
static void secp256k1_ge_clear(secp256k1_ge_t *r);
|
static void secp256k1_ge_clear(secp256k1_ge *r);
|
||||||
|
|
||||||
/** Convert a group element to the storage type. */
|
/** Convert a group element to the storage type. */
|
||||||
static void secp256k1_ge_to_storage(secp256k1_ge_storage_t *r, const secp256k1_ge_t*);
|
static void secp256k1_ge_to_storage(secp256k1_ge_storage *r, const secp256k1_ge *a);
|
||||||
|
|
||||||
/** Convert a group element back from the storage type. */
|
/** Convert a group element back from the storage type. */
|
||||||
static void secp256k1_ge_from_storage(secp256k1_ge_t *r, const secp256k1_ge_storage_t*);
|
static void secp256k1_ge_from_storage(secp256k1_ge *r, const secp256k1_ge_storage *a);
|
||||||
|
|
||||||
/** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */
|
/** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */
|
||||||
static void secp256k1_ge_storage_cmov(secp256k1_ge_storage_t *r, const secp256k1_ge_storage_t *a, int flag);
|
static void secp256k1_ge_storage_cmov(secp256k1_ge_storage *r, const secp256k1_ge_storage *a, int flag);
|
||||||
|
|
||||||
/** Rescale a jacobian point by b which must be non-zero. Constant-time. */
|
/** Rescale a jacobian point by b which must be non-zero. Constant-time. */
|
||||||
static void secp256k1_gej_rescale(secp256k1_gej_t *r, const secp256k1_fe_t *b);
|
static void secp256k1_gej_rescale(secp256k1_gej *r, const secp256k1_fe *b);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
375
src/group_impl.h
375
src/group_impl.h
|
@ -16,35 +16,41 @@
|
||||||
/** Generator for secp256k1, value 'g' defined in
|
/** Generator for secp256k1, value 'g' defined in
|
||||||
* "Standards for Efficient Cryptography" (SEC2) 2.7.1.
|
* "Standards for Efficient Cryptography" (SEC2) 2.7.1.
|
||||||
*/
|
*/
|
||||||
static const secp256k1_ge_t secp256k1_ge_const_g = SECP256K1_GE_CONST(
|
static const secp256k1_ge secp256k1_ge_const_g = SECP256K1_GE_CONST(
|
||||||
0x79BE667EUL, 0xF9DCBBACUL, 0x55A06295UL, 0xCE870B07UL,
|
0x79BE667EUL, 0xF9DCBBACUL, 0x55A06295UL, 0xCE870B07UL,
|
||||||
0x029BFCDBUL, 0x2DCE28D9UL, 0x59F2815BUL, 0x16F81798UL,
|
0x029BFCDBUL, 0x2DCE28D9UL, 0x59F2815BUL, 0x16F81798UL,
|
||||||
0x483ADA77UL, 0x26A3C465UL, 0x5DA4FBFCUL, 0x0E1108A8UL,
|
0x483ADA77UL, 0x26A3C465UL, 0x5DA4FBFCUL, 0x0E1108A8UL,
|
||||||
0xFD17B448UL, 0xA6855419UL, 0x9C47D08FUL, 0xFB10D4B8UL
|
0xFD17B448UL, 0xA6855419UL, 0x9C47D08FUL, 0xFB10D4B8UL
|
||||||
);
|
);
|
||||||
|
|
||||||
static void secp256k1_ge_set_infinity(secp256k1_ge_t *r) {
|
static void secp256k1_ge_set_gej_zinv(secp256k1_ge *r, const secp256k1_gej *a, const secp256k1_fe *zi) {
|
||||||
r->infinity = 1;
|
secp256k1_fe zi2;
|
||||||
|
secp256k1_fe zi3;
|
||||||
|
secp256k1_fe_sqr(&zi2, zi);
|
||||||
|
secp256k1_fe_mul(&zi3, &zi2, zi);
|
||||||
|
secp256k1_fe_mul(&r->x, &a->x, &zi2);
|
||||||
|
secp256k1_fe_mul(&r->y, &a->y, &zi3);
|
||||||
|
r->infinity = a->infinity;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ge_set_xy(secp256k1_ge_t *r, const secp256k1_fe_t *x, const secp256k1_fe_t *y) {
|
static void secp256k1_ge_set_xy(secp256k1_ge *r, const secp256k1_fe *x, const secp256k1_fe *y) {
|
||||||
r->infinity = 0;
|
r->infinity = 0;
|
||||||
r->x = *x;
|
r->x = *x;
|
||||||
r->y = *y;
|
r->y = *y;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_ge_is_infinity(const secp256k1_ge_t *a) {
|
static int secp256k1_ge_is_infinity(const secp256k1_ge *a) {
|
||||||
return a->infinity;
|
return a->infinity;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ge_neg(secp256k1_ge_t *r, const secp256k1_ge_t *a) {
|
static void secp256k1_ge_neg(secp256k1_ge *r, const secp256k1_ge *a) {
|
||||||
*r = *a;
|
*r = *a;
|
||||||
secp256k1_fe_normalize_weak(&r->y);
|
secp256k1_fe_normalize_weak(&r->y);
|
||||||
secp256k1_fe_negate(&r->y, &r->y, 1);
|
secp256k1_fe_negate(&r->y, &r->y, 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ge_set_gej(secp256k1_ge_t *r, secp256k1_gej_t *a) {
|
static void secp256k1_ge_set_gej(secp256k1_ge *r, secp256k1_gej *a) {
|
||||||
secp256k1_fe_t z2, z3;
|
secp256k1_fe z2, z3;
|
||||||
r->infinity = a->infinity;
|
r->infinity = a->infinity;
|
||||||
secp256k1_fe_inv(&a->z, &a->z);
|
secp256k1_fe_inv(&a->z, &a->z);
|
||||||
secp256k1_fe_sqr(&z2, &a->z);
|
secp256k1_fe_sqr(&z2, &a->z);
|
||||||
|
@ -56,8 +62,8 @@ static void secp256k1_ge_set_gej(secp256k1_ge_t *r, secp256k1_gej_t *a) {
|
||||||
r->y = a->y;
|
r->y = a->y;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ge_set_gej_var(secp256k1_ge_t *r, secp256k1_gej_t *a) {
|
static void secp256k1_ge_set_gej_var(secp256k1_ge *r, secp256k1_gej *a) {
|
||||||
secp256k1_fe_t z2, z3;
|
secp256k1_fe z2, z3;
|
||||||
r->infinity = a->infinity;
|
r->infinity = a->infinity;
|
||||||
if (a->infinity) {
|
if (a->infinity) {
|
||||||
return;
|
return;
|
||||||
|
@ -72,19 +78,19 @@ static void secp256k1_ge_set_gej_var(secp256k1_ge_t *r, secp256k1_gej_t *a) {
|
||||||
r->y = a->y;
|
r->y = a->y;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ge_set_all_gej_var(size_t len, secp256k1_ge_t *r, const secp256k1_gej_t *a) {
|
static void secp256k1_ge_set_all_gej_var(size_t len, secp256k1_ge *r, const secp256k1_gej *a, const secp256k1_callback *cb) {
|
||||||
secp256k1_fe_t *az;
|
secp256k1_fe *az;
|
||||||
secp256k1_fe_t *azi;
|
secp256k1_fe *azi;
|
||||||
size_t i;
|
size_t i;
|
||||||
size_t count = 0;
|
size_t count = 0;
|
||||||
az = (secp256k1_fe_t *)checked_malloc(sizeof(secp256k1_fe_t) * len);
|
az = (secp256k1_fe *)checked_malloc(cb, sizeof(secp256k1_fe) * len);
|
||||||
for (i = 0; i < len; i++) {
|
for (i = 0; i < len; i++) {
|
||||||
if (!a[i].infinity) {
|
if (!a[i].infinity) {
|
||||||
az[count++] = a[i].z;
|
az[count++] = a[i].z;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
azi = (secp256k1_fe_t *)checked_malloc(sizeof(secp256k1_fe_t) * count);
|
azi = (secp256k1_fe *)checked_malloc(cb, sizeof(secp256k1_fe) * count);
|
||||||
secp256k1_fe_inv_all_var(count, azi, az);
|
secp256k1_fe_inv_all_var(count, azi, az);
|
||||||
free(az);
|
free(az);
|
||||||
|
|
||||||
|
@ -92,53 +98,86 @@ static void secp256k1_ge_set_all_gej_var(size_t len, secp256k1_ge_t *r, const se
|
||||||
for (i = 0; i < len; i++) {
|
for (i = 0; i < len; i++) {
|
||||||
r[i].infinity = a[i].infinity;
|
r[i].infinity = a[i].infinity;
|
||||||
if (!a[i].infinity) {
|
if (!a[i].infinity) {
|
||||||
secp256k1_fe_t zi2, zi3;
|
secp256k1_ge_set_gej_zinv(&r[i], &a[i], &azi[count++]);
|
||||||
secp256k1_fe_t *zi = &azi[count++];
|
|
||||||
secp256k1_fe_sqr(&zi2, zi);
|
|
||||||
secp256k1_fe_mul(&zi3, &zi2, zi);
|
|
||||||
secp256k1_fe_mul(&r[i].x, &a[i].x, &zi2);
|
|
||||||
secp256k1_fe_mul(&r[i].y, &a[i].y, &zi3);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
free(azi);
|
free(azi);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_gej_set_infinity(secp256k1_gej_t *r) {
|
static void secp256k1_ge_set_table_gej_var(size_t len, secp256k1_ge *r, const secp256k1_gej *a, const secp256k1_fe *zr) {
|
||||||
|
size_t i = len - 1;
|
||||||
|
secp256k1_fe zi;
|
||||||
|
|
||||||
|
if (len > 0) {
|
||||||
|
/* Compute the inverse of the last z coordinate, and use it to compute the last affine output. */
|
||||||
|
secp256k1_fe_inv(&zi, &a[i].z);
|
||||||
|
secp256k1_ge_set_gej_zinv(&r[i], &a[i], &zi);
|
||||||
|
|
||||||
|
/* Work out way backwards, using the z-ratios to scale the x/y values. */
|
||||||
|
while (i > 0) {
|
||||||
|
secp256k1_fe_mul(&zi, &zi, &zr[i]);
|
||||||
|
i--;
|
||||||
|
secp256k1_ge_set_gej_zinv(&r[i], &a[i], &zi);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void secp256k1_ge_globalz_set_table_gej(size_t len, secp256k1_ge *r, secp256k1_fe *globalz, const secp256k1_gej *a, const secp256k1_fe *zr) {
|
||||||
|
size_t i = len - 1;
|
||||||
|
secp256k1_fe zs;
|
||||||
|
|
||||||
|
if (len > 0) {
|
||||||
|
/* The z of the final point gives us the "global Z" for the table. */
|
||||||
|
r[i].x = a[i].x;
|
||||||
|
r[i].y = a[i].y;
|
||||||
|
*globalz = a[i].z;
|
||||||
|
r[i].infinity = 0;
|
||||||
|
zs = zr[i];
|
||||||
|
|
||||||
|
/* Work our way backwards, using the z-ratios to scale the x/y values. */
|
||||||
|
while (i > 0) {
|
||||||
|
if (i != len - 1) {
|
||||||
|
secp256k1_fe_mul(&zs, &zs, &zr[i]);
|
||||||
|
}
|
||||||
|
i--;
|
||||||
|
secp256k1_ge_set_gej_zinv(&r[i], &a[i], &zs);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void secp256k1_gej_set_infinity(secp256k1_gej *r) {
|
||||||
r->infinity = 1;
|
r->infinity = 1;
|
||||||
secp256k1_fe_set_int(&r->x, 0);
|
secp256k1_fe_set_int(&r->x, 0);
|
||||||
secp256k1_fe_set_int(&r->y, 0);
|
secp256k1_fe_set_int(&r->y, 0);
|
||||||
secp256k1_fe_set_int(&r->z, 0);
|
secp256k1_fe_set_int(&r->z, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_gej_set_xy(secp256k1_gej_t *r, const secp256k1_fe_t *x, const secp256k1_fe_t *y) {
|
static void secp256k1_gej_clear(secp256k1_gej *r) {
|
||||||
r->infinity = 0;
|
|
||||||
r->x = *x;
|
|
||||||
r->y = *y;
|
|
||||||
secp256k1_fe_set_int(&r->z, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void secp256k1_gej_clear(secp256k1_gej_t *r) {
|
|
||||||
r->infinity = 0;
|
r->infinity = 0;
|
||||||
secp256k1_fe_clear(&r->x);
|
secp256k1_fe_clear(&r->x);
|
||||||
secp256k1_fe_clear(&r->y);
|
secp256k1_fe_clear(&r->y);
|
||||||
secp256k1_fe_clear(&r->z);
|
secp256k1_fe_clear(&r->z);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ge_clear(secp256k1_ge_t *r) {
|
static void secp256k1_ge_clear(secp256k1_ge *r) {
|
||||||
r->infinity = 0;
|
r->infinity = 0;
|
||||||
secp256k1_fe_clear(&r->x);
|
secp256k1_fe_clear(&r->x);
|
||||||
secp256k1_fe_clear(&r->y);
|
secp256k1_fe_clear(&r->y);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_ge_set_xo_var(secp256k1_ge_t *r, const secp256k1_fe_t *x, int odd) {
|
static int secp256k1_ge_set_xquad_var(secp256k1_ge *r, const secp256k1_fe *x) {
|
||||||
secp256k1_fe_t x2, x3, c;
|
secp256k1_fe x2, x3, c;
|
||||||
r->x = *x;
|
r->x = *x;
|
||||||
secp256k1_fe_sqr(&x2, x);
|
secp256k1_fe_sqr(&x2, x);
|
||||||
secp256k1_fe_mul(&x3, x, &x2);
|
secp256k1_fe_mul(&x3, x, &x2);
|
||||||
r->infinity = 0;
|
r->infinity = 0;
|
||||||
secp256k1_fe_set_int(&c, 7);
|
secp256k1_fe_set_int(&c, 7);
|
||||||
secp256k1_fe_add(&c, &x3);
|
secp256k1_fe_add(&c, &x3);
|
||||||
if (!secp256k1_fe_sqrt_var(&r->y, &c)) {
|
return secp256k1_fe_sqrt_var(&r->y, &c);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int secp256k1_ge_set_xo_var(secp256k1_ge *r, const secp256k1_fe *x, int odd) {
|
||||||
|
if (!secp256k1_ge_set_xquad_var(r, x)) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
secp256k1_fe_normalize_var(&r->y);
|
secp256k1_fe_normalize_var(&r->y);
|
||||||
|
@ -146,24 +185,25 @@ static int secp256k1_ge_set_xo_var(secp256k1_ge_t *r, const secp256k1_fe_t *x, i
|
||||||
secp256k1_fe_negate(&r->y, &r->y, 1);
|
secp256k1_fe_negate(&r->y, &r->y, 1);
|
||||||
}
|
}
|
||||||
return 1;
|
return 1;
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_gej_set_ge(secp256k1_gej_t *r, const secp256k1_ge_t *a) {
|
static void secp256k1_gej_set_ge(secp256k1_gej *r, const secp256k1_ge *a) {
|
||||||
r->infinity = a->infinity;
|
r->infinity = a->infinity;
|
||||||
r->x = a->x;
|
r->x = a->x;
|
||||||
r->y = a->y;
|
r->y = a->y;
|
||||||
secp256k1_fe_set_int(&r->z, 1);
|
secp256k1_fe_set_int(&r->z, 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_gej_eq_x_var(const secp256k1_fe_t *x, const secp256k1_gej_t *a) {
|
static int secp256k1_gej_eq_x_var(const secp256k1_fe *x, const secp256k1_gej *a) {
|
||||||
secp256k1_fe_t r, r2;
|
secp256k1_fe r, r2;
|
||||||
VERIFY_CHECK(!a->infinity);
|
VERIFY_CHECK(!a->infinity);
|
||||||
secp256k1_fe_sqr(&r, &a->z); secp256k1_fe_mul(&r, &r, x);
|
secp256k1_fe_sqr(&r, &a->z); secp256k1_fe_mul(&r, &r, x);
|
||||||
r2 = a->x; secp256k1_fe_normalize_weak(&r2);
|
r2 = a->x; secp256k1_fe_normalize_weak(&r2);
|
||||||
return secp256k1_fe_equal_var(&r, &r2);
|
return secp256k1_fe_equal_var(&r, &r2);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_gej_neg(secp256k1_gej_t *r, const secp256k1_gej_t *a) {
|
static void secp256k1_gej_neg(secp256k1_gej *r, const secp256k1_gej *a) {
|
||||||
r->infinity = a->infinity;
|
r->infinity = a->infinity;
|
||||||
r->x = a->x;
|
r->x = a->x;
|
||||||
r->y = a->y;
|
r->y = a->y;
|
||||||
|
@ -172,12 +212,12 @@ static void secp256k1_gej_neg(secp256k1_gej_t *r, const secp256k1_gej_t *a) {
|
||||||
secp256k1_fe_negate(&r->y, &r->y, 1);
|
secp256k1_fe_negate(&r->y, &r->y, 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_gej_is_infinity(const secp256k1_gej_t *a) {
|
static int secp256k1_gej_is_infinity(const secp256k1_gej *a) {
|
||||||
return a->infinity;
|
return a->infinity;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_gej_is_valid_var(const secp256k1_gej_t *a) {
|
static int secp256k1_gej_is_valid_var(const secp256k1_gej *a) {
|
||||||
secp256k1_fe_t y2, x3, z2, z6;
|
secp256k1_fe y2, x3, z2, z6;
|
||||||
if (a->infinity) {
|
if (a->infinity) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
@ -196,8 +236,8 @@ static int secp256k1_gej_is_valid_var(const secp256k1_gej_t *a) {
|
||||||
return secp256k1_fe_equal_var(&y2, &x3);
|
return secp256k1_fe_equal_var(&y2, &x3);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_ge_is_valid_var(const secp256k1_ge_t *a) {
|
static int secp256k1_ge_is_valid_var(const secp256k1_ge *a) {
|
||||||
secp256k1_fe_t y2, x3, c;
|
secp256k1_fe y2, x3, c;
|
||||||
if (a->infinity) {
|
if (a->infinity) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
@ -210,18 +250,27 @@ static int secp256k1_ge_is_valid_var(const secp256k1_ge_t *a) {
|
||||||
return secp256k1_fe_equal_var(&y2, &x3);
|
return secp256k1_fe_equal_var(&y2, &x3);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_gej_double_var(secp256k1_gej_t *r, const secp256k1_gej_t *a) {
|
static void secp256k1_gej_double_var(secp256k1_gej *r, const secp256k1_gej *a, secp256k1_fe *rzr) {
|
||||||
/* Operations: 3 mul, 4 sqr, 0 normalize, 12 mul_int/add/negate */
|
/* Operations: 3 mul, 4 sqr, 0 normalize, 12 mul_int/add/negate */
|
||||||
secp256k1_fe_t t1,t2,t3,t4;
|
secp256k1_fe t1,t2,t3,t4;
|
||||||
/** For secp256k1, 2Q is infinity if and only if Q is infinity. This is because if 2Q = infinity,
|
/** For secp256k1, 2Q is infinity if and only if Q is infinity. This is because if 2Q = infinity,
|
||||||
* Q must equal -Q, or that Q.y == -(Q.y), or Q.y is 0. For a point on y^2 = x^3 + 7 to have
|
* Q must equal -Q, or that Q.y == -(Q.y), or Q.y is 0. For a point on y^2 = x^3 + 7 to have
|
||||||
* y=0, x^3 must be -7 mod p. However, -7 has no cube root mod p.
|
* y=0, x^3 must be -7 mod p. However, -7 has no cube root mod p.
|
||||||
*/
|
*/
|
||||||
r->infinity = a->infinity;
|
r->infinity = a->infinity;
|
||||||
if (r->infinity) {
|
if (r->infinity) {
|
||||||
|
if (rzr != NULL) {
|
||||||
|
secp256k1_fe_set_int(rzr, 1);
|
||||||
|
}
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if (rzr != NULL) {
|
||||||
|
*rzr = a->y;
|
||||||
|
secp256k1_fe_normalize_weak(rzr);
|
||||||
|
secp256k1_fe_mul_int(rzr, 2);
|
||||||
|
}
|
||||||
|
|
||||||
secp256k1_fe_mul(&r->z, &a->z, &a->y);
|
secp256k1_fe_mul(&r->z, &a->z, &a->y);
|
||||||
secp256k1_fe_mul_int(&r->z, 2); /* Z' = 2*Y*Z (2) */
|
secp256k1_fe_mul_int(&r->z, 2); /* Z' = 2*Y*Z (2) */
|
||||||
secp256k1_fe_sqr(&t1, &a->x);
|
secp256k1_fe_sqr(&t1, &a->x);
|
||||||
|
@ -244,17 +293,29 @@ static void secp256k1_gej_double_var(secp256k1_gej_t *r, const secp256k1_gej_t *
|
||||||
secp256k1_fe_add(&r->y, &t2); /* Y' = 36*X^3*Y^2 - 27*X^6 - 8*Y^4 (4) */
|
secp256k1_fe_add(&r->y, &t2); /* Y' = 36*X^3*Y^2 - 27*X^6 - 8*Y^4 (4) */
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_gej_add_var(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_gej_t *b) {
|
static SECP256K1_INLINE void secp256k1_gej_double_nonzero(secp256k1_gej *r, const secp256k1_gej *a, secp256k1_fe *rzr) {
|
||||||
|
VERIFY_CHECK(!secp256k1_gej_is_infinity(a));
|
||||||
|
secp256k1_gej_double_var(r, a, rzr);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void secp256k1_gej_add_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_gej *b, secp256k1_fe *rzr) {
|
||||||
/* Operations: 12 mul, 4 sqr, 2 normalize, 12 mul_int/add/negate */
|
/* Operations: 12 mul, 4 sqr, 2 normalize, 12 mul_int/add/negate */
|
||||||
secp256k1_fe_t z22, z12, u1, u2, s1, s2, h, i, i2, h2, h3, t;
|
secp256k1_fe z22, z12, u1, u2, s1, s2, h, i, i2, h2, h3, t;
|
||||||
|
|
||||||
if (a->infinity) {
|
if (a->infinity) {
|
||||||
|
VERIFY_CHECK(rzr == NULL);
|
||||||
*r = *b;
|
*r = *b;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (b->infinity) {
|
if (b->infinity) {
|
||||||
|
if (rzr != NULL) {
|
||||||
|
secp256k1_fe_set_int(rzr, 1);
|
||||||
|
}
|
||||||
*r = *a;
|
*r = *a;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
r->infinity = 0;
|
r->infinity = 0;
|
||||||
secp256k1_fe_sqr(&z22, &b->z);
|
secp256k1_fe_sqr(&z22, &b->z);
|
||||||
secp256k1_fe_sqr(&z12, &a->z);
|
secp256k1_fe_sqr(&z12, &a->z);
|
||||||
|
@ -266,8 +327,11 @@ static void secp256k1_gej_add_var(secp256k1_gej_t *r, const secp256k1_gej_t *a,
|
||||||
secp256k1_fe_negate(&i, &s1, 1); secp256k1_fe_add(&i, &s2);
|
secp256k1_fe_negate(&i, &s1, 1); secp256k1_fe_add(&i, &s2);
|
||||||
if (secp256k1_fe_normalizes_to_zero_var(&h)) {
|
if (secp256k1_fe_normalizes_to_zero_var(&h)) {
|
||||||
if (secp256k1_fe_normalizes_to_zero_var(&i)) {
|
if (secp256k1_fe_normalizes_to_zero_var(&i)) {
|
||||||
secp256k1_gej_double_var(r, a);
|
secp256k1_gej_double_var(r, a, rzr);
|
||||||
} else {
|
} else {
|
||||||
|
if (rzr != NULL) {
|
||||||
|
secp256k1_fe_set_int(rzr, 0);
|
||||||
|
}
|
||||||
r->infinity = 1;
|
r->infinity = 1;
|
||||||
}
|
}
|
||||||
return;
|
return;
|
||||||
|
@ -275,7 +339,11 @@ static void secp256k1_gej_add_var(secp256k1_gej_t *r, const secp256k1_gej_t *a,
|
||||||
secp256k1_fe_sqr(&i2, &i);
|
secp256k1_fe_sqr(&i2, &i);
|
||||||
secp256k1_fe_sqr(&h2, &h);
|
secp256k1_fe_sqr(&h2, &h);
|
||||||
secp256k1_fe_mul(&h3, &h, &h2);
|
secp256k1_fe_mul(&h3, &h, &h2);
|
||||||
secp256k1_fe_mul(&r->z, &a->z, &b->z); secp256k1_fe_mul(&r->z, &r->z, &h);
|
secp256k1_fe_mul(&h, &h, &b->z);
|
||||||
|
if (rzr != NULL) {
|
||||||
|
*rzr = h;
|
||||||
|
}
|
||||||
|
secp256k1_fe_mul(&r->z, &a->z, &h);
|
||||||
secp256k1_fe_mul(&t, &u1, &h2);
|
secp256k1_fe_mul(&t, &u1, &h2);
|
||||||
r->x = t; secp256k1_fe_mul_int(&r->x, 2); secp256k1_fe_add(&r->x, &h3); secp256k1_fe_negate(&r->x, &r->x, 3); secp256k1_fe_add(&r->x, &i2);
|
r->x = t; secp256k1_fe_mul_int(&r->x, 2); secp256k1_fe_add(&r->x, &h3); secp256k1_fe_negate(&r->x, &r->x, 3); secp256k1_fe_add(&r->x, &i2);
|
||||||
secp256k1_fe_negate(&r->y, &r->x, 5); secp256k1_fe_add(&r->y, &t); secp256k1_fe_mul(&r->y, &r->y, &i);
|
secp256k1_fe_negate(&r->y, &r->x, 5); secp256k1_fe_add(&r->y, &t); secp256k1_fe_mul(&r->y, &r->y, &i);
|
||||||
|
@ -283,21 +351,23 @@ static void secp256k1_gej_add_var(secp256k1_gej_t *r, const secp256k1_gej_t *a,
|
||||||
secp256k1_fe_add(&r->y, &h3);
|
secp256k1_fe_add(&r->y, &h3);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_gej_add_ge_var(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_ge_t *b) {
|
static void secp256k1_gej_add_ge_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b, secp256k1_fe *rzr) {
|
||||||
/* 8 mul, 3 sqr, 4 normalize, 12 mul_int/add/negate */
|
/* 8 mul, 3 sqr, 4 normalize, 12 mul_int/add/negate */
|
||||||
secp256k1_fe_t z12, u1, u2, s1, s2, h, i, i2, h2, h3, t;
|
secp256k1_fe z12, u1, u2, s1, s2, h, i, i2, h2, h3, t;
|
||||||
if (a->infinity) {
|
if (a->infinity) {
|
||||||
r->infinity = b->infinity;
|
VERIFY_CHECK(rzr == NULL);
|
||||||
r->x = b->x;
|
secp256k1_gej_set_ge(r, b);
|
||||||
r->y = b->y;
|
|
||||||
secp256k1_fe_set_int(&r->z, 1);
|
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if (b->infinity) {
|
if (b->infinity) {
|
||||||
|
if (rzr != NULL) {
|
||||||
|
secp256k1_fe_set_int(rzr, 1);
|
||||||
|
}
|
||||||
*r = *a;
|
*r = *a;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
r->infinity = 0;
|
r->infinity = 0;
|
||||||
|
|
||||||
secp256k1_fe_sqr(&z12, &a->z);
|
secp256k1_fe_sqr(&z12, &a->z);
|
||||||
u1 = a->x; secp256k1_fe_normalize_weak(&u1);
|
u1 = a->x; secp256k1_fe_normalize_weak(&u1);
|
||||||
secp256k1_fe_mul(&u2, &b->x, &z12);
|
secp256k1_fe_mul(&u2, &b->x, &z12);
|
||||||
|
@ -307,7 +377,69 @@ static void secp256k1_gej_add_ge_var(secp256k1_gej_t *r, const secp256k1_gej_t *
|
||||||
secp256k1_fe_negate(&i, &s1, 1); secp256k1_fe_add(&i, &s2);
|
secp256k1_fe_negate(&i, &s1, 1); secp256k1_fe_add(&i, &s2);
|
||||||
if (secp256k1_fe_normalizes_to_zero_var(&h)) {
|
if (secp256k1_fe_normalizes_to_zero_var(&h)) {
|
||||||
if (secp256k1_fe_normalizes_to_zero_var(&i)) {
|
if (secp256k1_fe_normalizes_to_zero_var(&i)) {
|
||||||
secp256k1_gej_double_var(r, a);
|
secp256k1_gej_double_var(r, a, rzr);
|
||||||
|
} else {
|
||||||
|
if (rzr != NULL) {
|
||||||
|
secp256k1_fe_set_int(rzr, 0);
|
||||||
|
}
|
||||||
|
r->infinity = 1;
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
secp256k1_fe_sqr(&i2, &i);
|
||||||
|
secp256k1_fe_sqr(&h2, &h);
|
||||||
|
secp256k1_fe_mul(&h3, &h, &h2);
|
||||||
|
if (rzr != NULL) {
|
||||||
|
*rzr = h;
|
||||||
|
}
|
||||||
|
secp256k1_fe_mul(&r->z, &a->z, &h);
|
||||||
|
secp256k1_fe_mul(&t, &u1, &h2);
|
||||||
|
r->x = t; secp256k1_fe_mul_int(&r->x, 2); secp256k1_fe_add(&r->x, &h3); secp256k1_fe_negate(&r->x, &r->x, 3); secp256k1_fe_add(&r->x, &i2);
|
||||||
|
secp256k1_fe_negate(&r->y, &r->x, 5); secp256k1_fe_add(&r->y, &t); secp256k1_fe_mul(&r->y, &r->y, &i);
|
||||||
|
secp256k1_fe_mul(&h3, &h3, &s1); secp256k1_fe_negate(&h3, &h3, 1);
|
||||||
|
secp256k1_fe_add(&r->y, &h3);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void secp256k1_gej_add_zinv_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b, const secp256k1_fe *bzinv) {
|
||||||
|
/* 9 mul, 3 sqr, 4 normalize, 12 mul_int/add/negate */
|
||||||
|
secp256k1_fe az, z12, u1, u2, s1, s2, h, i, i2, h2, h3, t;
|
||||||
|
|
||||||
|
if (b->infinity) {
|
||||||
|
*r = *a;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (a->infinity) {
|
||||||
|
secp256k1_fe bzinv2, bzinv3;
|
||||||
|
r->infinity = b->infinity;
|
||||||
|
secp256k1_fe_sqr(&bzinv2, bzinv);
|
||||||
|
secp256k1_fe_mul(&bzinv3, &bzinv2, bzinv);
|
||||||
|
secp256k1_fe_mul(&r->x, &b->x, &bzinv2);
|
||||||
|
secp256k1_fe_mul(&r->y, &b->y, &bzinv3);
|
||||||
|
secp256k1_fe_set_int(&r->z, 1);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
r->infinity = 0;
|
||||||
|
|
||||||
|
/** We need to calculate (rx,ry,rz) = (ax,ay,az) + (bx,by,1/bzinv). Due to
|
||||||
|
* secp256k1's isomorphism we can multiply the Z coordinates on both sides
|
||||||
|
* by bzinv, and get: (rx,ry,rz*bzinv) = (ax,ay,az*bzinv) + (bx,by,1).
|
||||||
|
* This means that (rx,ry,rz) can be calculated as
|
||||||
|
* (ax,ay,az*bzinv) + (bx,by,1), when not applying the bzinv factor to rz.
|
||||||
|
* The variable az below holds the modified Z coordinate for a, which is used
|
||||||
|
* for the computation of rx and ry, but not for rz.
|
||||||
|
*/
|
||||||
|
secp256k1_fe_mul(&az, &a->z, bzinv);
|
||||||
|
|
||||||
|
secp256k1_fe_sqr(&z12, &az);
|
||||||
|
u1 = a->x; secp256k1_fe_normalize_weak(&u1);
|
||||||
|
secp256k1_fe_mul(&u2, &b->x, &z12);
|
||||||
|
s1 = a->y; secp256k1_fe_normalize_weak(&s1);
|
||||||
|
secp256k1_fe_mul(&s2, &b->y, &z12); secp256k1_fe_mul(&s2, &s2, &az);
|
||||||
|
secp256k1_fe_negate(&h, &u1, 1); secp256k1_fe_add(&h, &u2);
|
||||||
|
secp256k1_fe_negate(&i, &s1, 1); secp256k1_fe_add(&i, &s2);
|
||||||
|
if (secp256k1_fe_normalizes_to_zero_var(&h)) {
|
||||||
|
if (secp256k1_fe_normalizes_to_zero_var(&i)) {
|
||||||
|
secp256k1_gej_double_var(r, a, NULL);
|
||||||
} else {
|
} else {
|
||||||
r->infinity = 1;
|
r->infinity = 1;
|
||||||
}
|
}
|
||||||
|
@ -324,11 +456,13 @@ static void secp256k1_gej_add_ge_var(secp256k1_gej_t *r, const secp256k1_gej_t *
|
||||||
secp256k1_fe_add(&r->y, &h3);
|
secp256k1_fe_add(&r->y, &h3);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_gej_add_ge(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_ge_t *b) {
|
|
||||||
/* Operations: 7 mul, 5 sqr, 5 normalize, 17 mul_int/add/negate/cmov */
|
static void secp256k1_gej_add_ge(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b) {
|
||||||
static const secp256k1_fe_t fe_1 = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 1);
|
/* Operations: 7 mul, 5 sqr, 4 normalize, 21 mul_int/add/negate/cmov */
|
||||||
secp256k1_fe_t zz, u1, u2, s1, s2, z, t, m, n, q, rr;
|
static const secp256k1_fe fe_1 = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 1);
|
||||||
int infinity;
|
secp256k1_fe zz, u1, u2, s1, s2, t, tt, m, n, q, rr;
|
||||||
|
secp256k1_fe m_alt, rr_alt;
|
||||||
|
int infinity, degenerate;
|
||||||
VERIFY_CHECK(!b->infinity);
|
VERIFY_CHECK(!b->infinity);
|
||||||
VERIFY_CHECK(a->infinity == 0 || a->infinity == 1);
|
VERIFY_CHECK(a->infinity == 0 || a->infinity == 1);
|
||||||
|
|
||||||
|
@ -352,53 +486,102 @@ static void secp256k1_gej_add_ge(secp256k1_gej_t *r, const secp256k1_gej_t *a, c
|
||||||
* Y3 = 4*(R*(3*Q-2*R^2)-M^4)
|
* Y3 = 4*(R*(3*Q-2*R^2)-M^4)
|
||||||
* Z3 = 2*M*Z
|
* Z3 = 2*M*Z
|
||||||
* (Note that the paper uses xi = Xi / Zi and yi = Yi / Zi instead.)
|
* (Note that the paper uses xi = Xi / Zi and yi = Yi / Zi instead.)
|
||||||
|
*
|
||||||
|
* This formula has the benefit of being the same for both addition
|
||||||
|
* of distinct points and doubling. However, it breaks down in the
|
||||||
|
* case that either point is infinity, or that y1 = -y2. We handle
|
||||||
|
* these cases in the following ways:
|
||||||
|
*
|
||||||
|
* - If b is infinity we simply bail by means of a VERIFY_CHECK.
|
||||||
|
*
|
||||||
|
* - If a is infinity, we detect this, and at the end of the
|
||||||
|
* computation replace the result (which will be meaningless,
|
||||||
|
* but we compute to be constant-time) with b.x : b.y : 1.
|
||||||
|
*
|
||||||
|
* - If a = -b, we have y1 = -y2, which is a degenerate case.
|
||||||
|
* But here the answer is infinity, so we simply set the
|
||||||
|
* infinity flag of the result, overriding the computed values
|
||||||
|
* without even needing to cmov.
|
||||||
|
*
|
||||||
|
* - If y1 = -y2 but x1 != x2, which does occur thanks to certain
|
||||||
|
* properties of our curve (specifically, 1 has nontrivial cube
|
||||||
|
* roots in our field, and the curve equation has no x coefficient)
|
||||||
|
* then the answer is not infinity but also not given by the above
|
||||||
|
* equation. In this case, we cmov in place an alternate expression
|
||||||
|
* for lambda. Specifically (y1 - y2)/(x1 - x2). Where both these
|
||||||
|
* expressions for lambda are defined, they are equal, and can be
|
||||||
|
* obtained from each other by multiplication by (y1 + y2)/(y1 + y2)
|
||||||
|
* then substitution of x^3 + 7 for y^2 (using the curve equation).
|
||||||
|
* For all pairs of nonzero points (a, b) at least one is defined,
|
||||||
|
* so this covers everything.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
secp256k1_fe_sqr(&zz, &a->z); /* z = Z1^2 */
|
secp256k1_fe_sqr(&zz, &a->z); /* z = Z1^2 */
|
||||||
u1 = a->x; secp256k1_fe_normalize_weak(&u1); /* u1 = U1 = X1*Z2^2 (1) */
|
u1 = a->x; secp256k1_fe_normalize_weak(&u1); /* u1 = U1 = X1*Z2^2 (1) */
|
||||||
secp256k1_fe_mul(&u2, &b->x, &zz); /* u2 = U2 = X2*Z1^2 (1) */
|
secp256k1_fe_mul(&u2, &b->x, &zz); /* u2 = U2 = X2*Z1^2 (1) */
|
||||||
s1 = a->y; secp256k1_fe_normalize_weak(&s1); /* s1 = S1 = Y1*Z2^3 (1) */
|
s1 = a->y; secp256k1_fe_normalize_weak(&s1); /* s1 = S1 = Y1*Z2^3 (1) */
|
||||||
secp256k1_fe_mul(&s2, &b->y, &zz); /* s2 = Y2*Z2^2 (1) */
|
secp256k1_fe_mul(&s2, &b->y, &zz); /* s2 = Y2*Z1^2 (1) */
|
||||||
secp256k1_fe_mul(&s2, &s2, &a->z); /* s2 = S2 = Y2*Z1^3 (1) */
|
secp256k1_fe_mul(&s2, &s2, &a->z); /* s2 = S2 = Y2*Z1^3 (1) */
|
||||||
z = a->z; /* z = Z = Z1*Z2 (8) */
|
|
||||||
t = u1; secp256k1_fe_add(&t, &u2); /* t = T = U1+U2 (2) */
|
t = u1; secp256k1_fe_add(&t, &u2); /* t = T = U1+U2 (2) */
|
||||||
m = s1; secp256k1_fe_add(&m, &s2); /* m = M = S1+S2 (2) */
|
m = s1; secp256k1_fe_add(&m, &s2); /* m = M = S1+S2 (2) */
|
||||||
secp256k1_fe_sqr(&n, &m); /* n = M^2 (1) */
|
|
||||||
secp256k1_fe_mul(&q, &n, &t); /* q = Q = T*M^2 (1) */
|
|
||||||
secp256k1_fe_sqr(&n, &n); /* n = M^4 (1) */
|
|
||||||
secp256k1_fe_sqr(&rr, &t); /* rr = T^2 (1) */
|
secp256k1_fe_sqr(&rr, &t); /* rr = T^2 (1) */
|
||||||
secp256k1_fe_mul(&t, &u1, &u2); secp256k1_fe_negate(&t, &t, 1); /* t = -U1*U2 (2) */
|
secp256k1_fe_negate(&m_alt, &u2, 1); /* Malt = -X2*Z1^2 */
|
||||||
secp256k1_fe_add(&rr, &t); /* rr = R = T^2-U1*U2 (3) */
|
secp256k1_fe_mul(&tt, &u1, &m_alt); /* tt = -U1*U2 (2) */
|
||||||
secp256k1_fe_sqr(&t, &rr); /* t = R^2 (1) */
|
secp256k1_fe_add(&rr, &tt); /* rr = R = T^2-U1*U2 (3) */
|
||||||
secp256k1_fe_mul(&r->z, &m, &z); /* r->z = M*Z (1) */
|
/** If lambda = R/M = 0/0 we have a problem (except in the "trivial"
|
||||||
infinity = secp256k1_fe_normalizes_to_zero(&r->z) * (1 - a->infinity);
|
* case that Z = z1z2 = 0, and this is special-cased later on). */
|
||||||
secp256k1_fe_mul_int(&r->z, 2 * (1 - a->infinity)); /* r->z = Z3 = 2*M*Z (2) */
|
degenerate = secp256k1_fe_normalizes_to_zero(&m) &
|
||||||
r->x = t; /* r->x = R^2 (1) */
|
secp256k1_fe_normalizes_to_zero(&rr);
|
||||||
secp256k1_fe_negate(&q, &q, 1); /* q = -Q (2) */
|
/* This only occurs when y1 == -y2 and x1^3 == x2^3, but x1 != x2.
|
||||||
secp256k1_fe_add(&r->x, &q); /* r->x = R^2-Q (3) */
|
* This means either x1 == beta*x2 or beta*x1 == x2, where beta is
|
||||||
secp256k1_fe_normalize(&r->x);
|
* a nontrivial cube root of one. In either case, an alternate
|
||||||
secp256k1_fe_mul_int(&q, 3); /* q = -3*Q (6) */
|
* non-indeterminate expression for lambda is (y1 - y2)/(x1 - x2),
|
||||||
secp256k1_fe_mul_int(&t, 2); /* t = 2*R^2 (2) */
|
* so we set R/M equal to this. */
|
||||||
secp256k1_fe_add(&t, &q); /* t = 2*R^2-3*Q (8) */
|
rr_alt = s1;
|
||||||
secp256k1_fe_mul(&t, &t, &rr); /* t = R*(2*R^2-3*Q) (1) */
|
secp256k1_fe_mul_int(&rr_alt, 2); /* rr = Y1*Z2^3 - Y2*Z1^3 (2) */
|
||||||
secp256k1_fe_add(&t, &n); /* t = R*(2*R^2-3*Q)+M^4 (2) */
|
secp256k1_fe_add(&m_alt, &u1); /* Malt = X1*Z2^2 - X2*Z1^2 */
|
||||||
secp256k1_fe_negate(&r->y, &t, 2); /* r->y = R*(3*Q-2*R^2)-M^4 (3) */
|
|
||||||
secp256k1_fe_normalize_weak(&r->y);
|
|
||||||
secp256k1_fe_mul_int(&r->x, 4 * (1 - a->infinity)); /* r->x = X3 = 4*(R^2-Q) */
|
|
||||||
secp256k1_fe_mul_int(&r->y, 4 * (1 - a->infinity)); /* r->y = Y3 = 4*R*(3*Q-2*R^2)-4*M^4 (4) */
|
|
||||||
|
|
||||||
/** In case a->infinity == 1, the above code results in r->x, r->y, and r->z all equal to 0.
|
secp256k1_fe_cmov(&rr_alt, &rr, !degenerate);
|
||||||
* Replace r with b->x, b->y, 1 in that case.
|
secp256k1_fe_cmov(&m_alt, &m, !degenerate);
|
||||||
*/
|
/* Now Ralt / Malt = lambda and is guaranteed not to be 0/0.
|
||||||
|
* From here on out Ralt and Malt represent the numerator
|
||||||
|
* and denominator of lambda; R and M represent the explicit
|
||||||
|
* expressions x1^2 + x2^2 + x1x2 and y1 + y2. */
|
||||||
|
secp256k1_fe_sqr(&n, &m_alt); /* n = Malt^2 (1) */
|
||||||
|
secp256k1_fe_mul(&q, &n, &t); /* q = Q = T*Malt^2 (1) */
|
||||||
|
/* These two lines use the observation that either M == Malt or M == 0,
|
||||||
|
* so M^3 * Malt is either Malt^4 (which is computed by squaring), or
|
||||||
|
* zero (which is "computed" by cmov). So the cost is one squaring
|
||||||
|
* versus two multiplications. */
|
||||||
|
secp256k1_fe_sqr(&n, &n);
|
||||||
|
secp256k1_fe_cmov(&n, &m, degenerate); /* n = M^3 * Malt (2) */
|
||||||
|
secp256k1_fe_sqr(&t, &rr_alt); /* t = Ralt^2 (1) */
|
||||||
|
secp256k1_fe_mul(&r->z, &a->z, &m_alt); /* r->z = Malt*Z (1) */
|
||||||
|
infinity = secp256k1_fe_normalizes_to_zero(&r->z) * (1 - a->infinity);
|
||||||
|
secp256k1_fe_mul_int(&r->z, 2); /* r->z = Z3 = 2*Malt*Z (2) */
|
||||||
|
secp256k1_fe_negate(&q, &q, 1); /* q = -Q (2) */
|
||||||
|
secp256k1_fe_add(&t, &q); /* t = Ralt^2-Q (3) */
|
||||||
|
secp256k1_fe_normalize_weak(&t);
|
||||||
|
r->x = t; /* r->x = Ralt^2-Q (1) */
|
||||||
|
secp256k1_fe_mul_int(&t, 2); /* t = 2*x3 (2) */
|
||||||
|
secp256k1_fe_add(&t, &q); /* t = 2*x3 - Q: (4) */
|
||||||
|
secp256k1_fe_mul(&t, &t, &rr_alt); /* t = Ralt*(2*x3 - Q) (1) */
|
||||||
|
secp256k1_fe_add(&t, &n); /* t = Ralt*(2*x3 - Q) + M^3*Malt (3) */
|
||||||
|
secp256k1_fe_negate(&r->y, &t, 3); /* r->y = Ralt*(Q - 2x3) - M^3*Malt (4) */
|
||||||
|
secp256k1_fe_normalize_weak(&r->y);
|
||||||
|
secp256k1_fe_mul_int(&r->x, 4); /* r->x = X3 = 4*(Ralt^2-Q) */
|
||||||
|
secp256k1_fe_mul_int(&r->y, 4); /* r->y = Y3 = 4*Ralt*(Q - 2x3) - 4*M^3*Malt (4) */
|
||||||
|
|
||||||
|
/** In case a->infinity == 1, replace r with (b->x, b->y, 1). */
|
||||||
secp256k1_fe_cmov(&r->x, &b->x, a->infinity);
|
secp256k1_fe_cmov(&r->x, &b->x, a->infinity);
|
||||||
secp256k1_fe_cmov(&r->y, &b->y, a->infinity);
|
secp256k1_fe_cmov(&r->y, &b->y, a->infinity);
|
||||||
secp256k1_fe_cmov(&r->z, &fe_1, a->infinity);
|
secp256k1_fe_cmov(&r->z, &fe_1, a->infinity);
|
||||||
r->infinity = infinity;
|
r->infinity = infinity;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_gej_rescale(secp256k1_gej_t *r, const secp256k1_fe_t *s) {
|
static void secp256k1_gej_rescale(secp256k1_gej *r, const secp256k1_fe *s) {
|
||||||
/* Operations: 4 mul, 1 sqr */
|
/* Operations: 4 mul, 1 sqr */
|
||||||
secp256k1_fe_t zz;
|
secp256k1_fe zz;
|
||||||
VERIFY_CHECK(!secp256k1_fe_is_zero(s));
|
VERIFY_CHECK(!secp256k1_fe_is_zero(s));
|
||||||
secp256k1_fe_sqr(&zz, s);
|
secp256k1_fe_sqr(&zz, s);
|
||||||
secp256k1_fe_mul(&r->x, &r->x, &zz); /* r->x *= s^2 */
|
secp256k1_fe_mul(&r->x, &r->x, &zz); /* r->x *= s^2 */
|
||||||
|
@ -407,8 +590,8 @@ static void secp256k1_gej_rescale(secp256k1_gej_t *r, const secp256k1_fe_t *s) {
|
||||||
secp256k1_fe_mul(&r->z, &r->z, s); /* r->z *= s */
|
secp256k1_fe_mul(&r->z, &r->z, s); /* r->z *= s */
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ge_to_storage(secp256k1_ge_storage_t *r, const secp256k1_ge_t *a) {
|
static void secp256k1_ge_to_storage(secp256k1_ge_storage *r, const secp256k1_ge *a) {
|
||||||
secp256k1_fe_t x, y;
|
secp256k1_fe x, y;
|
||||||
VERIFY_CHECK(!a->infinity);
|
VERIFY_CHECK(!a->infinity);
|
||||||
x = a->x;
|
x = a->x;
|
||||||
secp256k1_fe_normalize(&x);
|
secp256k1_fe_normalize(&x);
|
||||||
|
@ -418,20 +601,20 @@ static void secp256k1_ge_to_storage(secp256k1_ge_storage_t *r, const secp256k1_g
|
||||||
secp256k1_fe_to_storage(&r->y, &y);
|
secp256k1_fe_to_storage(&r->y, &y);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_ge_from_storage(secp256k1_ge_t *r, const secp256k1_ge_storage_t *a) {
|
static void secp256k1_ge_from_storage(secp256k1_ge *r, const secp256k1_ge_storage *a) {
|
||||||
secp256k1_fe_from_storage(&r->x, &a->x);
|
secp256k1_fe_from_storage(&r->x, &a->x);
|
||||||
secp256k1_fe_from_storage(&r->y, &a->y);
|
secp256k1_fe_from_storage(&r->y, &a->y);
|
||||||
r->infinity = 0;
|
r->infinity = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static SECP256K1_INLINE void secp256k1_ge_storage_cmov(secp256k1_ge_storage_t *r, const secp256k1_ge_storage_t *a, int flag) {
|
static SECP256K1_INLINE void secp256k1_ge_storage_cmov(secp256k1_ge_storage *r, const secp256k1_ge_storage *a, int flag) {
|
||||||
secp256k1_fe_storage_cmov(&r->x, &a->x, flag);
|
secp256k1_fe_storage_cmov(&r->x, &a->x, flag);
|
||||||
secp256k1_fe_storage_cmov(&r->y, &a->y, flag);
|
secp256k1_fe_storage_cmov(&r->y, &a->y, flag);
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
static void secp256k1_gej_mul_lambda(secp256k1_gej_t *r, const secp256k1_gej_t *a) {
|
static void secp256k1_ge_mul_lambda(secp256k1_ge *r, const secp256k1_ge *a) {
|
||||||
static const secp256k1_fe_t beta = SECP256K1_FE_CONST(
|
static const secp256k1_fe beta = SECP256K1_FE_CONST(
|
||||||
0x7ae96a2bul, 0x657c0710ul, 0x6e64479eul, 0xac3434e9ul,
|
0x7ae96a2bul, 0x657c0710ul, 0x6e64479eul, 0xac3434e9ul,
|
||||||
0x9cf04975ul, 0x12f58995ul, 0xc1396c28ul, 0x719501eeul
|
0x9cf04975ul, 0x12f58995ul, 0xc1396c28ul, 0x719501eeul
|
||||||
);
|
);
|
||||||
|
|
|
@ -34,7 +34,7 @@ typedef struct {
|
||||||
int retry;
|
int retry;
|
||||||
} secp256k1_rfc6979_hmac_sha256_t;
|
} secp256k1_rfc6979_hmac_sha256_t;
|
||||||
|
|
||||||
static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256_t *rng, const unsigned char *key, size_t keylen, const unsigned char *msg, size_t msglen, const unsigned char *rnd, size_t rndlen);
|
static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256_t *rng, const unsigned char *key, size_t keylen);
|
||||||
static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256_t *rng, unsigned char *out, size_t outlen);
|
static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256_t *rng, unsigned char *out, size_t outlen);
|
||||||
static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256_t *rng);
|
static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256_t *rng);
|
||||||
|
|
||||||
|
|
|
@ -202,7 +202,7 @@ static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256_t *hash, unsign
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256_t *rng, const unsigned char *key, size_t keylen, const unsigned char *msg, size_t msglen, const unsigned char *rnd, size_t rndlen) {
|
static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256_t *rng, const unsigned char *key, size_t keylen) {
|
||||||
secp256k1_hmac_sha256_t hmac;
|
secp256k1_hmac_sha256_t hmac;
|
||||||
static const unsigned char zero[1] = {0x00};
|
static const unsigned char zero[1] = {0x00};
|
||||||
static const unsigned char one[1] = {0x01};
|
static const unsigned char one[1] = {0x01};
|
||||||
|
@ -215,11 +215,6 @@ static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha2
|
||||||
secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
|
secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
|
||||||
secp256k1_hmac_sha256_write(&hmac, zero, 1);
|
secp256k1_hmac_sha256_write(&hmac, zero, 1);
|
||||||
secp256k1_hmac_sha256_write(&hmac, key, keylen);
|
secp256k1_hmac_sha256_write(&hmac, key, keylen);
|
||||||
secp256k1_hmac_sha256_write(&hmac, msg, msglen);
|
|
||||||
if (rnd && rndlen) {
|
|
||||||
/* RFC6979 3.6 "Additional data". */
|
|
||||||
secp256k1_hmac_sha256_write(&hmac, rnd, rndlen);
|
|
||||||
}
|
|
||||||
secp256k1_hmac_sha256_finalize(&hmac, rng->k);
|
secp256k1_hmac_sha256_finalize(&hmac, rng->k);
|
||||||
secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
|
secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
|
||||||
secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
|
secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
|
||||||
|
@ -230,11 +225,6 @@ static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha2
|
||||||
secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
|
secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
|
||||||
secp256k1_hmac_sha256_write(&hmac, one, 1);
|
secp256k1_hmac_sha256_write(&hmac, one, 1);
|
||||||
secp256k1_hmac_sha256_write(&hmac, key, keylen);
|
secp256k1_hmac_sha256_write(&hmac, key, keylen);
|
||||||
secp256k1_hmac_sha256_write(&hmac, msg, msglen);
|
|
||||||
if (rnd && rndlen) {
|
|
||||||
/* RFC6979 3.6 "Additional data". */
|
|
||||||
secp256k1_hmac_sha256_write(&hmac, rnd, rndlen);
|
|
||||||
}
|
|
||||||
secp256k1_hmac_sha256_finalize(&hmac, rng->k);
|
secp256k1_hmac_sha256_finalize(&hmac, rng->k);
|
||||||
secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
|
secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
|
||||||
secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
|
secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
|
||||||
|
|
|
@ -0,0 +1,8 @@
|
||||||
|
include_HEADERS += include/secp256k1_ecdh.h
|
||||||
|
noinst_HEADERS += src/modules/ecdh/main_impl.h
|
||||||
|
noinst_HEADERS += src/modules/ecdh/tests_impl.h
|
||||||
|
if USE_BENCHMARK
|
||||||
|
noinst_PROGRAMS += bench_ecdh
|
||||||
|
bench_ecdh_SOURCES = src/bench_ecdh.c
|
||||||
|
bench_ecdh_LDADD = libsecp256k1.la $(SECP_LIBS)
|
||||||
|
endif
|
|
@ -0,0 +1,54 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2015 Andrew Poelstra *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#ifndef _SECP256K1_MODULE_ECDH_MAIN_
|
||||||
|
#define _SECP256K1_MODULE_ECDH_MAIN_
|
||||||
|
|
||||||
|
#include "include/secp256k1_ecdh.h"
|
||||||
|
#include "ecmult_const_impl.h"
|
||||||
|
|
||||||
|
int secp256k1_ecdh(const secp256k1_context* ctx, unsigned char *result, const secp256k1_pubkey *point, const unsigned char *scalar) {
|
||||||
|
int ret = 0;
|
||||||
|
int overflow = 0;
|
||||||
|
secp256k1_gej res;
|
||||||
|
secp256k1_ge pt;
|
||||||
|
secp256k1_scalar s;
|
||||||
|
ARG_CHECK(result != NULL);
|
||||||
|
ARG_CHECK(point != NULL);
|
||||||
|
ARG_CHECK(scalar != NULL);
|
||||||
|
(void)ctx;
|
||||||
|
|
||||||
|
secp256k1_pubkey_load(ctx, &pt, point);
|
||||||
|
secp256k1_scalar_set_b32(&s, scalar, &overflow);
|
||||||
|
if (overflow || secp256k1_scalar_is_zero(&s)) {
|
||||||
|
ret = 0;
|
||||||
|
} else {
|
||||||
|
unsigned char x[32];
|
||||||
|
unsigned char y[1];
|
||||||
|
secp256k1_sha256_t sha;
|
||||||
|
|
||||||
|
secp256k1_ecmult_const(&res, &pt, &s);
|
||||||
|
secp256k1_ge_set_gej(&pt, &res);
|
||||||
|
/* Compute a hash of the point in compressed form
|
||||||
|
* Note we cannot use secp256k1_eckey_pubkey_serialize here since it does not
|
||||||
|
* expect its output to be secret and has a timing sidechannel. */
|
||||||
|
secp256k1_fe_normalize(&pt.x);
|
||||||
|
secp256k1_fe_normalize(&pt.y);
|
||||||
|
secp256k1_fe_get_b32(x, &pt.x);
|
||||||
|
y[0] = 0x02 | secp256k1_fe_is_odd(&pt.y);
|
||||||
|
|
||||||
|
secp256k1_sha256_initialize(&sha);
|
||||||
|
secp256k1_sha256_write(&sha, y, sizeof(y));
|
||||||
|
secp256k1_sha256_write(&sha, x, sizeof(x));
|
||||||
|
secp256k1_sha256_finalize(&sha, result);
|
||||||
|
ret = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
secp256k1_scalar_clear(&s);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,75 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2015 Andrew Poelstra *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#ifndef _SECP256K1_MODULE_ECDH_TESTS_
|
||||||
|
#define _SECP256K1_MODULE_ECDH_TESTS_
|
||||||
|
|
||||||
|
void test_ecdh_generator_basepoint(void) {
|
||||||
|
unsigned char s_one[32] = { 0 };
|
||||||
|
secp256k1_pubkey point[2];
|
||||||
|
int i;
|
||||||
|
|
||||||
|
s_one[31] = 1;
|
||||||
|
/* Check against pubkey creation when the basepoint is the generator */
|
||||||
|
for (i = 0; i < 100; ++i) {
|
||||||
|
secp256k1_sha256_t sha;
|
||||||
|
unsigned char s_b32[32];
|
||||||
|
unsigned char output_ecdh[32];
|
||||||
|
unsigned char output_ser[32];
|
||||||
|
unsigned char point_ser[33];
|
||||||
|
size_t point_ser_len = sizeof(point_ser);
|
||||||
|
secp256k1_scalar s;
|
||||||
|
|
||||||
|
random_scalar_order(&s);
|
||||||
|
secp256k1_scalar_get_b32(s_b32, &s);
|
||||||
|
|
||||||
|
/* compute using ECDH function */
|
||||||
|
CHECK(secp256k1_ec_pubkey_create(ctx, &point[0], s_one) == 1);
|
||||||
|
CHECK(secp256k1_ecdh(ctx, output_ecdh, &point[0], s_b32) == 1);
|
||||||
|
/* compute "explicitly" */
|
||||||
|
CHECK(secp256k1_ec_pubkey_create(ctx, &point[1], s_b32) == 1);
|
||||||
|
CHECK(secp256k1_ec_pubkey_serialize(ctx, point_ser, &point_ser_len, &point[1], SECP256K1_EC_COMPRESSED) == 1);
|
||||||
|
CHECK(point_ser_len == sizeof(point_ser));
|
||||||
|
secp256k1_sha256_initialize(&sha);
|
||||||
|
secp256k1_sha256_write(&sha, point_ser, point_ser_len);
|
||||||
|
secp256k1_sha256_finalize(&sha, output_ser);
|
||||||
|
/* compare */
|
||||||
|
CHECK(memcmp(output_ecdh, output_ser, sizeof(output_ser)) == 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void test_bad_scalar(void) {
|
||||||
|
unsigned char s_zero[32] = { 0 };
|
||||||
|
unsigned char s_overflow[32] = {
|
||||||
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
||||||
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
|
||||||
|
0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
|
||||||
|
0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41
|
||||||
|
};
|
||||||
|
unsigned char s_rand[32] = { 0 };
|
||||||
|
unsigned char output[32];
|
||||||
|
secp256k1_scalar rand;
|
||||||
|
secp256k1_pubkey point;
|
||||||
|
|
||||||
|
/* Create random point */
|
||||||
|
random_scalar_order(&rand);
|
||||||
|
secp256k1_scalar_get_b32(s_rand, &rand);
|
||||||
|
CHECK(secp256k1_ec_pubkey_create(ctx, &point, s_rand) == 1);
|
||||||
|
|
||||||
|
/* Try to multiply it by bad values */
|
||||||
|
CHECK(secp256k1_ecdh(ctx, output, &point, s_zero) == 0);
|
||||||
|
CHECK(secp256k1_ecdh(ctx, output, &point, s_overflow) == 0);
|
||||||
|
/* ...and a good one */
|
||||||
|
s_overflow[31] -= 1;
|
||||||
|
CHECK(secp256k1_ecdh(ctx, output, &point, s_overflow) == 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void run_ecdh_tests(void) {
|
||||||
|
test_ecdh_generator_basepoint();
|
||||||
|
test_bad_scalar();
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,8 @@
|
||||||
|
include_HEADERS += include/secp256k1_recovery.h
|
||||||
|
noinst_HEADERS += src/modules/recovery/main_impl.h
|
||||||
|
noinst_HEADERS += src/modules/recovery/tests_impl.h
|
||||||
|
if USE_BENCHMARK
|
||||||
|
noinst_PROGRAMS += bench_recover
|
||||||
|
bench_recover_SOURCES = src/bench_recover.c
|
||||||
|
bench_recover_LDADD = libsecp256k1.la $(SECP_LIBS)
|
||||||
|
endif
|
|
@ -0,0 +1,193 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2013-2015 Pieter Wuille *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#ifndef _SECP256K1_MODULE_RECOVERY_MAIN_
|
||||||
|
#define _SECP256K1_MODULE_RECOVERY_MAIN_
|
||||||
|
|
||||||
|
#include "include/secp256k1_recovery.h"
|
||||||
|
|
||||||
|
static void secp256k1_ecdsa_recoverable_signature_load(const secp256k1_context* ctx, secp256k1_scalar* r, secp256k1_scalar* s, int* recid, const secp256k1_ecdsa_recoverable_signature* sig) {
|
||||||
|
(void)ctx;
|
||||||
|
if (sizeof(secp256k1_scalar) == 32) {
|
||||||
|
/* When the secp256k1_scalar type is exactly 32 byte, use its
|
||||||
|
* representation inside secp256k1_ecdsa_signature, as conversion is very fast.
|
||||||
|
* Note that secp256k1_ecdsa_signature_save must use the same representation. */
|
||||||
|
memcpy(r, &sig->data[0], 32);
|
||||||
|
memcpy(s, &sig->data[32], 32);
|
||||||
|
} else {
|
||||||
|
secp256k1_scalar_set_b32(r, &sig->data[0], NULL);
|
||||||
|
secp256k1_scalar_set_b32(s, &sig->data[32], NULL);
|
||||||
|
}
|
||||||
|
*recid = sig->data[64];
|
||||||
|
}
|
||||||
|
|
||||||
|
static void secp256k1_ecdsa_recoverable_signature_save(secp256k1_ecdsa_recoverable_signature* sig, const secp256k1_scalar* r, const secp256k1_scalar* s, int recid) {
|
||||||
|
if (sizeof(secp256k1_scalar) == 32) {
|
||||||
|
memcpy(&sig->data[0], r, 32);
|
||||||
|
memcpy(&sig->data[32], s, 32);
|
||||||
|
} else {
|
||||||
|
secp256k1_scalar_get_b32(&sig->data[0], r);
|
||||||
|
secp256k1_scalar_get_b32(&sig->data[32], s);
|
||||||
|
}
|
||||||
|
sig->data[64] = recid;
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_ecdsa_recoverable_signature_parse_compact(const secp256k1_context* ctx, secp256k1_ecdsa_recoverable_signature* sig, const unsigned char *input64, int recid) {
|
||||||
|
secp256k1_scalar r, s;
|
||||||
|
int ret = 1;
|
||||||
|
int overflow = 0;
|
||||||
|
|
||||||
|
(void)ctx;
|
||||||
|
ARG_CHECK(sig != NULL);
|
||||||
|
ARG_CHECK(input64 != NULL);
|
||||||
|
ARG_CHECK(recid >= 0 && recid <= 3);
|
||||||
|
|
||||||
|
secp256k1_scalar_set_b32(&r, &input64[0], &overflow);
|
||||||
|
ret &= !overflow;
|
||||||
|
secp256k1_scalar_set_b32(&s, &input64[32], &overflow);
|
||||||
|
ret &= !overflow;
|
||||||
|
if (ret) {
|
||||||
|
secp256k1_ecdsa_recoverable_signature_save(sig, &r, &s, recid);
|
||||||
|
} else {
|
||||||
|
memset(sig, 0, sizeof(*sig));
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_ecdsa_recoverable_signature_serialize_compact(const secp256k1_context* ctx, unsigned char *output64, int *recid, const secp256k1_ecdsa_recoverable_signature* sig) {
|
||||||
|
secp256k1_scalar r, s;
|
||||||
|
|
||||||
|
(void)ctx;
|
||||||
|
ARG_CHECK(output64 != NULL);
|
||||||
|
ARG_CHECK(sig != NULL);
|
||||||
|
ARG_CHECK(recid != NULL);
|
||||||
|
|
||||||
|
secp256k1_ecdsa_recoverable_signature_load(ctx, &r, &s, recid, sig);
|
||||||
|
secp256k1_scalar_get_b32(&output64[0], &r);
|
||||||
|
secp256k1_scalar_get_b32(&output64[32], &s);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_ecdsa_recoverable_signature_convert(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const secp256k1_ecdsa_recoverable_signature* sigin) {
|
||||||
|
secp256k1_scalar r, s;
|
||||||
|
int recid;
|
||||||
|
|
||||||
|
(void)ctx;
|
||||||
|
ARG_CHECK(sig != NULL);
|
||||||
|
ARG_CHECK(sigin != NULL);
|
||||||
|
|
||||||
|
secp256k1_ecdsa_recoverable_signature_load(ctx, &r, &s, &recid, sigin);
|
||||||
|
secp256k1_ecdsa_signature_save(sig, &r, &s);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int secp256k1_ecdsa_sig_recover(const secp256k1_ecmult_context *ctx, const secp256k1_scalar *sigr, const secp256k1_scalar* sigs, secp256k1_ge *pubkey, const secp256k1_scalar *message, int recid) {
|
||||||
|
unsigned char brx[32];
|
||||||
|
secp256k1_fe fx;
|
||||||
|
secp256k1_ge x;
|
||||||
|
secp256k1_gej xj;
|
||||||
|
secp256k1_scalar rn, u1, u2;
|
||||||
|
secp256k1_gej qj;
|
||||||
|
int r;
|
||||||
|
|
||||||
|
if (secp256k1_scalar_is_zero(sigr) || secp256k1_scalar_is_zero(sigs)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
secp256k1_scalar_get_b32(brx, sigr);
|
||||||
|
r = secp256k1_fe_set_b32(&fx, brx);
|
||||||
|
(void)r;
|
||||||
|
VERIFY_CHECK(r); /* brx comes from a scalar, so is less than the order; certainly less than p */
|
||||||
|
if (recid & 2) {
|
||||||
|
if (secp256k1_fe_cmp_var(&fx, &secp256k1_ecdsa_const_p_minus_order) >= 0) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
secp256k1_fe_add(&fx, &secp256k1_ecdsa_const_order_as_fe);
|
||||||
|
}
|
||||||
|
if (!secp256k1_ge_set_xo_var(&x, &fx, recid & 1)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
secp256k1_gej_set_ge(&xj, &x);
|
||||||
|
secp256k1_scalar_inverse_var(&rn, sigr);
|
||||||
|
secp256k1_scalar_mul(&u1, &rn, message);
|
||||||
|
secp256k1_scalar_negate(&u1, &u1);
|
||||||
|
secp256k1_scalar_mul(&u2, &rn, sigs);
|
||||||
|
secp256k1_ecmult(ctx, &qj, &xj, &u2, &u1);
|
||||||
|
secp256k1_ge_set_gej_var(pubkey, &qj);
|
||||||
|
return !secp256k1_gej_is_infinity(&qj);
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_ecdsa_sign_recoverable(const secp256k1_context* ctx, secp256k1_ecdsa_recoverable_signature *signature, const unsigned char *msg32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void* noncedata) {
|
||||||
|
secp256k1_scalar r, s;
|
||||||
|
secp256k1_scalar sec, non, msg;
|
||||||
|
int recid;
|
||||||
|
int ret = 0;
|
||||||
|
int overflow = 0;
|
||||||
|
VERIFY_CHECK(ctx != NULL);
|
||||||
|
ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
|
||||||
|
ARG_CHECK(msg32 != NULL);
|
||||||
|
ARG_CHECK(signature != NULL);
|
||||||
|
ARG_CHECK(seckey != NULL);
|
||||||
|
if (noncefp == NULL) {
|
||||||
|
noncefp = secp256k1_nonce_function_default;
|
||||||
|
}
|
||||||
|
|
||||||
|
secp256k1_scalar_set_b32(&sec, seckey, &overflow);
|
||||||
|
/* Fail if the secret key is invalid. */
|
||||||
|
if (!overflow && !secp256k1_scalar_is_zero(&sec)) {
|
||||||
|
unsigned int count = 0;
|
||||||
|
secp256k1_scalar_set_b32(&msg, msg32, NULL);
|
||||||
|
while (1) {
|
||||||
|
unsigned char nonce32[32];
|
||||||
|
ret = noncefp(nonce32, msg32, seckey, NULL, (void*)noncedata, count);
|
||||||
|
if (!ret) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
secp256k1_scalar_set_b32(&non, nonce32, &overflow);
|
||||||
|
memset(nonce32, 0, 32);
|
||||||
|
if (!secp256k1_scalar_is_zero(&non) && !overflow) {
|
||||||
|
if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &r, &s, &sec, &msg, &non, &recid)) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
secp256k1_scalar_clear(&msg);
|
||||||
|
secp256k1_scalar_clear(&non);
|
||||||
|
secp256k1_scalar_clear(&sec);
|
||||||
|
}
|
||||||
|
if (ret) {
|
||||||
|
secp256k1_ecdsa_recoverable_signature_save(signature, &r, &s, recid);
|
||||||
|
} else {
|
||||||
|
memset(signature, 0, sizeof(*signature));
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_ecdsa_recover(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const secp256k1_ecdsa_recoverable_signature *signature, const unsigned char *msg32) {
|
||||||
|
secp256k1_ge q;
|
||||||
|
secp256k1_scalar r, s;
|
||||||
|
secp256k1_scalar m;
|
||||||
|
int recid;
|
||||||
|
VERIFY_CHECK(ctx != NULL);
|
||||||
|
ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
|
||||||
|
ARG_CHECK(msg32 != NULL);
|
||||||
|
ARG_CHECK(signature != NULL);
|
||||||
|
ARG_CHECK(pubkey != NULL);
|
||||||
|
|
||||||
|
secp256k1_ecdsa_recoverable_signature_load(ctx, &r, &s, &recid, signature);
|
||||||
|
ARG_CHECK(recid >= 0 && recid < 4);
|
||||||
|
secp256k1_scalar_set_b32(&m, msg32, NULL);
|
||||||
|
if (secp256k1_ecdsa_sig_recover(&ctx->ecmult_ctx, &r, &s, &q, &m, recid)) {
|
||||||
|
secp256k1_pubkey_save(pubkey, &q);
|
||||||
|
return 1;
|
||||||
|
} else {
|
||||||
|
memset(pubkey, 0, sizeof(*pubkey));
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,250 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2013-2015 Pieter Wuille *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#ifndef _SECP256K1_MODULE_RECOVERY_TESTS_
|
||||||
|
#define _SECP256K1_MODULE_RECOVERY_TESTS_
|
||||||
|
|
||||||
|
void test_ecdsa_recovery_end_to_end(void) {
|
||||||
|
unsigned char extra[32] = {0x00};
|
||||||
|
unsigned char privkey[32];
|
||||||
|
unsigned char message[32];
|
||||||
|
secp256k1_ecdsa_signature signature[5];
|
||||||
|
secp256k1_ecdsa_recoverable_signature rsignature[5];
|
||||||
|
unsigned char sig[74];
|
||||||
|
secp256k1_pubkey pubkey;
|
||||||
|
secp256k1_pubkey recpubkey;
|
||||||
|
int recid = 0;
|
||||||
|
|
||||||
|
/* Generate a random key and message. */
|
||||||
|
{
|
||||||
|
secp256k1_scalar msg, key;
|
||||||
|
random_scalar_order_test(&msg);
|
||||||
|
random_scalar_order_test(&key);
|
||||||
|
secp256k1_scalar_get_b32(privkey, &key);
|
||||||
|
secp256k1_scalar_get_b32(message, &msg);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Construct and verify corresponding public key. */
|
||||||
|
CHECK(secp256k1_ec_seckey_verify(ctx, privkey) == 1);
|
||||||
|
CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, privkey) == 1);
|
||||||
|
|
||||||
|
/* Serialize/parse compact and verify/recover. */
|
||||||
|
extra[0] = 0;
|
||||||
|
CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[0], message, privkey, NULL, NULL) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_sign(ctx, &signature[0], message, privkey, NULL, NULL) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[4], message, privkey, NULL, NULL) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[1], message, privkey, NULL, extra) == 1);
|
||||||
|
extra[31] = 1;
|
||||||
|
CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[2], message, privkey, NULL, extra) == 1);
|
||||||
|
extra[31] = 0;
|
||||||
|
extra[0] = 1;
|
||||||
|
CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[3], message, privkey, NULL, extra) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(ctx, sig, &recid, &rsignature[4]) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_convert(ctx, &signature[4], &rsignature[4]) == 1);
|
||||||
|
CHECK(memcmp(&signature[4], &signature[0], 64) == 0);
|
||||||
|
CHECK(secp256k1_ecdsa_verify(ctx, &signature[4], message, &pubkey) == 1);
|
||||||
|
memset(&rsignature[4], 0, sizeof(rsignature[4]));
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsignature[4], sig, recid) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_convert(ctx, &signature[4], &rsignature[4]) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_verify(ctx, &signature[4], message, &pubkey) == 1);
|
||||||
|
/* Parse compact (with recovery id) and recover. */
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsignature[4], sig, recid) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_recover(ctx, &recpubkey, &rsignature[4], message) == 1);
|
||||||
|
CHECK(memcmp(&pubkey, &recpubkey, sizeof(pubkey)) == 0);
|
||||||
|
/* Serialize/destroy/parse signature and verify again. */
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(ctx, sig, &recid, &rsignature[4]) == 1);
|
||||||
|
sig[secp256k1_rand_bits(6)] += 1 + secp256k1_rand_int(255);
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsignature[4], sig, recid) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_convert(ctx, &signature[4], &rsignature[4]) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_verify(ctx, &signature[4], message, &pubkey) == 0);
|
||||||
|
/* Recover again */
|
||||||
|
CHECK(secp256k1_ecdsa_recover(ctx, &recpubkey, &rsignature[4], message) == 0 ||
|
||||||
|
memcmp(&pubkey, &recpubkey, sizeof(pubkey)) != 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Tests several edge cases. */
|
||||||
|
void test_ecdsa_recovery_edge_cases(void) {
|
||||||
|
const unsigned char msg32[32] = {
|
||||||
|
'T', 'h', 'i', 's', ' ', 'i', 's', ' ',
|
||||||
|
'a', ' ', 'v', 'e', 'r', 'y', ' ', 's',
|
||||||
|
'e', 'c', 'r', 'e', 't', ' ', 'm', 'e',
|
||||||
|
's', 's', 'a', 'g', 'e', '.', '.', '.'
|
||||||
|
};
|
||||||
|
const unsigned char sig64[64] = {
|
||||||
|
/* Generated by signing the above message with nonce 'This is the nonce we will use...'
|
||||||
|
* and secret key 0 (which is not valid), resulting in recid 0. */
|
||||||
|
0x67, 0xCB, 0x28, 0x5F, 0x9C, 0xD1, 0x94, 0xE8,
|
||||||
|
0x40, 0xD6, 0x29, 0x39, 0x7A, 0xF5, 0x56, 0x96,
|
||||||
|
0x62, 0xFD, 0xE4, 0x46, 0x49, 0x99, 0x59, 0x63,
|
||||||
|
0x17, 0x9A, 0x7D, 0xD1, 0x7B, 0xD2, 0x35, 0x32,
|
||||||
|
0x4B, 0x1B, 0x7D, 0xF3, 0x4C, 0xE1, 0xF6, 0x8E,
|
||||||
|
0x69, 0x4F, 0xF6, 0xF1, 0x1A, 0xC7, 0x51, 0xDD,
|
||||||
|
0x7D, 0xD7, 0x3E, 0x38, 0x7E, 0xE4, 0xFC, 0x86,
|
||||||
|
0x6E, 0x1B, 0xE8, 0xEC, 0xC7, 0xDD, 0x95, 0x57
|
||||||
|
};
|
||||||
|
secp256k1_pubkey pubkey;
|
||||||
|
/* signature (r,s) = (4,4), which can be recovered with all 4 recids. */
|
||||||
|
const unsigned char sigb64[64] = {
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
|
||||||
|
};
|
||||||
|
secp256k1_pubkey pubkeyb;
|
||||||
|
secp256k1_ecdsa_recoverable_signature rsig;
|
||||||
|
secp256k1_ecdsa_signature sig;
|
||||||
|
int recid;
|
||||||
|
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sig64, 0));
|
||||||
|
CHECK(!secp256k1_ecdsa_recover(ctx, &pubkey, &rsig, msg32));
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sig64, 1));
|
||||||
|
CHECK(secp256k1_ecdsa_recover(ctx, &pubkey, &rsig, msg32));
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sig64, 2));
|
||||||
|
CHECK(!secp256k1_ecdsa_recover(ctx, &pubkey, &rsig, msg32));
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sig64, 3));
|
||||||
|
CHECK(!secp256k1_ecdsa_recover(ctx, &pubkey, &rsig, msg32));
|
||||||
|
|
||||||
|
for (recid = 0; recid < 4; recid++) {
|
||||||
|
int i;
|
||||||
|
int recid2;
|
||||||
|
/* (4,4) encoded in DER. */
|
||||||
|
unsigned char sigbder[8] = {0x30, 0x06, 0x02, 0x01, 0x04, 0x02, 0x01, 0x04};
|
||||||
|
unsigned char sigcder_zr[7] = {0x30, 0x05, 0x02, 0x00, 0x02, 0x01, 0x01};
|
||||||
|
unsigned char sigcder_zs[7] = {0x30, 0x05, 0x02, 0x01, 0x01, 0x02, 0x00};
|
||||||
|
unsigned char sigbderalt1[39] = {
|
||||||
|
0x30, 0x25, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x04, 0x02, 0x01, 0x04,
|
||||||
|
};
|
||||||
|
unsigned char sigbderalt2[39] = {
|
||||||
|
0x30, 0x25, 0x02, 0x01, 0x04, 0x02, 0x20, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
|
||||||
|
};
|
||||||
|
unsigned char sigbderalt3[40] = {
|
||||||
|
0x30, 0x26, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x01, 0x04,
|
||||||
|
};
|
||||||
|
unsigned char sigbderalt4[40] = {
|
||||||
|
0x30, 0x26, 0x02, 0x01, 0x04, 0x02, 0x21, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
|
||||||
|
};
|
||||||
|
/* (order + r,4) encoded in DER. */
|
||||||
|
unsigned char sigbderlong[40] = {
|
||||||
|
0x30, 0x26, 0x02, 0x21, 0x00, 0xFF, 0xFF, 0xFF,
|
||||||
|
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
|
||||||
|
0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xBA, 0xAE, 0xDC,
|
||||||
|
0xE6, 0xAF, 0x48, 0xA0, 0x3B, 0xBF, 0xD2, 0x5E,
|
||||||
|
0x8C, 0xD0, 0x36, 0x41, 0x45, 0x02, 0x01, 0x04
|
||||||
|
};
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigb64, recid) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_recover(ctx, &pubkeyb, &rsig, msg32) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, sizeof(sigbder)) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 1);
|
||||||
|
for (recid2 = 0; recid2 < 4; recid2++) {
|
||||||
|
secp256k1_pubkey pubkey2b;
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigb64, recid2) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_recover(ctx, &pubkey2b, &rsig, msg32) == 1);
|
||||||
|
/* Verifying with (order + r,4) should always fail. */
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderlong, sizeof(sigbderlong)) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
|
||||||
|
}
|
||||||
|
/* DER parsing tests. */
|
||||||
|
/* Zero length r/s. */
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder_zr, sizeof(sigcder_zr)) == 0);
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder_zs, sizeof(sigcder_zs)) == 0);
|
||||||
|
/* Leading zeros. */
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt1, sizeof(sigbderalt1)) == 0);
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt2, sizeof(sigbderalt2)) == 0);
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt3, sizeof(sigbderalt3)) == 0);
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt4, sizeof(sigbderalt4)) == 0);
|
||||||
|
sigbderalt3[4] = 1;
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt3, sizeof(sigbderalt3)) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
|
||||||
|
sigbderalt4[7] = 1;
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt4, sizeof(sigbderalt4)) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
|
||||||
|
/* Damage signature. */
|
||||||
|
sigbder[7]++;
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, sizeof(sigbder)) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
|
||||||
|
sigbder[7]--;
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, 6) == 0);
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, sizeof(sigbder) - 1) == 0);
|
||||||
|
for(i = 0; i < 8; i++) {
|
||||||
|
int c;
|
||||||
|
unsigned char orig = sigbder[i];
|
||||||
|
/*Try every single-byte change.*/
|
||||||
|
for (c = 0; c < 256; c++) {
|
||||||
|
if (c == orig ) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
sigbder[i] = c;
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, sizeof(sigbder)) == 0 || secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
|
||||||
|
}
|
||||||
|
sigbder[i] = orig;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Test r/s equal to zero */
|
||||||
|
{
|
||||||
|
/* (1,1) encoded in DER. */
|
||||||
|
unsigned char sigcder[8] = {0x30, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01};
|
||||||
|
unsigned char sigc64[64] = {
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
|
||||||
|
};
|
||||||
|
secp256k1_pubkey pubkeyc;
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigc64, 0) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_recover(ctx, &pubkeyc, &rsig, msg32) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder, sizeof(sigcder)) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyc) == 1);
|
||||||
|
sigcder[4] = 0;
|
||||||
|
sigc64[31] = 0;
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigc64, 0) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_recover(ctx, &pubkeyb, &rsig, msg32) == 0);
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder, sizeof(sigcder)) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyc) == 0);
|
||||||
|
sigcder[4] = 1;
|
||||||
|
sigcder[7] = 0;
|
||||||
|
sigc64[31] = 1;
|
||||||
|
sigc64[63] = 0;
|
||||||
|
CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigc64, 0) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_recover(ctx, &pubkeyb, &rsig, msg32) == 0);
|
||||||
|
CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder, sizeof(sigcder)) == 1);
|
||||||
|
CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyc) == 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void run_recovery_tests(void) {
|
||||||
|
int i;
|
||||||
|
for (i = 0; i < 64*count; i++) {
|
||||||
|
test_ecdsa_recovery_end_to_end();
|
||||||
|
}
|
||||||
|
test_ecdsa_recovery_edge_cases();
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,10 @@
|
||||||
|
include_HEADERS += include/secp256k1_schnorr.h
|
||||||
|
noinst_HEADERS += src/modules/schnorr/main_impl.h
|
||||||
|
noinst_HEADERS += src/modules/schnorr/schnorr.h
|
||||||
|
noinst_HEADERS += src/modules/schnorr/schnorr_impl.h
|
||||||
|
noinst_HEADERS += src/modules/schnorr/tests_impl.h
|
||||||
|
if USE_BENCHMARK
|
||||||
|
noinst_PROGRAMS += bench_schnorr_verify
|
||||||
|
bench_schnorr_verify_SOURCES = src/bench_schnorr_verify.c
|
||||||
|
bench_schnorr_verify_LDADD = libsecp256k1.la $(SECP_LIBS)
|
||||||
|
endif
|
|
@ -0,0 +1,164 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2014-2015 Pieter Wuille *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#ifndef SECP256K1_MODULE_SCHNORR_MAIN
|
||||||
|
#define SECP256K1_MODULE_SCHNORR_MAIN
|
||||||
|
|
||||||
|
#include "include/secp256k1_schnorr.h"
|
||||||
|
#include "modules/schnorr/schnorr_impl.h"
|
||||||
|
|
||||||
|
static void secp256k1_schnorr_msghash_sha256(unsigned char *h32, const unsigned char *r32, const unsigned char *msg32) {
|
||||||
|
secp256k1_sha256_t sha;
|
||||||
|
secp256k1_sha256_initialize(&sha);
|
||||||
|
secp256k1_sha256_write(&sha, r32, 32);
|
||||||
|
secp256k1_sha256_write(&sha, msg32, 32);
|
||||||
|
secp256k1_sha256_finalize(&sha, h32);
|
||||||
|
}
|
||||||
|
|
||||||
|
static const unsigned char secp256k1_schnorr_algo16[17] = "Schnorr+SHA256 ";
|
||||||
|
|
||||||
|
int secp256k1_schnorr_sign(const secp256k1_context* ctx, unsigned char *sig64, const unsigned char *msg32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void* noncedata) {
|
||||||
|
secp256k1_scalar sec, non;
|
||||||
|
int ret = 0;
|
||||||
|
int overflow = 0;
|
||||||
|
unsigned int count = 0;
|
||||||
|
VERIFY_CHECK(ctx != NULL);
|
||||||
|
ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
|
||||||
|
ARG_CHECK(msg32 != NULL);
|
||||||
|
ARG_CHECK(sig64 != NULL);
|
||||||
|
ARG_CHECK(seckey != NULL);
|
||||||
|
if (noncefp == NULL) {
|
||||||
|
noncefp = secp256k1_nonce_function_default;
|
||||||
|
}
|
||||||
|
|
||||||
|
secp256k1_scalar_set_b32(&sec, seckey, NULL);
|
||||||
|
while (1) {
|
||||||
|
unsigned char nonce32[32];
|
||||||
|
ret = noncefp(nonce32, msg32, seckey, secp256k1_schnorr_algo16, (void*)noncedata, count);
|
||||||
|
if (!ret) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
secp256k1_scalar_set_b32(&non, nonce32, &overflow);
|
||||||
|
memset(nonce32, 0, 32);
|
||||||
|
if (!secp256k1_scalar_is_zero(&non) && !overflow) {
|
||||||
|
if (secp256k1_schnorr_sig_sign(&ctx->ecmult_gen_ctx, sig64, &sec, &non, NULL, secp256k1_schnorr_msghash_sha256, msg32)) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
if (!ret) {
|
||||||
|
memset(sig64, 0, 64);
|
||||||
|
}
|
||||||
|
secp256k1_scalar_clear(&non);
|
||||||
|
secp256k1_scalar_clear(&sec);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_schnorr_verify(const secp256k1_context* ctx, const unsigned char *sig64, const unsigned char *msg32, const secp256k1_pubkey *pubkey) {
|
||||||
|
secp256k1_ge q;
|
||||||
|
VERIFY_CHECK(ctx != NULL);
|
||||||
|
ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
|
||||||
|
ARG_CHECK(msg32 != NULL);
|
||||||
|
ARG_CHECK(sig64 != NULL);
|
||||||
|
ARG_CHECK(pubkey != NULL);
|
||||||
|
|
||||||
|
secp256k1_pubkey_load(ctx, &q, pubkey);
|
||||||
|
return secp256k1_schnorr_sig_verify(&ctx->ecmult_ctx, sig64, &q, secp256k1_schnorr_msghash_sha256, msg32);
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_schnorr_recover(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *sig64, const unsigned char *msg32) {
|
||||||
|
secp256k1_ge q;
|
||||||
|
|
||||||
|
VERIFY_CHECK(ctx != NULL);
|
||||||
|
ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
|
||||||
|
ARG_CHECK(msg32 != NULL);
|
||||||
|
ARG_CHECK(sig64 != NULL);
|
||||||
|
ARG_CHECK(pubkey != NULL);
|
||||||
|
|
||||||
|
if (secp256k1_schnorr_sig_recover(&ctx->ecmult_ctx, sig64, &q, secp256k1_schnorr_msghash_sha256, msg32)) {
|
||||||
|
secp256k1_pubkey_save(pubkey, &q);
|
||||||
|
return 1;
|
||||||
|
} else {
|
||||||
|
memset(pubkey, 0, sizeof(*pubkey));
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_schnorr_generate_nonce_pair(const secp256k1_context* ctx, secp256k1_pubkey *pubnonce, unsigned char *privnonce32, const unsigned char *sec32, const unsigned char *msg32, secp256k1_nonce_function noncefp, const void* noncedata) {
|
||||||
|
int count = 0;
|
||||||
|
int ret = 1;
|
||||||
|
secp256k1_gej Qj;
|
||||||
|
secp256k1_ge Q;
|
||||||
|
secp256k1_scalar sec;
|
||||||
|
|
||||||
|
VERIFY_CHECK(ctx != NULL);
|
||||||
|
ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
|
||||||
|
ARG_CHECK(msg32 != NULL);
|
||||||
|
ARG_CHECK(sec32 != NULL);
|
||||||
|
ARG_CHECK(pubnonce != NULL);
|
||||||
|
ARG_CHECK(privnonce32 != NULL);
|
||||||
|
|
||||||
|
if (noncefp == NULL) {
|
||||||
|
noncefp = secp256k1_nonce_function_default;
|
||||||
|
}
|
||||||
|
|
||||||
|
do {
|
||||||
|
int overflow;
|
||||||
|
ret = noncefp(privnonce32, sec32, msg32, secp256k1_schnorr_algo16, (void*)noncedata, count++);
|
||||||
|
if (!ret) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
secp256k1_scalar_set_b32(&sec, privnonce32, &overflow);
|
||||||
|
if (overflow || secp256k1_scalar_is_zero(&sec)) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &Qj, &sec);
|
||||||
|
secp256k1_ge_set_gej(&Q, &Qj);
|
||||||
|
|
||||||
|
secp256k1_pubkey_save(pubnonce, &Q);
|
||||||
|
break;
|
||||||
|
} while(1);
|
||||||
|
|
||||||
|
secp256k1_scalar_clear(&sec);
|
||||||
|
if (!ret) {
|
||||||
|
memset(pubnonce, 0, sizeof(*pubnonce));
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_schnorr_partial_sign(const secp256k1_context* ctx, unsigned char *sig64, const unsigned char *msg32, const unsigned char *sec32, const secp256k1_pubkey *pubnonce_others, const unsigned char *secnonce32) {
|
||||||
|
int overflow = 0;
|
||||||
|
secp256k1_scalar sec, non;
|
||||||
|
secp256k1_ge pubnon;
|
||||||
|
VERIFY_CHECK(ctx != NULL);
|
||||||
|
ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
|
||||||
|
ARG_CHECK(msg32 != NULL);
|
||||||
|
ARG_CHECK(sig64 != NULL);
|
||||||
|
ARG_CHECK(sec32 != NULL);
|
||||||
|
ARG_CHECK(secnonce32 != NULL);
|
||||||
|
ARG_CHECK(pubnonce_others != NULL);
|
||||||
|
|
||||||
|
secp256k1_scalar_set_b32(&sec, sec32, &overflow);
|
||||||
|
if (overflow || secp256k1_scalar_is_zero(&sec)) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
secp256k1_scalar_set_b32(&non, secnonce32, &overflow);
|
||||||
|
if (overflow || secp256k1_scalar_is_zero(&non)) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
secp256k1_pubkey_load(ctx, &pubnon, pubnonce_others);
|
||||||
|
return secp256k1_schnorr_sig_sign(&ctx->ecmult_gen_ctx, sig64, &sec, &non, &pubnon, secp256k1_schnorr_msghash_sha256, msg32);
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_schnorr_partial_combine(const secp256k1_context* ctx, unsigned char *sig64, const unsigned char * const *sig64sin, size_t n) {
|
||||||
|
ARG_CHECK(sig64 != NULL);
|
||||||
|
ARG_CHECK(n >= 1);
|
||||||
|
ARG_CHECK(sig64sin != NULL);
|
||||||
|
return secp256k1_schnorr_sig_combine(sig64, n, sig64sin);
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,20 @@
|
||||||
|
/***********************************************************************
|
||||||
|
* Copyright (c) 2014-2015 Pieter Wuille *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php. *
|
||||||
|
***********************************************************************/
|
||||||
|
|
||||||
|
#ifndef _SECP256K1_MODULE_SCHNORR_H_
|
||||||
|
#define _SECP256K1_MODULE_SCHNORR_H_
|
||||||
|
|
||||||
|
#include "scalar.h"
|
||||||
|
#include "group.h"
|
||||||
|
|
||||||
|
typedef void (*secp256k1_schnorr_msghash)(unsigned char *h32, const unsigned char *r32, const unsigned char *msg32);
|
||||||
|
|
||||||
|
static int secp256k1_schnorr_sig_sign(const secp256k1_ecmult_gen_context* ctx, unsigned char *sig64, const secp256k1_scalar *key, const secp256k1_scalar *nonce, const secp256k1_ge *pubnonce, secp256k1_schnorr_msghash hash, const unsigned char *msg32);
|
||||||
|
static int secp256k1_schnorr_sig_verify(const secp256k1_ecmult_context* ctx, const unsigned char *sig64, const secp256k1_ge *pubkey, secp256k1_schnorr_msghash hash, const unsigned char *msg32);
|
||||||
|
static int secp256k1_schnorr_sig_recover(const secp256k1_ecmult_context* ctx, const unsigned char *sig64, secp256k1_ge *pubkey, secp256k1_schnorr_msghash hash, const unsigned char *msg32);
|
||||||
|
static int secp256k1_schnorr_sig_combine(unsigned char *sig64, size_t n, const unsigned char * const *sig64ins);
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,207 @@
|
||||||
|
/***********************************************************************
|
||||||
|
* Copyright (c) 2014-2015 Pieter Wuille *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php. *
|
||||||
|
***********************************************************************/
|
||||||
|
|
||||||
|
#ifndef _SECP256K1_SCHNORR_IMPL_H_
|
||||||
|
#define _SECP256K1_SCHNORR_IMPL_H_
|
||||||
|
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
#include "schnorr.h"
|
||||||
|
#include "num.h"
|
||||||
|
#include "field.h"
|
||||||
|
#include "group.h"
|
||||||
|
#include "ecmult.h"
|
||||||
|
#include "ecmult_gen.h"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Custom Schnorr-based signature scheme. They support multiparty signing, public key
|
||||||
|
* recovery and batch validation.
|
||||||
|
*
|
||||||
|
* Rationale for verifying R's y coordinate:
|
||||||
|
* In order to support batch validation and public key recovery, the full R point must
|
||||||
|
* be known to verifiers, rather than just its x coordinate. In order to not risk
|
||||||
|
* being more strict in batch validation than normal validation, validators must be
|
||||||
|
* required to reject signatures with incorrect y coordinate. This is only possible
|
||||||
|
* by including a (relatively slow) field inverse, or a field square root. However,
|
||||||
|
* batch validation offers potentially much higher benefits than this cost.
|
||||||
|
*
|
||||||
|
* Rationale for having an implicit y coordinate oddness:
|
||||||
|
* If we commit to having the full R point known to verifiers, there are two mechanism.
|
||||||
|
* Either include its oddness in the signature, or give it an implicit fixed value.
|
||||||
|
* As the R y coordinate can be flipped by a simple negation of the nonce, we choose the
|
||||||
|
* latter, as it comes with nearly zero impact on signing or validation performance, and
|
||||||
|
* saves a byte in the signature.
|
||||||
|
*
|
||||||
|
* Signing:
|
||||||
|
* Inputs: 32-byte message m, 32-byte scalar key x (!=0), 32-byte scalar nonce k (!=0)
|
||||||
|
*
|
||||||
|
* Compute point R = k * G. Reject nonce if R's y coordinate is odd (or negate nonce).
|
||||||
|
* Compute 32-byte r, the serialization of R's x coordinate.
|
||||||
|
* Compute scalar h = Hash(r || m). Reject nonce if h == 0 or h >= order.
|
||||||
|
* Compute scalar s = k - h * x.
|
||||||
|
* The signature is (r, s).
|
||||||
|
*
|
||||||
|
*
|
||||||
|
* Verification:
|
||||||
|
* Inputs: 32-byte message m, public key point Q, signature: (32-byte r, scalar s)
|
||||||
|
*
|
||||||
|
* Signature is invalid if s >= order.
|
||||||
|
* Signature is invalid if r >= p.
|
||||||
|
* Compute scalar h = Hash(r || m). Signature is invalid if h == 0 or h >= order.
|
||||||
|
* Option 1 (faster for single verification):
|
||||||
|
* Compute point R = h * Q + s * G. Signature is invalid if R is infinity or R's y coordinate is odd.
|
||||||
|
* Signature is valid if the serialization of R's x coordinate equals r.
|
||||||
|
* Option 2 (allows batch validation and pubkey recovery):
|
||||||
|
* Decompress x coordinate r into point R, with odd y coordinate. Fail if R is not on the curve.
|
||||||
|
* Signature is valid if R + h * Q + s * G == 0.
|
||||||
|
*/
|
||||||
|
|
||||||
|
static int secp256k1_schnorr_sig_sign(const secp256k1_ecmult_gen_context* ctx, unsigned char *sig64, const secp256k1_scalar *key, const secp256k1_scalar *nonce, const secp256k1_ge *pubnonce, secp256k1_schnorr_msghash hash, const unsigned char *msg32) {
|
||||||
|
secp256k1_gej Rj;
|
||||||
|
secp256k1_ge Ra;
|
||||||
|
unsigned char h32[32];
|
||||||
|
secp256k1_scalar h, s;
|
||||||
|
int overflow;
|
||||||
|
secp256k1_scalar n;
|
||||||
|
|
||||||
|
if (secp256k1_scalar_is_zero(key) || secp256k1_scalar_is_zero(nonce)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
n = *nonce;
|
||||||
|
|
||||||
|
secp256k1_ecmult_gen(ctx, &Rj, &n);
|
||||||
|
if (pubnonce != NULL) {
|
||||||
|
secp256k1_gej_add_ge(&Rj, &Rj, pubnonce);
|
||||||
|
}
|
||||||
|
secp256k1_ge_set_gej(&Ra, &Rj);
|
||||||
|
secp256k1_fe_normalize(&Ra.y);
|
||||||
|
if (secp256k1_fe_is_odd(&Ra.y)) {
|
||||||
|
/* R's y coordinate is odd, which is not allowed (see rationale above).
|
||||||
|
Force it to be even by negating the nonce. Note that this even works
|
||||||
|
for multiparty signing, as the R point is known to all participants,
|
||||||
|
which can all decide to flip the sign in unison, resulting in the
|
||||||
|
overall R point to be negated too. */
|
||||||
|
secp256k1_scalar_negate(&n, &n);
|
||||||
|
}
|
||||||
|
secp256k1_fe_normalize(&Ra.x);
|
||||||
|
secp256k1_fe_get_b32(sig64, &Ra.x);
|
||||||
|
hash(h32, sig64, msg32);
|
||||||
|
overflow = 0;
|
||||||
|
secp256k1_scalar_set_b32(&h, h32, &overflow);
|
||||||
|
if (overflow || secp256k1_scalar_is_zero(&h)) {
|
||||||
|
secp256k1_scalar_clear(&n);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
secp256k1_scalar_mul(&s, &h, key);
|
||||||
|
secp256k1_scalar_negate(&s, &s);
|
||||||
|
secp256k1_scalar_add(&s, &s, &n);
|
||||||
|
secp256k1_scalar_clear(&n);
|
||||||
|
secp256k1_scalar_get_b32(sig64 + 32, &s);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int secp256k1_schnorr_sig_verify(const secp256k1_ecmult_context* ctx, const unsigned char *sig64, const secp256k1_ge *pubkey, secp256k1_schnorr_msghash hash, const unsigned char *msg32) {
|
||||||
|
secp256k1_gej Qj, Rj;
|
||||||
|
secp256k1_ge Ra;
|
||||||
|
secp256k1_fe Rx;
|
||||||
|
secp256k1_scalar h, s;
|
||||||
|
unsigned char hh[32];
|
||||||
|
int overflow;
|
||||||
|
|
||||||
|
if (secp256k1_ge_is_infinity(pubkey)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
hash(hh, sig64, msg32);
|
||||||
|
overflow = 0;
|
||||||
|
secp256k1_scalar_set_b32(&h, hh, &overflow);
|
||||||
|
if (overflow || secp256k1_scalar_is_zero(&h)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
overflow = 0;
|
||||||
|
secp256k1_scalar_set_b32(&s, sig64 + 32, &overflow);
|
||||||
|
if (overflow) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (!secp256k1_fe_set_b32(&Rx, sig64)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
secp256k1_gej_set_ge(&Qj, pubkey);
|
||||||
|
secp256k1_ecmult(ctx, &Rj, &Qj, &h, &s);
|
||||||
|
if (secp256k1_gej_is_infinity(&Rj)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
secp256k1_ge_set_gej_var(&Ra, &Rj);
|
||||||
|
secp256k1_fe_normalize_var(&Ra.y);
|
||||||
|
if (secp256k1_fe_is_odd(&Ra.y)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
return secp256k1_fe_equal_var(&Rx, &Ra.x);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int secp256k1_schnorr_sig_recover(const secp256k1_ecmult_context* ctx, const unsigned char *sig64, secp256k1_ge *pubkey, secp256k1_schnorr_msghash hash, const unsigned char *msg32) {
|
||||||
|
secp256k1_gej Qj, Rj;
|
||||||
|
secp256k1_ge Ra;
|
||||||
|
secp256k1_fe Rx;
|
||||||
|
secp256k1_scalar h, s;
|
||||||
|
unsigned char hh[32];
|
||||||
|
int overflow;
|
||||||
|
|
||||||
|
hash(hh, sig64, msg32);
|
||||||
|
overflow = 0;
|
||||||
|
secp256k1_scalar_set_b32(&h, hh, &overflow);
|
||||||
|
if (overflow || secp256k1_scalar_is_zero(&h)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
overflow = 0;
|
||||||
|
secp256k1_scalar_set_b32(&s, sig64 + 32, &overflow);
|
||||||
|
if (overflow) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (!secp256k1_fe_set_b32(&Rx, sig64)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (!secp256k1_ge_set_xo_var(&Ra, &Rx, 0)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
secp256k1_gej_set_ge(&Rj, &Ra);
|
||||||
|
secp256k1_scalar_inverse_var(&h, &h);
|
||||||
|
secp256k1_scalar_negate(&s, &s);
|
||||||
|
secp256k1_scalar_mul(&s, &s, &h);
|
||||||
|
secp256k1_ecmult(ctx, &Qj, &Rj, &h, &s);
|
||||||
|
if (secp256k1_gej_is_infinity(&Qj)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
secp256k1_ge_set_gej(pubkey, &Qj);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int secp256k1_schnorr_sig_combine(unsigned char *sig64, size_t n, const unsigned char * const *sig64ins) {
|
||||||
|
secp256k1_scalar s = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
|
||||||
|
size_t i;
|
||||||
|
for (i = 0; i < n; i++) {
|
||||||
|
secp256k1_scalar si;
|
||||||
|
int overflow;
|
||||||
|
secp256k1_scalar_set_b32(&si, sig64ins[i] + 32, &overflow);
|
||||||
|
if (overflow) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
if (i) {
|
||||||
|
if (memcmp(sig64ins[i - 1], sig64ins[i], 32) != 0) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
secp256k1_scalar_add(&s, &s, &si);
|
||||||
|
}
|
||||||
|
if (secp256k1_scalar_is_zero(&s)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
memcpy(sig64, sig64ins[0], 32);
|
||||||
|
secp256k1_scalar_get_b32(sig64 + 32, &s);
|
||||||
|
secp256k1_scalar_clear(&s);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,175 @@
|
||||||
|
/**********************************************************************
|
||||||
|
* Copyright (c) 2014-2015 Pieter Wuille *
|
||||||
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
|
**********************************************************************/
|
||||||
|
|
||||||
|
#ifndef SECP256K1_MODULE_SCHNORR_TESTS
|
||||||
|
#define SECP256K1_MODULE_SCHNORR_TESTS
|
||||||
|
|
||||||
|
#include "include/secp256k1_schnorr.h"
|
||||||
|
|
||||||
|
void test_schnorr_end_to_end(void) {
|
||||||
|
unsigned char privkey[32];
|
||||||
|
unsigned char message[32];
|
||||||
|
unsigned char schnorr_signature[64];
|
||||||
|
secp256k1_pubkey pubkey, recpubkey;
|
||||||
|
|
||||||
|
/* Generate a random key and message. */
|
||||||
|
{
|
||||||
|
secp256k1_scalar key;
|
||||||
|
random_scalar_order_test(&key);
|
||||||
|
secp256k1_scalar_get_b32(privkey, &key);
|
||||||
|
secp256k1_rand256_test(message);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Construct and verify corresponding public key. */
|
||||||
|
CHECK(secp256k1_ec_seckey_verify(ctx, privkey) == 1);
|
||||||
|
CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, privkey) == 1);
|
||||||
|
|
||||||
|
/* Schnorr sign. */
|
||||||
|
CHECK(secp256k1_schnorr_sign(ctx, schnorr_signature, message, privkey, NULL, NULL) == 1);
|
||||||
|
CHECK(secp256k1_schnorr_verify(ctx, schnorr_signature, message, &pubkey) == 1);
|
||||||
|
CHECK(secp256k1_schnorr_recover(ctx, &recpubkey, schnorr_signature, message) == 1);
|
||||||
|
CHECK(memcmp(&pubkey, &recpubkey, sizeof(pubkey)) == 0);
|
||||||
|
/* Destroy signature and verify again. */
|
||||||
|
schnorr_signature[secp256k1_rand_bits(6)] += 1 + secp256k1_rand_int(255);
|
||||||
|
CHECK(secp256k1_schnorr_verify(ctx, schnorr_signature, message, &pubkey) == 0);
|
||||||
|
CHECK(secp256k1_schnorr_recover(ctx, &recpubkey, schnorr_signature, message) != 1 ||
|
||||||
|
memcmp(&pubkey, &recpubkey, sizeof(pubkey)) != 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Horribly broken hash function. Do not use for anything but tests. */
|
||||||
|
void test_schnorr_hash(unsigned char *h32, const unsigned char *r32, const unsigned char *msg32) {
|
||||||
|
int i;
|
||||||
|
for (i = 0; i < 32; i++) {
|
||||||
|
h32[i] = r32[i] ^ msg32[i];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void test_schnorr_sign_verify(void) {
|
||||||
|
unsigned char msg32[32];
|
||||||
|
unsigned char sig64[3][64];
|
||||||
|
secp256k1_gej pubkeyj[3];
|
||||||
|
secp256k1_ge pubkey[3];
|
||||||
|
secp256k1_scalar nonce[3], key[3];
|
||||||
|
int i = 0;
|
||||||
|
int k;
|
||||||
|
|
||||||
|
secp256k1_rand256_test(msg32);
|
||||||
|
|
||||||
|
for (k = 0; k < 3; k++) {
|
||||||
|
random_scalar_order_test(&key[k]);
|
||||||
|
|
||||||
|
do {
|
||||||
|
random_scalar_order_test(&nonce[k]);
|
||||||
|
if (secp256k1_schnorr_sig_sign(&ctx->ecmult_gen_ctx, sig64[k], &key[k], &nonce[k], NULL, &test_schnorr_hash, msg32)) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
} while(1);
|
||||||
|
|
||||||
|
secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pubkeyj[k], &key[k]);
|
||||||
|
secp256k1_ge_set_gej_var(&pubkey[k], &pubkeyj[k]);
|
||||||
|
CHECK(secp256k1_schnorr_sig_verify(&ctx->ecmult_ctx, sig64[k], &pubkey[k], &test_schnorr_hash, msg32));
|
||||||
|
|
||||||
|
for (i = 0; i < 4; i++) {
|
||||||
|
int pos = secp256k1_rand_bits(6);
|
||||||
|
int mod = 1 + secp256k1_rand_int(255);
|
||||||
|
sig64[k][pos] ^= mod;
|
||||||
|
CHECK(secp256k1_schnorr_sig_verify(&ctx->ecmult_ctx, sig64[k], &pubkey[k], &test_schnorr_hash, msg32) == 0);
|
||||||
|
sig64[k][pos] ^= mod;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void test_schnorr_threshold(void) {
|
||||||
|
unsigned char msg[32];
|
||||||
|
unsigned char sec[5][32];
|
||||||
|
secp256k1_pubkey pub[5];
|
||||||
|
unsigned char nonce[5][32];
|
||||||
|
secp256k1_pubkey pubnonce[5];
|
||||||
|
unsigned char sig[5][64];
|
||||||
|
const unsigned char* sigs[5];
|
||||||
|
unsigned char allsig[64];
|
||||||
|
const secp256k1_pubkey* pubs[5];
|
||||||
|
secp256k1_pubkey allpub;
|
||||||
|
int n, i;
|
||||||
|
int damage;
|
||||||
|
int ret = 0;
|
||||||
|
|
||||||
|
damage = secp256k1_rand_bits(1) ? (1 + secp256k1_rand_int(4)) : 0;
|
||||||
|
secp256k1_rand256_test(msg);
|
||||||
|
n = 2 + secp256k1_rand_int(4);
|
||||||
|
for (i = 0; i < n; i++) {
|
||||||
|
do {
|
||||||
|
secp256k1_rand256_test(sec[i]);
|
||||||
|
} while (!secp256k1_ec_seckey_verify(ctx, sec[i]));
|
||||||
|
CHECK(secp256k1_ec_pubkey_create(ctx, &pub[i], sec[i]));
|
||||||
|
CHECK(secp256k1_schnorr_generate_nonce_pair(ctx, &pubnonce[i], nonce[i], msg, sec[i], NULL, NULL));
|
||||||
|
pubs[i] = &pub[i];
|
||||||
|
}
|
||||||
|
if (damage == 1) {
|
||||||
|
nonce[secp256k1_rand_int(n)][secp256k1_rand_int(32)] ^= 1 + secp256k1_rand_int(255);
|
||||||
|
} else if (damage == 2) {
|
||||||
|
sec[secp256k1_rand_int(n)][secp256k1_rand_int(32)] ^= 1 + secp256k1_rand_int(255);
|
||||||
|
}
|
||||||
|
for (i = 0; i < n; i++) {
|
||||||
|
secp256k1_pubkey allpubnonce;
|
||||||
|
const secp256k1_pubkey *pubnonces[4];
|
||||||
|
int j;
|
||||||
|
for (j = 0; j < i; j++) {
|
||||||
|
pubnonces[j] = &pubnonce[j];
|
||||||
|
}
|
||||||
|
for (j = i + 1; j < n; j++) {
|
||||||
|
pubnonces[j - 1] = &pubnonce[j];
|
||||||
|
}
|
||||||
|
CHECK(secp256k1_ec_pubkey_combine(ctx, &allpubnonce, pubnonces, n - 1));
|
||||||
|
ret |= (secp256k1_schnorr_partial_sign(ctx, sig[i], msg, sec[i], &allpubnonce, nonce[i]) != 1) * 1;
|
||||||
|
sigs[i] = sig[i];
|
||||||
|
}
|
||||||
|
if (damage == 3) {
|
||||||
|
sig[secp256k1_rand_int(n)][secp256k1_rand_bits(6)] ^= 1 + secp256k1_rand_int(255);
|
||||||
|
}
|
||||||
|
ret |= (secp256k1_ec_pubkey_combine(ctx, &allpub, pubs, n) != 1) * 2;
|
||||||
|
if ((ret & 1) == 0) {
|
||||||
|
ret |= (secp256k1_schnorr_partial_combine(ctx, allsig, sigs, n) != 1) * 4;
|
||||||
|
}
|
||||||
|
if (damage == 4) {
|
||||||
|
allsig[secp256k1_rand_int(32)] ^= 1 + secp256k1_rand_int(255);
|
||||||
|
}
|
||||||
|
if ((ret & 7) == 0) {
|
||||||
|
ret |= (secp256k1_schnorr_verify(ctx, allsig, msg, &allpub) != 1) * 8;
|
||||||
|
}
|
||||||
|
CHECK((ret == 0) == (damage == 0));
|
||||||
|
}
|
||||||
|
|
||||||
|
void test_schnorr_recovery(void) {
|
||||||
|
unsigned char msg32[32];
|
||||||
|
unsigned char sig64[64];
|
||||||
|
secp256k1_ge Q;
|
||||||
|
|
||||||
|
secp256k1_rand256_test(msg32);
|
||||||
|
secp256k1_rand256_test(sig64);
|
||||||
|
secp256k1_rand256_test(sig64 + 32);
|
||||||
|
if (secp256k1_schnorr_sig_recover(&ctx->ecmult_ctx, sig64, &Q, &test_schnorr_hash, msg32) == 1) {
|
||||||
|
CHECK(secp256k1_schnorr_sig_verify(&ctx->ecmult_ctx, sig64, &Q, &test_schnorr_hash, msg32) == 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void run_schnorr_tests(void) {
|
||||||
|
int i;
|
||||||
|
for (i = 0; i < 32*count; i++) {
|
||||||
|
test_schnorr_end_to_end();
|
||||||
|
}
|
||||||
|
for (i = 0; i < 32 * count; i++) {
|
||||||
|
test_schnorr_sign_verify();
|
||||||
|
}
|
||||||
|
for (i = 0; i < 16 * count; i++) {
|
||||||
|
test_schnorr_recovery();
|
||||||
|
}
|
||||||
|
for (i = 0; i < 10 * count; i++) {
|
||||||
|
test_schnorr_threshold();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
28
src/num.h
28
src/num.h
|
@ -20,48 +20,48 @@
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/** Copy a number. */
|
/** Copy a number. */
|
||||||
static void secp256k1_num_copy(secp256k1_num_t *r, const secp256k1_num_t *a);
|
static void secp256k1_num_copy(secp256k1_num *r, const secp256k1_num *a);
|
||||||
|
|
||||||
/** Convert a number's absolute value to a binary big-endian string.
|
/** Convert a number's absolute value to a binary big-endian string.
|
||||||
* There must be enough place. */
|
* There must be enough place. */
|
||||||
static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const secp256k1_num_t *a);
|
static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const secp256k1_num *a);
|
||||||
|
|
||||||
/** Set a number to the value of a binary big-endian string. */
|
/** Set a number to the value of a binary big-endian string. */
|
||||||
static void secp256k1_num_set_bin(secp256k1_num_t *r, const unsigned char *a, unsigned int alen);
|
static void secp256k1_num_set_bin(secp256k1_num *r, const unsigned char *a, unsigned int alen);
|
||||||
|
|
||||||
/** Compute a modular inverse. The input must be less than the modulus. */
|
/** Compute a modular inverse. The input must be less than the modulus. */
|
||||||
static void secp256k1_num_mod_inverse(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *m);
|
static void secp256k1_num_mod_inverse(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *m);
|
||||||
|
|
||||||
/** Compare the absolute value of two numbers. */
|
/** Compare the absolute value of two numbers. */
|
||||||
static int secp256k1_num_cmp(const secp256k1_num_t *a, const secp256k1_num_t *b);
|
static int secp256k1_num_cmp(const secp256k1_num *a, const secp256k1_num *b);
|
||||||
|
|
||||||
/** Test whether two number are equal (including sign). */
|
/** Test whether two number are equal (including sign). */
|
||||||
static int secp256k1_num_eq(const secp256k1_num_t *a, const secp256k1_num_t *b);
|
static int secp256k1_num_eq(const secp256k1_num *a, const secp256k1_num *b);
|
||||||
|
|
||||||
/** Add two (signed) numbers. */
|
/** Add two (signed) numbers. */
|
||||||
static void secp256k1_num_add(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b);
|
static void secp256k1_num_add(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b);
|
||||||
|
|
||||||
/** Subtract two (signed) numbers. */
|
/** Subtract two (signed) numbers. */
|
||||||
static void secp256k1_num_sub(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b);
|
static void secp256k1_num_sub(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b);
|
||||||
|
|
||||||
/** Multiply two (signed) numbers. */
|
/** Multiply two (signed) numbers. */
|
||||||
static void secp256k1_num_mul(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b);
|
static void secp256k1_num_mul(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b);
|
||||||
|
|
||||||
/** Replace a number by its remainder modulo m. M's sign is ignored. The result is a number between 0 and m-1,
|
/** Replace a number by its remainder modulo m. M's sign is ignored. The result is a number between 0 and m-1,
|
||||||
even if r was negative. */
|
even if r was negative. */
|
||||||
static void secp256k1_num_mod(secp256k1_num_t *r, const secp256k1_num_t *m);
|
static void secp256k1_num_mod(secp256k1_num *r, const secp256k1_num *m);
|
||||||
|
|
||||||
/** Right-shift the passed number by bits bits. */
|
/** Right-shift the passed number by bits bits. */
|
||||||
static void secp256k1_num_shift(secp256k1_num_t *r, int bits);
|
static void secp256k1_num_shift(secp256k1_num *r, int bits);
|
||||||
|
|
||||||
/** Check whether a number is zero. */
|
/** Check whether a number is zero. */
|
||||||
static int secp256k1_num_is_zero(const secp256k1_num_t *a);
|
static int secp256k1_num_is_zero(const secp256k1_num *a);
|
||||||
|
|
||||||
/** Check whether a number is strictly negative. */
|
/** Check whether a number is strictly negative. */
|
||||||
static int secp256k1_num_is_neg(const secp256k1_num_t *a);
|
static int secp256k1_num_is_neg(const secp256k1_num *a);
|
||||||
|
|
||||||
/** Change a number's sign. */
|
/** Change a number's sign. */
|
||||||
static void secp256k1_num_negate(secp256k1_num_t *r);
|
static void secp256k1_num_negate(secp256k1_num *r);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
|
|
@ -15,6 +15,6 @@ typedef struct {
|
||||||
mp_limb_t data[2*NUM_LIMBS];
|
mp_limb_t data[2*NUM_LIMBS];
|
||||||
int neg;
|
int neg;
|
||||||
int limbs;
|
int limbs;
|
||||||
} secp256k1_num_t;
|
} secp256k1_num;
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -15,18 +15,18 @@
|
||||||
#include "num.h"
|
#include "num.h"
|
||||||
|
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
static void secp256k1_num_sanity(const secp256k1_num_t *a) {
|
static void secp256k1_num_sanity(const secp256k1_num *a) {
|
||||||
VERIFY_CHECK(a->limbs == 1 || (a->limbs > 1 && a->data[a->limbs-1] != 0));
|
VERIFY_CHECK(a->limbs == 1 || (a->limbs > 1 && a->data[a->limbs-1] != 0));
|
||||||
}
|
}
|
||||||
#else
|
#else
|
||||||
#define secp256k1_num_sanity(a) do { } while(0)
|
#define secp256k1_num_sanity(a) do { } while(0)
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
static void secp256k1_num_copy(secp256k1_num_t *r, const secp256k1_num_t *a) {
|
static void secp256k1_num_copy(secp256k1_num *r, const secp256k1_num *a) {
|
||||||
*r = *a;
|
*r = *a;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const secp256k1_num_t *a) {
|
static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const secp256k1_num *a) {
|
||||||
unsigned char tmp[65];
|
unsigned char tmp[65];
|
||||||
int len = 0;
|
int len = 0;
|
||||||
int shift = 0;
|
int shift = 0;
|
||||||
|
@ -42,7 +42,7 @@ static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const sec
|
||||||
memset(tmp, 0, sizeof(tmp));
|
memset(tmp, 0, sizeof(tmp));
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_num_set_bin(secp256k1_num_t *r, const unsigned char *a, unsigned int alen) {
|
static void secp256k1_num_set_bin(secp256k1_num *r, const unsigned char *a, unsigned int alen) {
|
||||||
int len;
|
int len;
|
||||||
VERIFY_CHECK(alen > 0);
|
VERIFY_CHECK(alen > 0);
|
||||||
VERIFY_CHECK(alen <= 64);
|
VERIFY_CHECK(alen <= 64);
|
||||||
|
@ -59,7 +59,7 @@ static void secp256k1_num_set_bin(secp256k1_num_t *r, const unsigned char *a, un
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_num_add_abs(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b) {
|
static void secp256k1_num_add_abs(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
|
||||||
mp_limb_t c = mpn_add(r->data, a->data, a->limbs, b->data, b->limbs);
|
mp_limb_t c = mpn_add(r->data, a->data, a->limbs, b->data, b->limbs);
|
||||||
r->limbs = a->limbs;
|
r->limbs = a->limbs;
|
||||||
if (c != 0) {
|
if (c != 0) {
|
||||||
|
@ -68,8 +68,9 @@ static void secp256k1_num_add_abs(secp256k1_num_t *r, const secp256k1_num_t *a,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_num_sub_abs(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b) {
|
static void secp256k1_num_sub_abs(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
|
||||||
mp_limb_t c = mpn_sub(r->data, a->data, a->limbs, b->data, b->limbs);
|
mp_limb_t c = mpn_sub(r->data, a->data, a->limbs, b->data, b->limbs);
|
||||||
|
(void)c;
|
||||||
VERIFY_CHECK(c == 0);
|
VERIFY_CHECK(c == 0);
|
||||||
r->limbs = a->limbs;
|
r->limbs = a->limbs;
|
||||||
while (r->limbs > 1 && r->data[r->limbs-1]==0) {
|
while (r->limbs > 1 && r->data[r->limbs-1]==0) {
|
||||||
|
@ -77,7 +78,7 @@ static void secp256k1_num_sub_abs(secp256k1_num_t *r, const secp256k1_num_t *a,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_num_mod(secp256k1_num_t *r, const secp256k1_num_t *m) {
|
static void secp256k1_num_mod(secp256k1_num *r, const secp256k1_num *m) {
|
||||||
secp256k1_num_sanity(r);
|
secp256k1_num_sanity(r);
|
||||||
secp256k1_num_sanity(m);
|
secp256k1_num_sanity(m);
|
||||||
|
|
||||||
|
@ -97,7 +98,7 @@ static void secp256k1_num_mod(secp256k1_num_t *r, const secp256k1_num_t *m) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_num_mod_inverse(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *m) {
|
static void secp256k1_num_mod_inverse(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *m) {
|
||||||
int i;
|
int i;
|
||||||
mp_limb_t g[NUM_LIMBS+1];
|
mp_limb_t g[NUM_LIMBS+1];
|
||||||
mp_limb_t u[NUM_LIMBS+1];
|
mp_limb_t u[NUM_LIMBS+1];
|
||||||
|
@ -125,6 +126,7 @@ static void secp256k1_num_mod_inverse(secp256k1_num_t *r, const secp256k1_num_t
|
||||||
}
|
}
|
||||||
sn = NUM_LIMBS+1;
|
sn = NUM_LIMBS+1;
|
||||||
gn = mpn_gcdext(g, r->data, &sn, u, m->limbs, v, m->limbs);
|
gn = mpn_gcdext(g, r->data, &sn, u, m->limbs, v, m->limbs);
|
||||||
|
(void)gn;
|
||||||
VERIFY_CHECK(gn == 1);
|
VERIFY_CHECK(gn == 1);
|
||||||
VERIFY_CHECK(g[0] == 1);
|
VERIFY_CHECK(g[0] == 1);
|
||||||
r->neg = a->neg ^ m->neg;
|
r->neg = a->neg ^ m->neg;
|
||||||
|
@ -142,15 +144,15 @@ static void secp256k1_num_mod_inverse(secp256k1_num_t *r, const secp256k1_num_t
|
||||||
memset(v, 0, sizeof(v));
|
memset(v, 0, sizeof(v));
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_num_is_zero(const secp256k1_num_t *a) {
|
static int secp256k1_num_is_zero(const secp256k1_num *a) {
|
||||||
return (a->limbs == 1 && a->data[0] == 0);
|
return (a->limbs == 1 && a->data[0] == 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_num_is_neg(const secp256k1_num_t *a) {
|
static int secp256k1_num_is_neg(const secp256k1_num *a) {
|
||||||
return (a->limbs > 1 || a->data[0] != 0) && a->neg;
|
return (a->limbs > 1 || a->data[0] != 0) && a->neg;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_num_cmp(const secp256k1_num_t *a, const secp256k1_num_t *b) {
|
static int secp256k1_num_cmp(const secp256k1_num *a, const secp256k1_num *b) {
|
||||||
if (a->limbs > b->limbs) {
|
if (a->limbs > b->limbs) {
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
@ -160,7 +162,7 @@ static int secp256k1_num_cmp(const secp256k1_num_t *a, const secp256k1_num_t *b)
|
||||||
return mpn_cmp(a->data, b->data, a->limbs);
|
return mpn_cmp(a->data, b->data, a->limbs);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_num_eq(const secp256k1_num_t *a, const secp256k1_num_t *b) {
|
static int secp256k1_num_eq(const secp256k1_num *a, const secp256k1_num *b) {
|
||||||
if (a->limbs > b->limbs) {
|
if (a->limbs > b->limbs) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
@ -173,7 +175,7 @@ static int secp256k1_num_eq(const secp256k1_num_t *a, const secp256k1_num_t *b)
|
||||||
return mpn_cmp(a->data, b->data, a->limbs) == 0;
|
return mpn_cmp(a->data, b->data, a->limbs) == 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_num_subadd(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b, int bneg) {
|
static void secp256k1_num_subadd(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b, int bneg) {
|
||||||
if (!(b->neg ^ bneg ^ a->neg)) { /* a and b have the same sign */
|
if (!(b->neg ^ bneg ^ a->neg)) { /* a and b have the same sign */
|
||||||
r->neg = a->neg;
|
r->neg = a->neg;
|
||||||
if (a->limbs >= b->limbs) {
|
if (a->limbs >= b->limbs) {
|
||||||
|
@ -192,19 +194,19 @@ static void secp256k1_num_subadd(secp256k1_num_t *r, const secp256k1_num_t *a, c
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_num_add(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b) {
|
static void secp256k1_num_add(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
|
||||||
secp256k1_num_sanity(a);
|
secp256k1_num_sanity(a);
|
||||||
secp256k1_num_sanity(b);
|
secp256k1_num_sanity(b);
|
||||||
secp256k1_num_subadd(r, a, b, 0);
|
secp256k1_num_subadd(r, a, b, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_num_sub(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b) {
|
static void secp256k1_num_sub(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
|
||||||
secp256k1_num_sanity(a);
|
secp256k1_num_sanity(a);
|
||||||
secp256k1_num_sanity(b);
|
secp256k1_num_sanity(b);
|
||||||
secp256k1_num_subadd(r, a, b, 1);
|
secp256k1_num_subadd(r, a, b, 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_num_mul(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b) {
|
static void secp256k1_num_mul(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
|
||||||
mp_limb_t tmp[2*NUM_LIMBS+1];
|
mp_limb_t tmp[2*NUM_LIMBS+1];
|
||||||
secp256k1_num_sanity(a);
|
secp256k1_num_sanity(a);
|
||||||
secp256k1_num_sanity(b);
|
secp256k1_num_sanity(b);
|
||||||
|
@ -231,13 +233,13 @@ static void secp256k1_num_mul(secp256k1_num_t *r, const secp256k1_num_t *a, cons
|
||||||
memset(tmp, 0, sizeof(tmp));
|
memset(tmp, 0, sizeof(tmp));
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_num_shift(secp256k1_num_t *r, int bits) {
|
static void secp256k1_num_shift(secp256k1_num *r, int bits) {
|
||||||
int i;
|
|
||||||
if (bits % GMP_NUMB_BITS) {
|
if (bits % GMP_NUMB_BITS) {
|
||||||
/* Shift within limbs. */
|
/* Shift within limbs. */
|
||||||
mpn_rshift(r->data, r->data, r->limbs, bits % GMP_NUMB_BITS);
|
mpn_rshift(r->data, r->data, r->limbs, bits % GMP_NUMB_BITS);
|
||||||
}
|
}
|
||||||
if (bits >= GMP_NUMB_BITS) {
|
if (bits >= GMP_NUMB_BITS) {
|
||||||
|
int i;
|
||||||
/* Shift full limbs. */
|
/* Shift full limbs. */
|
||||||
for (i = 0; i < r->limbs; i++) {
|
for (i = 0; i < r->limbs; i++) {
|
||||||
int index = i + (bits / GMP_NUMB_BITS);
|
int index = i + (bits / GMP_NUMB_BITS);
|
||||||
|
@ -253,7 +255,7 @@ static void secp256k1_num_shift(secp256k1_num_t *r, int bits) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_num_negate(secp256k1_num_t *r) {
|
static void secp256k1_num_negate(secp256k1_num *r) {
|
||||||
r->neg ^= 1;
|
r->neg ^= 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
57
src/scalar.h
57
src/scalar.h
|
@ -22,72 +22,83 @@
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/** Clear a scalar to prevent the leak of sensitive data. */
|
/** Clear a scalar to prevent the leak of sensitive data. */
|
||||||
static void secp256k1_scalar_clear(secp256k1_scalar_t *r);
|
static void secp256k1_scalar_clear(secp256k1_scalar *r);
|
||||||
|
|
||||||
/** Access bits from a scalar. All requested bits must belong to the same 32-bit limb. */
|
/** Access bits from a scalar. All requested bits must belong to the same 32-bit limb. */
|
||||||
static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count);
|
static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count);
|
||||||
|
|
||||||
/** Access bits from a scalar. Not constant time. */
|
/** Access bits from a scalar. Not constant time. */
|
||||||
static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count);
|
static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count);
|
||||||
|
|
||||||
/** Set a scalar from a big endian byte array. */
|
/** Set a scalar from a big endian byte array. */
|
||||||
static void secp256k1_scalar_set_b32(secp256k1_scalar_t *r, const unsigned char *bin, int *overflow);
|
static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *bin, int *overflow);
|
||||||
|
|
||||||
/** Set a scalar to an unsigned integer. */
|
/** Set a scalar to an unsigned integer. */
|
||||||
static void secp256k1_scalar_set_int(secp256k1_scalar_t *r, unsigned int v);
|
static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v);
|
||||||
|
|
||||||
/** Convert a scalar to a byte array. */
|
/** Convert a scalar to a byte array. */
|
||||||
static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar_t* a);
|
static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a);
|
||||||
|
|
||||||
/** Add two scalars together (modulo the group order). Returns whether it overflowed. */
|
/** Add two scalars together (modulo the group order). Returns whether it overflowed. */
|
||||||
static int secp256k1_scalar_add(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b);
|
static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b);
|
||||||
|
|
||||||
/** Add a power of two to a scalar. The result is not allowed to overflow. */
|
/** Conditionally add a power of two to a scalar. The result is not allowed to overflow. */
|
||||||
static void secp256k1_scalar_add_bit(secp256k1_scalar_t *r, unsigned int bit);
|
static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag);
|
||||||
|
|
||||||
/** Multiply two scalars (modulo the group order). */
|
/** Multiply two scalars (modulo the group order). */
|
||||||
static void secp256k1_scalar_mul(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b);
|
static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b);
|
||||||
|
|
||||||
|
/** Shift a scalar right by some amount strictly between 0 and 16, returning
|
||||||
|
* the low bits that were shifted off */
|
||||||
|
static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n);
|
||||||
|
|
||||||
/** Compute the square of a scalar (modulo the group order). */
|
/** Compute the square of a scalar (modulo the group order). */
|
||||||
static void secp256k1_scalar_sqr(secp256k1_scalar_t *r, const secp256k1_scalar_t *a);
|
static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a);
|
||||||
|
|
||||||
/** Compute the inverse of a scalar (modulo the group order). */
|
/** Compute the inverse of a scalar (modulo the group order). */
|
||||||
static void secp256k1_scalar_inverse(secp256k1_scalar_t *r, const secp256k1_scalar_t *a);
|
static void secp256k1_scalar_inverse(secp256k1_scalar *r, const secp256k1_scalar *a);
|
||||||
|
|
||||||
/** Compute the inverse of a scalar (modulo the group order), without constant-time guarantee. */
|
/** Compute the inverse of a scalar (modulo the group order), without constant-time guarantee. */
|
||||||
static void secp256k1_scalar_inverse_var(secp256k1_scalar_t *r, const secp256k1_scalar_t *a);
|
static void secp256k1_scalar_inverse_var(secp256k1_scalar *r, const secp256k1_scalar *a);
|
||||||
|
|
||||||
/** Compute the complement of a scalar (modulo the group order). */
|
/** Compute the complement of a scalar (modulo the group order). */
|
||||||
static void secp256k1_scalar_negate(secp256k1_scalar_t *r, const secp256k1_scalar_t *a);
|
static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a);
|
||||||
|
|
||||||
/** Check whether a scalar equals zero. */
|
/** Check whether a scalar equals zero. */
|
||||||
static int secp256k1_scalar_is_zero(const secp256k1_scalar_t *a);
|
static int secp256k1_scalar_is_zero(const secp256k1_scalar *a);
|
||||||
|
|
||||||
/** Check whether a scalar equals one. */
|
/** Check whether a scalar equals one. */
|
||||||
static int secp256k1_scalar_is_one(const secp256k1_scalar_t *a);
|
static int secp256k1_scalar_is_one(const secp256k1_scalar *a);
|
||||||
|
|
||||||
|
/** Check whether a scalar, considered as an nonnegative integer, is even. */
|
||||||
|
static int secp256k1_scalar_is_even(const secp256k1_scalar *a);
|
||||||
|
|
||||||
/** Check whether a scalar is higher than the group order divided by 2. */
|
/** Check whether a scalar is higher than the group order divided by 2. */
|
||||||
static int secp256k1_scalar_is_high(const secp256k1_scalar_t *a);
|
static int secp256k1_scalar_is_high(const secp256k1_scalar *a);
|
||||||
|
|
||||||
|
/** Conditionally negate a number, in constant time.
|
||||||
|
* Returns -1 if the number was negated, 1 otherwise */
|
||||||
|
static int secp256k1_scalar_cond_negate(secp256k1_scalar *a, int flag);
|
||||||
|
|
||||||
#ifndef USE_NUM_NONE
|
#ifndef USE_NUM_NONE
|
||||||
/** Convert a scalar to a number. */
|
/** Convert a scalar to a number. */
|
||||||
static void secp256k1_scalar_get_num(secp256k1_num_t *r, const secp256k1_scalar_t *a);
|
static void secp256k1_scalar_get_num(secp256k1_num *r, const secp256k1_scalar *a);
|
||||||
|
|
||||||
/** Get the order of the group as a number. */
|
/** Get the order of the group as a number. */
|
||||||
static void secp256k1_scalar_order_get_num(secp256k1_num_t *r);
|
static void secp256k1_scalar_order_get_num(secp256k1_num *r);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/** Compare two scalars. */
|
/** Compare two scalars. */
|
||||||
static int secp256k1_scalar_eq(const secp256k1_scalar_t *a, const secp256k1_scalar_t *b);
|
static int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b);
|
||||||
|
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
/** Find r1 and r2 such that r1+r2*2^128 = a. */
|
/** Find r1 and r2 such that r1+r2*2^128 = a. */
|
||||||
static void secp256k1_scalar_split_128(secp256k1_scalar_t *r1, secp256k1_scalar_t *r2, const secp256k1_scalar_t *a);
|
static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a);
|
||||||
/** Find r1 and r2 such that r1+r2*lambda = a, and r1 and r2 are maximum 128 bits long (see secp256k1_gej_mul_lambda). */
|
/** Find r1 and r2 such that r1+r2*lambda = a, and r1 and r2 are maximum 128 bits long (see secp256k1_gej_mul_lambda). */
|
||||||
static void secp256k1_scalar_split_lambda_var(secp256k1_scalar_t *r1, secp256k1_scalar_t *r2, const secp256k1_scalar_t *a);
|
static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/** Multiply a and b (without taking the modulus!), divide by 2**shift, and round to the nearest integer. Shift must be at least 256. */
|
/** Multiply a and b (without taking the modulus!), divide by 2**shift, and round to the nearest integer. Shift must be at least 256. */
|
||||||
static void secp256k1_scalar_mul_shift_var(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b, unsigned int shift);
|
static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -12,7 +12,7 @@
|
||||||
/** A scalar modulo the group order of the secp256k1 curve. */
|
/** A scalar modulo the group order of the secp256k1 curve. */
|
||||||
typedef struct {
|
typedef struct {
|
||||||
uint64_t d[4];
|
uint64_t d[4];
|
||||||
} secp256k1_scalar_t;
|
} secp256k1_scalar;
|
||||||
|
|
||||||
#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{((uint64_t)(d1)) << 32 | (d0), ((uint64_t)(d3)) << 32 | (d2), ((uint64_t)(d5)) << 32 | (d4), ((uint64_t)(d7)) << 32 | (d6)}}
|
#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{((uint64_t)(d1)) << 32 | (d0), ((uint64_t)(d3)) << 32 | (d2), ((uint64_t)(d5)) << 32 | (d4), ((uint64_t)(d7)) << 32 | (d6)}}
|
||||||
|
|
||||||
|
|
|
@ -24,26 +24,26 @@
|
||||||
#define SECP256K1_N_H_2 ((uint64_t)0xFFFFFFFFFFFFFFFFULL)
|
#define SECP256K1_N_H_2 ((uint64_t)0xFFFFFFFFFFFFFFFFULL)
|
||||||
#define SECP256K1_N_H_3 ((uint64_t)0x7FFFFFFFFFFFFFFFULL)
|
#define SECP256K1_N_H_3 ((uint64_t)0x7FFFFFFFFFFFFFFFULL)
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar_t *r) {
|
SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) {
|
||||||
r->d[0] = 0;
|
r->d[0] = 0;
|
||||||
r->d[1] = 0;
|
r->d[1] = 0;
|
||||||
r->d[2] = 0;
|
r->d[2] = 0;
|
||||||
r->d[3] = 0;
|
r->d[3] = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar_t *r, unsigned int v) {
|
SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v) {
|
||||||
r->d[0] = v;
|
r->d[0] = v;
|
||||||
r->d[1] = 0;
|
r->d[1] = 0;
|
||||||
r->d[2] = 0;
|
r->d[2] = 0;
|
||||||
r->d[3] = 0;
|
r->d[3] = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count) {
|
SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
|
||||||
VERIFY_CHECK((offset + count - 1) >> 6 == offset >> 6);
|
VERIFY_CHECK((offset + count - 1) >> 6 == offset >> 6);
|
||||||
return (a->d[offset >> 6] >> (offset & 0x3F)) & ((((uint64_t)1) << count) - 1);
|
return (a->d[offset >> 6] >> (offset & 0x3F)) & ((((uint64_t)1) << count) - 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count) {
|
SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
|
||||||
VERIFY_CHECK(count < 32);
|
VERIFY_CHECK(count < 32);
|
||||||
VERIFY_CHECK(offset + count <= 256);
|
VERIFY_CHECK(offset + count <= 256);
|
||||||
if ((offset + count - 1) >> 6 == offset >> 6) {
|
if ((offset + count - 1) >> 6 == offset >> 6) {
|
||||||
|
@ -54,7 +54,7 @@ SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar_t *a) {
|
SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar *a) {
|
||||||
int yes = 0;
|
int yes = 0;
|
||||||
int no = 0;
|
int no = 0;
|
||||||
no |= (a->d[3] < SECP256K1_N_3); /* No need for a > check. */
|
no |= (a->d[3] < SECP256K1_N_3); /* No need for a > check. */
|
||||||
|
@ -66,7 +66,7 @@ SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scal
|
||||||
return yes;
|
return yes;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar_t *r, unsigned int overflow) {
|
SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar *r, unsigned int overflow) {
|
||||||
uint128_t t;
|
uint128_t t;
|
||||||
VERIFY_CHECK(overflow <= 1);
|
VERIFY_CHECK(overflow <= 1);
|
||||||
t = (uint128_t)r->d[0] + overflow * SECP256K1_N_C_0;
|
t = (uint128_t)r->d[0] + overflow * SECP256K1_N_C_0;
|
||||||
|
@ -80,7 +80,7 @@ SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar_t *r, unsig
|
||||||
return overflow;
|
return overflow;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_scalar_add(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
|
static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
|
||||||
int overflow;
|
int overflow;
|
||||||
uint128_t t = (uint128_t)a->d[0] + b->d[0];
|
uint128_t t = (uint128_t)a->d[0] + b->d[0];
|
||||||
r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
|
r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
|
||||||
|
@ -96,9 +96,10 @@ static int secp256k1_scalar_add(secp256k1_scalar_t *r, const secp256k1_scalar_t
|
||||||
return overflow;
|
return overflow;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_add_bit(secp256k1_scalar_t *r, unsigned int bit) {
|
static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag) {
|
||||||
uint128_t t;
|
uint128_t t;
|
||||||
VERIFY_CHECK(bit < 256);
|
VERIFY_CHECK(bit < 256);
|
||||||
|
bit += ((uint32_t) flag - 1) & 0x100; /* forcing (bit >> 6) > 3 makes this a noop */
|
||||||
t = (uint128_t)r->d[0] + (((uint64_t)((bit >> 6) == 0)) << (bit & 0x3F));
|
t = (uint128_t)r->d[0] + (((uint64_t)((bit >> 6) == 0)) << (bit & 0x3F));
|
||||||
r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
|
r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
|
||||||
t += (uint128_t)r->d[1] + (((uint64_t)((bit >> 6) == 1)) << (bit & 0x3F));
|
t += (uint128_t)r->d[1] + (((uint64_t)((bit >> 6) == 1)) << (bit & 0x3F));
|
||||||
|
@ -113,7 +114,7 @@ static void secp256k1_scalar_add_bit(secp256k1_scalar_t *r, unsigned int bit) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_set_b32(secp256k1_scalar_t *r, const unsigned char *b32, int *overflow) {
|
static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow) {
|
||||||
int over;
|
int over;
|
||||||
r->d[0] = (uint64_t)b32[31] | (uint64_t)b32[30] << 8 | (uint64_t)b32[29] << 16 | (uint64_t)b32[28] << 24 | (uint64_t)b32[27] << 32 | (uint64_t)b32[26] << 40 | (uint64_t)b32[25] << 48 | (uint64_t)b32[24] << 56;
|
r->d[0] = (uint64_t)b32[31] | (uint64_t)b32[30] << 8 | (uint64_t)b32[29] << 16 | (uint64_t)b32[28] << 24 | (uint64_t)b32[27] << 32 | (uint64_t)b32[26] << 40 | (uint64_t)b32[25] << 48 | (uint64_t)b32[24] << 56;
|
||||||
r->d[1] = (uint64_t)b32[23] | (uint64_t)b32[22] << 8 | (uint64_t)b32[21] << 16 | (uint64_t)b32[20] << 24 | (uint64_t)b32[19] << 32 | (uint64_t)b32[18] << 40 | (uint64_t)b32[17] << 48 | (uint64_t)b32[16] << 56;
|
r->d[1] = (uint64_t)b32[23] | (uint64_t)b32[22] << 8 | (uint64_t)b32[21] << 16 | (uint64_t)b32[20] << 24 | (uint64_t)b32[19] << 32 | (uint64_t)b32[18] << 40 | (uint64_t)b32[17] << 48 | (uint64_t)b32[16] << 56;
|
||||||
|
@ -125,18 +126,18 @@ static void secp256k1_scalar_set_b32(secp256k1_scalar_t *r, const unsigned char
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar_t* a) {
|
static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a) {
|
||||||
bin[0] = a->d[3] >> 56; bin[1] = a->d[3] >> 48; bin[2] = a->d[3] >> 40; bin[3] = a->d[3] >> 32; bin[4] = a->d[3] >> 24; bin[5] = a->d[3] >> 16; bin[6] = a->d[3] >> 8; bin[7] = a->d[3];
|
bin[0] = a->d[3] >> 56; bin[1] = a->d[3] >> 48; bin[2] = a->d[3] >> 40; bin[3] = a->d[3] >> 32; bin[4] = a->d[3] >> 24; bin[5] = a->d[3] >> 16; bin[6] = a->d[3] >> 8; bin[7] = a->d[3];
|
||||||
bin[8] = a->d[2] >> 56; bin[9] = a->d[2] >> 48; bin[10] = a->d[2] >> 40; bin[11] = a->d[2] >> 32; bin[12] = a->d[2] >> 24; bin[13] = a->d[2] >> 16; bin[14] = a->d[2] >> 8; bin[15] = a->d[2];
|
bin[8] = a->d[2] >> 56; bin[9] = a->d[2] >> 48; bin[10] = a->d[2] >> 40; bin[11] = a->d[2] >> 32; bin[12] = a->d[2] >> 24; bin[13] = a->d[2] >> 16; bin[14] = a->d[2] >> 8; bin[15] = a->d[2];
|
||||||
bin[16] = a->d[1] >> 56; bin[17] = a->d[1] >> 48; bin[18] = a->d[1] >> 40; bin[19] = a->d[1] >> 32; bin[20] = a->d[1] >> 24; bin[21] = a->d[1] >> 16; bin[22] = a->d[1] >> 8; bin[23] = a->d[1];
|
bin[16] = a->d[1] >> 56; bin[17] = a->d[1] >> 48; bin[18] = a->d[1] >> 40; bin[19] = a->d[1] >> 32; bin[20] = a->d[1] >> 24; bin[21] = a->d[1] >> 16; bin[22] = a->d[1] >> 8; bin[23] = a->d[1];
|
||||||
bin[24] = a->d[0] >> 56; bin[25] = a->d[0] >> 48; bin[26] = a->d[0] >> 40; bin[27] = a->d[0] >> 32; bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0];
|
bin[24] = a->d[0] >> 56; bin[25] = a->d[0] >> 48; bin[26] = a->d[0] >> 40; bin[27] = a->d[0] >> 32; bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0];
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar_t *a) {
|
SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar *a) {
|
||||||
return (a->d[0] | a->d[1] | a->d[2] | a->d[3]) == 0;
|
return (a->d[0] | a->d[1] | a->d[2] | a->d[3]) == 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_negate(secp256k1_scalar_t *r, const secp256k1_scalar_t *a) {
|
static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a) {
|
||||||
uint64_t nonzero = 0xFFFFFFFFFFFFFFFFULL * (secp256k1_scalar_is_zero(a) == 0);
|
uint64_t nonzero = 0xFFFFFFFFFFFFFFFFULL * (secp256k1_scalar_is_zero(a) == 0);
|
||||||
uint128_t t = (uint128_t)(~a->d[0]) + SECP256K1_N_0 + 1;
|
uint128_t t = (uint128_t)(~a->d[0]) + SECP256K1_N_0 + 1;
|
||||||
r->d[0] = t & nonzero; t >>= 64;
|
r->d[0] = t & nonzero; t >>= 64;
|
||||||
|
@ -148,11 +149,11 @@ static void secp256k1_scalar_negate(secp256k1_scalar_t *r, const secp256k1_scala
|
||||||
r->d[3] = t & nonzero;
|
r->d[3] = t & nonzero;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar_t *a) {
|
SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar *a) {
|
||||||
return ((a->d[0] ^ 1) | a->d[1] | a->d[2] | a->d[3]) == 0;
|
return ((a->d[0] ^ 1) | a->d[1] | a->d[2] | a->d[3]) == 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_scalar_is_high(const secp256k1_scalar_t *a) {
|
static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
|
||||||
int yes = 0;
|
int yes = 0;
|
||||||
int no = 0;
|
int no = 0;
|
||||||
no |= (a->d[3] < SECP256K1_N_H_3);
|
no |= (a->d[3] < SECP256K1_N_H_3);
|
||||||
|
@ -164,6 +165,22 @@ static int secp256k1_scalar_is_high(const secp256k1_scalar_t *a) {
|
||||||
return yes;
|
return yes;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
|
||||||
|
/* If we are flag = 0, mask = 00...00 and this is a no-op;
|
||||||
|
* if we are flag = 1, mask = 11...11 and this is identical to secp256k1_scalar_negate */
|
||||||
|
uint64_t mask = !flag - 1;
|
||||||
|
uint64_t nonzero = (secp256k1_scalar_is_zero(r) != 0) - 1;
|
||||||
|
uint128_t t = (uint128_t)(r->d[0] ^ mask) + ((SECP256K1_N_0 + 1) & mask);
|
||||||
|
r->d[0] = t & nonzero; t >>= 64;
|
||||||
|
t += (uint128_t)(r->d[1] ^ mask) + (SECP256K1_N_1 & mask);
|
||||||
|
r->d[1] = t & nonzero; t >>= 64;
|
||||||
|
t += (uint128_t)(r->d[2] ^ mask) + (SECP256K1_N_2 & mask);
|
||||||
|
r->d[2] = t & nonzero; t >>= 64;
|
||||||
|
t += (uint128_t)(r->d[3] ^ mask) + (SECP256K1_N_3 & mask);
|
||||||
|
r->d[3] = t & nonzero;
|
||||||
|
return 2 * (mask == 0) - 1;
|
||||||
|
}
|
||||||
|
|
||||||
/* Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. */
|
/* Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. */
|
||||||
|
|
||||||
/** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
|
/** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
|
||||||
|
@ -250,7 +267,7 @@ static int secp256k1_scalar_is_high(const secp256k1_scalar_t *a) {
|
||||||
VERIFY_CHECK(c2 == 0); \
|
VERIFY_CHECK(c2 == 0); \
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_reduce_512(secp256k1_scalar_t *r, const uint64_t *l) {
|
static void secp256k1_scalar_reduce_512(secp256k1_scalar *r, const uint64_t *l) {
|
||||||
#ifdef USE_ASM_X86_64
|
#ifdef USE_ASM_X86_64
|
||||||
/* Reduce 512 bits into 385. */
|
/* Reduce 512 bits into 385. */
|
||||||
uint64_t m0, m1, m2, m3, m4, m5, m6;
|
uint64_t m0, m1, m2, m3, m4, m5, m6;
|
||||||
|
@ -559,7 +576,7 @@ static void secp256k1_scalar_reduce_512(secp256k1_scalar_t *r, const uint64_t *l
|
||||||
secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r));
|
secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r));
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_mul_512(uint64_t l[8], const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
|
static void secp256k1_scalar_mul_512(uint64_t l[8], const secp256k1_scalar *a, const secp256k1_scalar *b) {
|
||||||
#ifdef USE_ASM_X86_64
|
#ifdef USE_ASM_X86_64
|
||||||
const uint64_t *pb = b->d;
|
const uint64_t *pb = b->d;
|
||||||
__asm__ __volatile__(
|
__asm__ __volatile__(
|
||||||
|
@ -721,12 +738,12 @@ static void secp256k1_scalar_mul_512(uint64_t l[8], const secp256k1_scalar_t *a,
|
||||||
extract(l[5]);
|
extract(l[5]);
|
||||||
muladd_fast(a->d[3], b->d[3]);
|
muladd_fast(a->d[3], b->d[3]);
|
||||||
extract_fast(l[6]);
|
extract_fast(l[6]);
|
||||||
VERIFY_CHECK(c1 <= 0);
|
VERIFY_CHECK(c1 == 0);
|
||||||
l[7] = c0;
|
l[7] = c0;
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_sqr_512(uint64_t l[8], const secp256k1_scalar_t *a) {
|
static void secp256k1_scalar_sqr_512(uint64_t l[8], const secp256k1_scalar *a) {
|
||||||
#ifdef USE_ASM_X86_64
|
#ifdef USE_ASM_X86_64
|
||||||
__asm__ __volatile__(
|
__asm__ __volatile__(
|
||||||
/* Preload */
|
/* Preload */
|
||||||
|
@ -871,19 +888,32 @@ static void secp256k1_scalar_sqr_512(uint64_t l[8], const secp256k1_scalar_t *a)
|
||||||
#undef extract
|
#undef extract
|
||||||
#undef extract_fast
|
#undef extract_fast
|
||||||
|
|
||||||
static void secp256k1_scalar_mul(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
|
static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
|
||||||
uint64_t l[8];
|
uint64_t l[8];
|
||||||
secp256k1_scalar_mul_512(l, a, b);
|
secp256k1_scalar_mul_512(l, a, b);
|
||||||
secp256k1_scalar_reduce_512(r, l);
|
secp256k1_scalar_reduce_512(r, l);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_sqr(secp256k1_scalar_t *r, const secp256k1_scalar_t *a) {
|
static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
|
||||||
|
int ret;
|
||||||
|
VERIFY_CHECK(n > 0);
|
||||||
|
VERIFY_CHECK(n < 16);
|
||||||
|
ret = r->d[0] & ((1 << n) - 1);
|
||||||
|
r->d[0] = (r->d[0] >> n) + (r->d[1] << (64 - n));
|
||||||
|
r->d[1] = (r->d[1] >> n) + (r->d[2] << (64 - n));
|
||||||
|
r->d[2] = (r->d[2] >> n) + (r->d[3] << (64 - n));
|
||||||
|
r->d[3] = (r->d[3] >> n);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a) {
|
||||||
uint64_t l[8];
|
uint64_t l[8];
|
||||||
secp256k1_scalar_sqr_512(l, a);
|
secp256k1_scalar_sqr_512(l, a);
|
||||||
secp256k1_scalar_reduce_512(r, l);
|
secp256k1_scalar_reduce_512(r, l);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_split_128(secp256k1_scalar_t *r1, secp256k1_scalar_t *r2, const secp256k1_scalar_t *a) {
|
#ifdef USE_ENDOMORPHISM
|
||||||
|
static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
|
||||||
r1->d[0] = a->d[0];
|
r1->d[0] = a->d[0];
|
||||||
r1->d[1] = a->d[1];
|
r1->d[1] = a->d[1];
|
||||||
r1->d[2] = 0;
|
r1->d[2] = 0;
|
||||||
|
@ -893,12 +923,13 @@ static void secp256k1_scalar_split_128(secp256k1_scalar_t *r1, secp256k1_scalar_
|
||||||
r2->d[2] = 0;
|
r2->d[2] = 0;
|
||||||
r2->d[3] = 0;
|
r2->d[3] = 0;
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
|
SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b) {
|
||||||
return ((a->d[0] ^ b->d[0]) | (a->d[1] ^ b->d[1]) | (a->d[2] ^ b->d[2]) | (a->d[3] ^ b->d[3])) == 0;
|
return ((a->d[0] ^ b->d[0]) | (a->d[1] ^ b->d[1]) | (a->d[2] ^ b->d[2]) | (a->d[3] ^ b->d[3])) == 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b, unsigned int shift) {
|
SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift) {
|
||||||
uint64_t l[8];
|
uint64_t l[8];
|
||||||
unsigned int shiftlimbs;
|
unsigned int shiftlimbs;
|
||||||
unsigned int shiftlow;
|
unsigned int shiftlow;
|
||||||
|
@ -912,9 +943,7 @@ SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar_t *
|
||||||
r->d[1] = shift < 448 ? (l[1 + shiftlimbs] >> shiftlow | (shift < 384 && shiftlow ? (l[2 + shiftlimbs] << shifthigh) : 0)) : 0;
|
r->d[1] = shift < 448 ? (l[1 + shiftlimbs] >> shiftlow | (shift < 384 && shiftlow ? (l[2 + shiftlimbs] << shifthigh) : 0)) : 0;
|
||||||
r->d[2] = shift < 384 ? (l[2 + shiftlimbs] >> shiftlow | (shift < 320 && shiftlow ? (l[3 + shiftlimbs] << shifthigh) : 0)) : 0;
|
r->d[2] = shift < 384 ? (l[2 + shiftlimbs] >> shiftlow | (shift < 320 && shiftlow ? (l[3 + shiftlimbs] << shifthigh) : 0)) : 0;
|
||||||
r->d[3] = shift < 320 ? (l[3 + shiftlimbs] >> shiftlow) : 0;
|
r->d[3] = shift < 320 ? (l[3 + shiftlimbs] >> shiftlow) : 0;
|
||||||
if ((l[(shift - 1) >> 6] >> ((shift - 1) & 0x3f)) & 1) {
|
secp256k1_scalar_cadd_bit(r, 0, (l[(shift - 1) >> 6] >> ((shift - 1) & 0x3f)) & 1);
|
||||||
secp256k1_scalar_add_bit(r, 0);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -12,7 +12,7 @@
|
||||||
/** A scalar modulo the group order of the secp256k1 curve. */
|
/** A scalar modulo the group order of the secp256k1 curve. */
|
||||||
typedef struct {
|
typedef struct {
|
||||||
uint32_t d[8];
|
uint32_t d[8];
|
||||||
} secp256k1_scalar_t;
|
} secp256k1_scalar;
|
||||||
|
|
||||||
#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{(d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7)}}
|
#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{(d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7)}}
|
||||||
|
|
||||||
|
|
|
@ -34,7 +34,7 @@
|
||||||
#define SECP256K1_N_H_6 ((uint32_t)0xFFFFFFFFUL)
|
#define SECP256K1_N_H_6 ((uint32_t)0xFFFFFFFFUL)
|
||||||
#define SECP256K1_N_H_7 ((uint32_t)0x7FFFFFFFUL)
|
#define SECP256K1_N_H_7 ((uint32_t)0x7FFFFFFFUL)
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar_t *r) {
|
SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) {
|
||||||
r->d[0] = 0;
|
r->d[0] = 0;
|
||||||
r->d[1] = 0;
|
r->d[1] = 0;
|
||||||
r->d[2] = 0;
|
r->d[2] = 0;
|
||||||
|
@ -45,7 +45,7 @@ SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar_t *r) {
|
||||||
r->d[7] = 0;
|
r->d[7] = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar_t *r, unsigned int v) {
|
SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v) {
|
||||||
r->d[0] = v;
|
r->d[0] = v;
|
||||||
r->d[1] = 0;
|
r->d[1] = 0;
|
||||||
r->d[2] = 0;
|
r->d[2] = 0;
|
||||||
|
@ -56,12 +56,12 @@ SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar_t *r, uns
|
||||||
r->d[7] = 0;
|
r->d[7] = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count) {
|
SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
|
||||||
VERIFY_CHECK((offset + count - 1) >> 5 == offset >> 5);
|
VERIFY_CHECK((offset + count - 1) >> 5 == offset >> 5);
|
||||||
return (a->d[offset >> 5] >> (offset & 0x1F)) & ((1 << count) - 1);
|
return (a->d[offset >> 5] >> (offset & 0x1F)) & ((1 << count) - 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count) {
|
SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
|
||||||
VERIFY_CHECK(count < 32);
|
VERIFY_CHECK(count < 32);
|
||||||
VERIFY_CHECK(offset + count <= 256);
|
VERIFY_CHECK(offset + count <= 256);
|
||||||
if ((offset + count - 1) >> 5 == offset >> 5) {
|
if ((offset + count - 1) >> 5 == offset >> 5) {
|
||||||
|
@ -72,7 +72,7 @@ SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar_t *a) {
|
SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar *a) {
|
||||||
int yes = 0;
|
int yes = 0;
|
||||||
int no = 0;
|
int no = 0;
|
||||||
no |= (a->d[7] < SECP256K1_N_7); /* No need for a > check. */
|
no |= (a->d[7] < SECP256K1_N_7); /* No need for a > check. */
|
||||||
|
@ -90,7 +90,7 @@ SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scal
|
||||||
return yes;
|
return yes;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar_t *r, uint32_t overflow) {
|
SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar *r, uint32_t overflow) {
|
||||||
uint64_t t;
|
uint64_t t;
|
||||||
VERIFY_CHECK(overflow <= 1);
|
VERIFY_CHECK(overflow <= 1);
|
||||||
t = (uint64_t)r->d[0] + overflow * SECP256K1_N_C_0;
|
t = (uint64_t)r->d[0] + overflow * SECP256K1_N_C_0;
|
||||||
|
@ -112,7 +112,7 @@ SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar_t *r, uint3
|
||||||
return overflow;
|
return overflow;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_scalar_add(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
|
static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
|
||||||
int overflow;
|
int overflow;
|
||||||
uint64_t t = (uint64_t)a->d[0] + b->d[0];
|
uint64_t t = (uint64_t)a->d[0] + b->d[0];
|
||||||
r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
|
r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
|
||||||
|
@ -136,9 +136,10 @@ static int secp256k1_scalar_add(secp256k1_scalar_t *r, const secp256k1_scalar_t
|
||||||
return overflow;
|
return overflow;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_add_bit(secp256k1_scalar_t *r, unsigned int bit) {
|
static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag) {
|
||||||
uint64_t t;
|
uint64_t t;
|
||||||
VERIFY_CHECK(bit < 256);
|
VERIFY_CHECK(bit < 256);
|
||||||
|
bit += ((uint32_t) flag - 1) & 0x100; /* forcing (bit >> 5) > 7 makes this a noop */
|
||||||
t = (uint64_t)r->d[0] + (((uint32_t)((bit >> 5) == 0)) << (bit & 0x1F));
|
t = (uint64_t)r->d[0] + (((uint32_t)((bit >> 5) == 0)) << (bit & 0x1F));
|
||||||
r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
|
r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
|
||||||
t += (uint64_t)r->d[1] + (((uint32_t)((bit >> 5) == 1)) << (bit & 0x1F));
|
t += (uint64_t)r->d[1] + (((uint32_t)((bit >> 5) == 1)) << (bit & 0x1F));
|
||||||
|
@ -161,7 +162,7 @@ static void secp256k1_scalar_add_bit(secp256k1_scalar_t *r, unsigned int bit) {
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_set_b32(secp256k1_scalar_t *r, const unsigned char *b32, int *overflow) {
|
static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow) {
|
||||||
int over;
|
int over;
|
||||||
r->d[0] = (uint32_t)b32[31] | (uint32_t)b32[30] << 8 | (uint32_t)b32[29] << 16 | (uint32_t)b32[28] << 24;
|
r->d[0] = (uint32_t)b32[31] | (uint32_t)b32[30] << 8 | (uint32_t)b32[29] << 16 | (uint32_t)b32[28] << 24;
|
||||||
r->d[1] = (uint32_t)b32[27] | (uint32_t)b32[26] << 8 | (uint32_t)b32[25] << 16 | (uint32_t)b32[24] << 24;
|
r->d[1] = (uint32_t)b32[27] | (uint32_t)b32[26] << 8 | (uint32_t)b32[25] << 16 | (uint32_t)b32[24] << 24;
|
||||||
|
@ -177,7 +178,7 @@ static void secp256k1_scalar_set_b32(secp256k1_scalar_t *r, const unsigned char
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar_t* a) {
|
static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a) {
|
||||||
bin[0] = a->d[7] >> 24; bin[1] = a->d[7] >> 16; bin[2] = a->d[7] >> 8; bin[3] = a->d[7];
|
bin[0] = a->d[7] >> 24; bin[1] = a->d[7] >> 16; bin[2] = a->d[7] >> 8; bin[3] = a->d[7];
|
||||||
bin[4] = a->d[6] >> 24; bin[5] = a->d[6] >> 16; bin[6] = a->d[6] >> 8; bin[7] = a->d[6];
|
bin[4] = a->d[6] >> 24; bin[5] = a->d[6] >> 16; bin[6] = a->d[6] >> 8; bin[7] = a->d[6];
|
||||||
bin[8] = a->d[5] >> 24; bin[9] = a->d[5] >> 16; bin[10] = a->d[5] >> 8; bin[11] = a->d[5];
|
bin[8] = a->d[5] >> 24; bin[9] = a->d[5] >> 16; bin[10] = a->d[5] >> 8; bin[11] = a->d[5];
|
||||||
|
@ -188,11 +189,11 @@ static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar_
|
||||||
bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0];
|
bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0];
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar_t *a) {
|
SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar *a) {
|
||||||
return (a->d[0] | a->d[1] | a->d[2] | a->d[3] | a->d[4] | a->d[5] | a->d[6] | a->d[7]) == 0;
|
return (a->d[0] | a->d[1] | a->d[2] | a->d[3] | a->d[4] | a->d[5] | a->d[6] | a->d[7]) == 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_negate(secp256k1_scalar_t *r, const secp256k1_scalar_t *a) {
|
static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a) {
|
||||||
uint32_t nonzero = 0xFFFFFFFFUL * (secp256k1_scalar_is_zero(a) == 0);
|
uint32_t nonzero = 0xFFFFFFFFUL * (secp256k1_scalar_is_zero(a) == 0);
|
||||||
uint64_t t = (uint64_t)(~a->d[0]) + SECP256K1_N_0 + 1;
|
uint64_t t = (uint64_t)(~a->d[0]) + SECP256K1_N_0 + 1;
|
||||||
r->d[0] = t & nonzero; t >>= 32;
|
r->d[0] = t & nonzero; t >>= 32;
|
||||||
|
@ -212,11 +213,11 @@ static void secp256k1_scalar_negate(secp256k1_scalar_t *r, const secp256k1_scala
|
||||||
r->d[7] = t & nonzero;
|
r->d[7] = t & nonzero;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar_t *a) {
|
SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar *a) {
|
||||||
return ((a->d[0] ^ 1) | a->d[1] | a->d[2] | a->d[3] | a->d[4] | a->d[5] | a->d[6] | a->d[7]) == 0;
|
return ((a->d[0] ^ 1) | a->d[1] | a->d[2] | a->d[3] | a->d[4] | a->d[5] | a->d[6] | a->d[7]) == 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int secp256k1_scalar_is_high(const secp256k1_scalar_t *a) {
|
static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
|
||||||
int yes = 0;
|
int yes = 0;
|
||||||
int no = 0;
|
int no = 0;
|
||||||
no |= (a->d[7] < SECP256K1_N_H_7);
|
no |= (a->d[7] < SECP256K1_N_H_7);
|
||||||
|
@ -234,6 +235,31 @@ static int secp256k1_scalar_is_high(const secp256k1_scalar_t *a) {
|
||||||
return yes;
|
return yes;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
|
||||||
|
/* If we are flag = 0, mask = 00...00 and this is a no-op;
|
||||||
|
* if we are flag = 1, mask = 11...11 and this is identical to secp256k1_scalar_negate */
|
||||||
|
uint32_t mask = !flag - 1;
|
||||||
|
uint32_t nonzero = 0xFFFFFFFFUL * (secp256k1_scalar_is_zero(r) == 0);
|
||||||
|
uint64_t t = (uint64_t)(r->d[0] ^ mask) + ((SECP256K1_N_0 + 1) & mask);
|
||||||
|
r->d[0] = t & nonzero; t >>= 32;
|
||||||
|
t += (uint64_t)(r->d[1] ^ mask) + (SECP256K1_N_1 & mask);
|
||||||
|
r->d[1] = t & nonzero; t >>= 32;
|
||||||
|
t += (uint64_t)(r->d[2] ^ mask) + (SECP256K1_N_2 & mask);
|
||||||
|
r->d[2] = t & nonzero; t >>= 32;
|
||||||
|
t += (uint64_t)(r->d[3] ^ mask) + (SECP256K1_N_3 & mask);
|
||||||
|
r->d[3] = t & nonzero; t >>= 32;
|
||||||
|
t += (uint64_t)(r->d[4] ^ mask) + (SECP256K1_N_4 & mask);
|
||||||
|
r->d[4] = t & nonzero; t >>= 32;
|
||||||
|
t += (uint64_t)(r->d[5] ^ mask) + (SECP256K1_N_5 & mask);
|
||||||
|
r->d[5] = t & nonzero; t >>= 32;
|
||||||
|
t += (uint64_t)(r->d[6] ^ mask) + (SECP256K1_N_6 & mask);
|
||||||
|
r->d[6] = t & nonzero; t >>= 32;
|
||||||
|
t += (uint64_t)(r->d[7] ^ mask) + (SECP256K1_N_7 & mask);
|
||||||
|
r->d[7] = t & nonzero;
|
||||||
|
return 2 * (mask == 0) - 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
/* Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. */
|
/* Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. */
|
||||||
|
|
||||||
/** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
|
/** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
|
||||||
|
@ -320,7 +346,7 @@ static int secp256k1_scalar_is_high(const secp256k1_scalar_t *a) {
|
||||||
VERIFY_CHECK(c2 == 0); \
|
VERIFY_CHECK(c2 == 0); \
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_reduce_512(secp256k1_scalar_t *r, const uint32_t *l) {
|
static void secp256k1_scalar_reduce_512(secp256k1_scalar *r, const uint32_t *l) {
|
||||||
uint64_t c;
|
uint64_t c;
|
||||||
uint32_t n0 = l[8], n1 = l[9], n2 = l[10], n3 = l[11], n4 = l[12], n5 = l[13], n6 = l[14], n7 = l[15];
|
uint32_t n0 = l[8], n1 = l[9], n2 = l[10], n3 = l[11], n4 = l[12], n5 = l[13], n6 = l[14], n7 = l[15];
|
||||||
uint32_t m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12;
|
uint32_t m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12;
|
||||||
|
@ -462,7 +488,7 @@ static void secp256k1_scalar_reduce_512(secp256k1_scalar_t *r, const uint32_t *l
|
||||||
secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r));
|
secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r));
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_mul_512(uint32_t *l, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
|
static void secp256k1_scalar_mul_512(uint32_t *l, const secp256k1_scalar *a, const secp256k1_scalar *b) {
|
||||||
/* 96 bit accumulator. */
|
/* 96 bit accumulator. */
|
||||||
uint32_t c0 = 0, c1 = 0, c2 = 0;
|
uint32_t c0 = 0, c1 = 0, c2 = 0;
|
||||||
|
|
||||||
|
@ -550,7 +576,7 @@ static void secp256k1_scalar_mul_512(uint32_t *l, const secp256k1_scalar_t *a, c
|
||||||
l[15] = c0;
|
l[15] = c0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_sqr_512(uint32_t *l, const secp256k1_scalar_t *a) {
|
static void secp256k1_scalar_sqr_512(uint32_t *l, const secp256k1_scalar *a) {
|
||||||
/* 96 bit accumulator. */
|
/* 96 bit accumulator. */
|
||||||
uint32_t c0 = 0, c1 = 0, c2 = 0;
|
uint32_t c0 = 0, c1 = 0, c2 = 0;
|
||||||
|
|
||||||
|
@ -618,20 +644,36 @@ static void secp256k1_scalar_sqr_512(uint32_t *l, const secp256k1_scalar_t *a) {
|
||||||
#undef extract
|
#undef extract
|
||||||
#undef extract_fast
|
#undef extract_fast
|
||||||
|
|
||||||
static void secp256k1_scalar_mul(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
|
static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
|
||||||
uint32_t l[16];
|
uint32_t l[16];
|
||||||
secp256k1_scalar_mul_512(l, a, b);
|
secp256k1_scalar_mul_512(l, a, b);
|
||||||
secp256k1_scalar_reduce_512(r, l);
|
secp256k1_scalar_reduce_512(r, l);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_sqr(secp256k1_scalar_t *r, const secp256k1_scalar_t *a) {
|
static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
|
||||||
|
int ret;
|
||||||
|
VERIFY_CHECK(n > 0);
|
||||||
|
VERIFY_CHECK(n < 16);
|
||||||
|
ret = r->d[0] & ((1 << n) - 1);
|
||||||
|
r->d[0] = (r->d[0] >> n) + (r->d[1] << (32 - n));
|
||||||
|
r->d[1] = (r->d[1] >> n) + (r->d[2] << (32 - n));
|
||||||
|
r->d[2] = (r->d[2] >> n) + (r->d[3] << (32 - n));
|
||||||
|
r->d[3] = (r->d[3] >> n) + (r->d[4] << (32 - n));
|
||||||
|
r->d[4] = (r->d[4] >> n) + (r->d[5] << (32 - n));
|
||||||
|
r->d[5] = (r->d[5] >> n) + (r->d[6] << (32 - n));
|
||||||
|
r->d[6] = (r->d[6] >> n) + (r->d[7] << (32 - n));
|
||||||
|
r->d[7] = (r->d[7] >> n);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a) {
|
||||||
uint32_t l[16];
|
uint32_t l[16];
|
||||||
secp256k1_scalar_sqr_512(l, a);
|
secp256k1_scalar_sqr_512(l, a);
|
||||||
secp256k1_scalar_reduce_512(r, l);
|
secp256k1_scalar_reduce_512(r, l);
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef USE_ENDOMORPHISM
|
#ifdef USE_ENDOMORPHISM
|
||||||
static void secp256k1_scalar_split_128(secp256k1_scalar_t *r1, secp256k1_scalar_t *r2, const secp256k1_scalar_t *a) {
|
static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
|
||||||
r1->d[0] = a->d[0];
|
r1->d[0] = a->d[0];
|
||||||
r1->d[1] = a->d[1];
|
r1->d[1] = a->d[1];
|
||||||
r1->d[2] = a->d[2];
|
r1->d[2] = a->d[2];
|
||||||
|
@ -651,11 +693,11 @@ static void secp256k1_scalar_split_128(secp256k1_scalar_t *r1, secp256k1_scalar_
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
|
SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b) {
|
||||||
return ((a->d[0] ^ b->d[0]) | (a->d[1] ^ b->d[1]) | (a->d[2] ^ b->d[2]) | (a->d[3] ^ b->d[3]) | (a->d[4] ^ b->d[4]) | (a->d[5] ^ b->d[5]) | (a->d[6] ^ b->d[6]) | (a->d[7] ^ b->d[7])) == 0;
|
return ((a->d[0] ^ b->d[0]) | (a->d[1] ^ b->d[1]) | (a->d[2] ^ b->d[2]) | (a->d[3] ^ b->d[3]) | (a->d[4] ^ b->d[4]) | (a->d[5] ^ b->d[5]) | (a->d[6] ^ b->d[6]) | (a->d[7] ^ b->d[7])) == 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b, unsigned int shift) {
|
SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift) {
|
||||||
uint32_t l[16];
|
uint32_t l[16];
|
||||||
unsigned int shiftlimbs;
|
unsigned int shiftlimbs;
|
||||||
unsigned int shiftlow;
|
unsigned int shiftlow;
|
||||||
|
@ -673,9 +715,7 @@ SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar_t *
|
||||||
r->d[5] = shift < 352 ? (l[5 + shiftlimbs] >> shiftlow | (shift < 320 && shiftlow ? (l[6 + shiftlimbs] << shifthigh) : 0)) : 0;
|
r->d[5] = shift < 352 ? (l[5 + shiftlimbs] >> shiftlow | (shift < 320 && shiftlow ? (l[6 + shiftlimbs] << shifthigh) : 0)) : 0;
|
||||||
r->d[6] = shift < 320 ? (l[6 + shiftlimbs] >> shiftlow | (shift < 288 && shiftlow ? (l[7 + shiftlimbs] << shifthigh) : 0)) : 0;
|
r->d[6] = shift < 320 ? (l[6 + shiftlimbs] >> shiftlow | (shift < 288 && shiftlow ? (l[7 + shiftlimbs] << shifthigh) : 0)) : 0;
|
||||||
r->d[7] = shift < 288 ? (l[7 + shiftlimbs] >> shiftlow) : 0;
|
r->d[7] = shift < 288 ? (l[7 + shiftlimbs] >> shiftlow) : 0;
|
||||||
if ((l[(shift - 1) >> 5] >> ((shift - 1) & 0x1f)) & 1) {
|
secp256k1_scalar_cadd_bit(r, 0, (l[(shift - 1) >> 5] >> ((shift - 1) & 0x1f)) & 1);
|
||||||
secp256k1_scalar_add_bit(r, 0);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -25,14 +25,14 @@
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifndef USE_NUM_NONE
|
#ifndef USE_NUM_NONE
|
||||||
static void secp256k1_scalar_get_num(secp256k1_num_t *r, const secp256k1_scalar_t *a) {
|
static void secp256k1_scalar_get_num(secp256k1_num *r, const secp256k1_scalar *a) {
|
||||||
unsigned char c[32];
|
unsigned char c[32];
|
||||||
secp256k1_scalar_get_b32(c, a);
|
secp256k1_scalar_get_b32(c, a);
|
||||||
secp256k1_num_set_bin(r, c, 32);
|
secp256k1_num_set_bin(r, c, 32);
|
||||||
}
|
}
|
||||||
|
|
||||||
/** secp256k1 curve order, see secp256k1_ecdsa_const_order_as_fe in ecdsa_impl.h */
|
/** secp256k1 curve order, see secp256k1_ecdsa_const_order_as_fe in ecdsa_impl.h */
|
||||||
static void secp256k1_scalar_order_get_num(secp256k1_num_t *r) {
|
static void secp256k1_scalar_order_get_num(secp256k1_num *r) {
|
||||||
static const unsigned char order[32] = {
|
static const unsigned char order[32] = {
|
||||||
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
||||||
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
|
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
|
||||||
|
@ -43,11 +43,11 @@ static void secp256k1_scalar_order_get_num(secp256k1_num_t *r) {
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
static void secp256k1_scalar_inverse(secp256k1_scalar_t *r, const secp256k1_scalar_t *x) {
|
static void secp256k1_scalar_inverse(secp256k1_scalar *r, const secp256k1_scalar *x) {
|
||||||
secp256k1_scalar_t *t;
|
secp256k1_scalar *t;
|
||||||
int i;
|
int i;
|
||||||
/* First compute x ^ (2^N - 1) for some values of N. */
|
/* First compute x ^ (2^N - 1) for some values of N. */
|
||||||
secp256k1_scalar_t x2, x3, x4, x6, x7, x8, x15, x30, x60, x120, x127;
|
secp256k1_scalar x2, x3, x4, x6, x7, x8, x15, x30, x60, x120, x127;
|
||||||
|
|
||||||
secp256k1_scalar_sqr(&x2, x);
|
secp256k1_scalar_sqr(&x2, x);
|
||||||
secp256k1_scalar_mul(&x2, &x2, x);
|
secp256k1_scalar_mul(&x2, &x2, x);
|
||||||
|
@ -234,18 +234,27 @@ static void secp256k1_scalar_inverse(secp256k1_scalar_t *r, const secp256k1_scal
|
||||||
secp256k1_scalar_mul(r, t, &x6); /* 111111 */
|
secp256k1_scalar_mul(r, t, &x6); /* 111111 */
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_scalar_inverse_var(secp256k1_scalar_t *r, const secp256k1_scalar_t *x) {
|
SECP256K1_INLINE static int secp256k1_scalar_is_even(const secp256k1_scalar *a) {
|
||||||
|
/* d[0] is present and is the lowest word for all representations */
|
||||||
|
return !(a->d[0] & 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void secp256k1_scalar_inverse_var(secp256k1_scalar *r, const secp256k1_scalar *x) {
|
||||||
#if defined(USE_SCALAR_INV_BUILTIN)
|
#if defined(USE_SCALAR_INV_BUILTIN)
|
||||||
secp256k1_scalar_inverse(r, x);
|
secp256k1_scalar_inverse(r, x);
|
||||||
#elif defined(USE_SCALAR_INV_NUM)
|
#elif defined(USE_SCALAR_INV_NUM)
|
||||||
unsigned char b[32];
|
unsigned char b[32];
|
||||||
secp256k1_num_t n, m;
|
secp256k1_num n, m;
|
||||||
secp256k1_scalar_get_b32(b, x);
|
secp256k1_scalar t = *x;
|
||||||
|
secp256k1_scalar_get_b32(b, &t);
|
||||||
secp256k1_num_set_bin(&n, b, 32);
|
secp256k1_num_set_bin(&n, b, 32);
|
||||||
secp256k1_scalar_order_get_num(&m);
|
secp256k1_scalar_order_get_num(&m);
|
||||||
secp256k1_num_mod_inverse(&n, &n, &m);
|
secp256k1_num_mod_inverse(&n, &n, &m);
|
||||||
secp256k1_num_get_bin(b, 32, &n);
|
secp256k1_num_get_bin(b, 32, &n);
|
||||||
secp256k1_scalar_set_b32(r, b, NULL);
|
secp256k1_scalar_set_b32(r, b, NULL);
|
||||||
|
/* Verify that the inverse was computed correctly, without GMP code. */
|
||||||
|
secp256k1_scalar_mul(&t, &t, r);
|
||||||
|
CHECK(secp256k1_scalar_is_one(&t));
|
||||||
#else
|
#else
|
||||||
#error "Please select scalar inverse implementation"
|
#error "Please select scalar inverse implementation"
|
||||||
#endif
|
#endif
|
||||||
|
@ -290,30 +299,31 @@ static void secp256k1_scalar_inverse_var(secp256k1_scalar_t *r, const secp256k1_
|
||||||
* The function below splits a in r1 and r2, such that r1 + lambda * r2 == a (mod order).
|
* The function below splits a in r1 and r2, such that r1 + lambda * r2 == a (mod order).
|
||||||
*/
|
*/
|
||||||
|
|
||||||
static void secp256k1_scalar_split_lambda_var(secp256k1_scalar_t *r1, secp256k1_scalar_t *r2, const secp256k1_scalar_t *a) {
|
static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
|
||||||
secp256k1_scalar_t c1, c2;
|
secp256k1_scalar c1, c2;
|
||||||
static const secp256k1_scalar_t minus_lambda = SECP256K1_SCALAR_CONST(
|
static const secp256k1_scalar minus_lambda = SECP256K1_SCALAR_CONST(
|
||||||
0xAC9C52B3UL, 0x3FA3CF1FUL, 0x5AD9E3FDUL, 0x77ED9BA4UL,
|
0xAC9C52B3UL, 0x3FA3CF1FUL, 0x5AD9E3FDUL, 0x77ED9BA4UL,
|
||||||
0xA880B9FCUL, 0x8EC739C2UL, 0xE0CFC810UL, 0xB51283CFUL
|
0xA880B9FCUL, 0x8EC739C2UL, 0xE0CFC810UL, 0xB51283CFUL
|
||||||
);
|
);
|
||||||
static const secp256k1_scalar_t minus_b1 = SECP256K1_SCALAR_CONST(
|
static const secp256k1_scalar minus_b1 = SECP256K1_SCALAR_CONST(
|
||||||
0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,
|
0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,
|
||||||
0xE4437ED6UL, 0x010E8828UL, 0x6F547FA9UL, 0x0ABFE4C3UL
|
0xE4437ED6UL, 0x010E8828UL, 0x6F547FA9UL, 0x0ABFE4C3UL
|
||||||
);
|
);
|
||||||
static const secp256k1_scalar_t minus_b2 = SECP256K1_SCALAR_CONST(
|
static const secp256k1_scalar minus_b2 = SECP256K1_SCALAR_CONST(
|
||||||
0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL,
|
0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL,
|
||||||
0x8A280AC5UL, 0x0774346DUL, 0xD765CDA8UL, 0x3DB1562CUL
|
0x8A280AC5UL, 0x0774346DUL, 0xD765CDA8UL, 0x3DB1562CUL
|
||||||
);
|
);
|
||||||
static const secp256k1_scalar_t g1 = SECP256K1_SCALAR_CONST(
|
static const secp256k1_scalar g1 = SECP256K1_SCALAR_CONST(
|
||||||
0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00003086UL,
|
0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00003086UL,
|
||||||
0xD221A7D4UL, 0x6BCDE86CUL, 0x90E49284UL, 0xEB153DABUL
|
0xD221A7D4UL, 0x6BCDE86CUL, 0x90E49284UL, 0xEB153DABUL
|
||||||
);
|
);
|
||||||
static const secp256k1_scalar_t g2 = SECP256K1_SCALAR_CONST(
|
static const secp256k1_scalar g2 = SECP256K1_SCALAR_CONST(
|
||||||
0x00000000UL, 0x00000000UL, 0x00000000UL, 0x0000E443UL,
|
0x00000000UL, 0x00000000UL, 0x00000000UL, 0x0000E443UL,
|
||||||
0x7ED6010EUL, 0x88286F54UL, 0x7FA90ABFUL, 0xE4C42212UL
|
0x7ED6010EUL, 0x88286F54UL, 0x7FA90ABFUL, 0xE4C42212UL
|
||||||
);
|
);
|
||||||
VERIFY_CHECK(r1 != a);
|
VERIFY_CHECK(r1 != a);
|
||||||
VERIFY_CHECK(r2 != a);
|
VERIFY_CHECK(r2 != a);
|
||||||
|
/* these _var calls are constant time since the shift amount is constant */
|
||||||
secp256k1_scalar_mul_shift_var(&c1, a, &g1, 272);
|
secp256k1_scalar_mul_shift_var(&c1, a, &g1, 272);
|
||||||
secp256k1_scalar_mul_shift_var(&c2, a, &g2, 272);
|
secp256k1_scalar_mul_shift_var(&c2, a, &g2, 272);
|
||||||
secp256k1_scalar_mul(&c1, &c1, &minus_b1);
|
secp256k1_scalar_mul(&c1, &c1, &minus_b1);
|
||||||
|
|
655
src/secp256k1.c
655
src/secp256k1.c
|
@ -14,81 +14,328 @@
|
||||||
#include "scalar_impl.h"
|
#include "scalar_impl.h"
|
||||||
#include "group_impl.h"
|
#include "group_impl.h"
|
||||||
#include "ecmult_impl.h"
|
#include "ecmult_impl.h"
|
||||||
|
#include "ecmult_const_impl.h"
|
||||||
#include "ecmult_gen_impl.h"
|
#include "ecmult_gen_impl.h"
|
||||||
#include "ecdsa_impl.h"
|
#include "ecdsa_impl.h"
|
||||||
#include "eckey_impl.h"
|
#include "eckey_impl.h"
|
||||||
#include "hash_impl.h"
|
#include "hash_impl.h"
|
||||||
|
|
||||||
struct secp256k1_context_struct {
|
#define ARG_CHECK(cond) do { \
|
||||||
secp256k1_ecmult_context_t ecmult_ctx;
|
if (EXPECT(!(cond), 0)) { \
|
||||||
secp256k1_ecmult_gen_context_t ecmult_gen_ctx;
|
secp256k1_callback_call(&ctx->illegal_callback, #cond); \
|
||||||
|
return 0; \
|
||||||
|
} \
|
||||||
|
} while(0)
|
||||||
|
|
||||||
|
static void default_illegal_callback_fn(const char* str, void* data) {
|
||||||
|
(void)data;
|
||||||
|
fprintf(stderr, "[libsecp256k1] illegal argument: %s\n", str);
|
||||||
|
abort();
|
||||||
|
}
|
||||||
|
|
||||||
|
static const secp256k1_callback default_illegal_callback = {
|
||||||
|
default_illegal_callback_fn,
|
||||||
|
NULL
|
||||||
};
|
};
|
||||||
|
|
||||||
secp256k1_context_t* secp256k1_context_create(int flags) {
|
static void default_error_callback_fn(const char* str, void* data) {
|
||||||
secp256k1_context_t* ret = (secp256k1_context_t*)checked_malloc(sizeof(secp256k1_context_t));
|
(void)data;
|
||||||
|
fprintf(stderr, "[libsecp256k1] internal consistency check failed: %s\n", str);
|
||||||
|
abort();
|
||||||
|
}
|
||||||
|
|
||||||
|
static const secp256k1_callback default_error_callback = {
|
||||||
|
default_error_callback_fn,
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
struct secp256k1_context_struct {
|
||||||
|
secp256k1_ecmult_context ecmult_ctx;
|
||||||
|
secp256k1_ecmult_gen_context ecmult_gen_ctx;
|
||||||
|
secp256k1_callback illegal_callback;
|
||||||
|
secp256k1_callback error_callback;
|
||||||
|
};
|
||||||
|
|
||||||
|
secp256k1_context* secp256k1_context_create(unsigned int flags) {
|
||||||
|
secp256k1_context* ret = (secp256k1_context*)checked_malloc(&default_error_callback, sizeof(secp256k1_context));
|
||||||
|
ret->illegal_callback = default_illegal_callback;
|
||||||
|
ret->error_callback = default_error_callback;
|
||||||
|
|
||||||
|
if (EXPECT((flags & SECP256K1_FLAGS_TYPE_MASK) != SECP256K1_FLAGS_TYPE_CONTEXT, 0)) {
|
||||||
|
secp256k1_callback_call(&ret->illegal_callback,
|
||||||
|
"Invalid flags");
|
||||||
|
free(ret);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
secp256k1_ecmult_context_init(&ret->ecmult_ctx);
|
secp256k1_ecmult_context_init(&ret->ecmult_ctx);
|
||||||
secp256k1_ecmult_gen_context_init(&ret->ecmult_gen_ctx);
|
secp256k1_ecmult_gen_context_init(&ret->ecmult_gen_ctx);
|
||||||
|
|
||||||
if (flags & SECP256K1_CONTEXT_SIGN) {
|
if (flags & SECP256K1_FLAGS_BIT_CONTEXT_SIGN) {
|
||||||
secp256k1_ecmult_gen_context_build(&ret->ecmult_gen_ctx);
|
secp256k1_ecmult_gen_context_build(&ret->ecmult_gen_ctx, &ret->error_callback);
|
||||||
}
|
}
|
||||||
if (flags & SECP256K1_CONTEXT_VERIFY) {
|
if (flags & SECP256K1_FLAGS_BIT_CONTEXT_VERIFY) {
|
||||||
secp256k1_ecmult_context_build(&ret->ecmult_ctx);
|
secp256k1_ecmult_context_build(&ret->ecmult_ctx, &ret->error_callback);
|
||||||
}
|
}
|
||||||
|
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
secp256k1_context_t* secp256k1_context_clone(const secp256k1_context_t* ctx) {
|
secp256k1_context* secp256k1_context_clone(const secp256k1_context* ctx) {
|
||||||
secp256k1_context_t* ret = (secp256k1_context_t*)checked_malloc(sizeof(secp256k1_context_t));
|
secp256k1_context* ret = (secp256k1_context*)checked_malloc(&ctx->error_callback, sizeof(secp256k1_context));
|
||||||
secp256k1_ecmult_context_clone(&ret->ecmult_ctx, &ctx->ecmult_ctx);
|
ret->illegal_callback = ctx->illegal_callback;
|
||||||
secp256k1_ecmult_gen_context_clone(&ret->ecmult_gen_ctx, &ctx->ecmult_gen_ctx);
|
ret->error_callback = ctx->error_callback;
|
||||||
|
secp256k1_ecmult_context_clone(&ret->ecmult_ctx, &ctx->ecmult_ctx, &ctx->error_callback);
|
||||||
|
secp256k1_ecmult_gen_context_clone(&ret->ecmult_gen_ctx, &ctx->ecmult_gen_ctx, &ctx->error_callback);
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
void secp256k1_context_destroy(secp256k1_context_t* ctx) {
|
void secp256k1_context_destroy(secp256k1_context* ctx) {
|
||||||
|
if (ctx != NULL) {
|
||||||
secp256k1_ecmult_context_clear(&ctx->ecmult_ctx);
|
secp256k1_ecmult_context_clear(&ctx->ecmult_ctx);
|
||||||
secp256k1_ecmult_gen_context_clear(&ctx->ecmult_gen_ctx);
|
secp256k1_ecmult_gen_context_clear(&ctx->ecmult_gen_ctx);
|
||||||
|
|
||||||
free(ctx);
|
free(ctx);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
int secp256k1_ecdsa_verify(const secp256k1_context_t* ctx, const unsigned char *msg32, const unsigned char *sig, int siglen, const unsigned char *pubkey, int pubkeylen) {
|
void secp256k1_context_set_illegal_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
|
||||||
secp256k1_ge_t q;
|
if (fun == NULL) {
|
||||||
secp256k1_ecdsa_sig_t s;
|
fun = default_illegal_callback_fn;
|
||||||
secp256k1_scalar_t m;
|
|
||||||
int ret = -3;
|
|
||||||
DEBUG_CHECK(ctx != NULL);
|
|
||||||
DEBUG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
|
|
||||||
DEBUG_CHECK(msg32 != NULL);
|
|
||||||
DEBUG_CHECK(sig != NULL);
|
|
||||||
DEBUG_CHECK(pubkey != NULL);
|
|
||||||
|
|
||||||
secp256k1_scalar_set_b32(&m, msg32, NULL);
|
|
||||||
|
|
||||||
if (secp256k1_eckey_pubkey_parse(&q, pubkey, pubkeylen)) {
|
|
||||||
if (secp256k1_ecdsa_sig_parse(&s, sig, siglen)) {
|
|
||||||
if (secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &s, &q, &m)) {
|
|
||||||
/* success is 1, all other values are fail */
|
|
||||||
ret = 1;
|
|
||||||
} else {
|
|
||||||
ret = 0;
|
|
||||||
}
|
}
|
||||||
} else {
|
ctx->illegal_callback.fn = fun;
|
||||||
ret = -2;
|
ctx->illegal_callback.data = data;
|
||||||
|
}
|
||||||
|
|
||||||
|
void secp256k1_context_set_error_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
|
||||||
|
if (fun == NULL) {
|
||||||
|
fun = default_error_callback_fn;
|
||||||
}
|
}
|
||||||
|
ctx->error_callback.fn = fun;
|
||||||
|
ctx->error_callback.data = data;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int secp256k1_pubkey_load(const secp256k1_context* ctx, secp256k1_ge* ge, const secp256k1_pubkey* pubkey) {
|
||||||
|
if (sizeof(secp256k1_ge_storage) == 64) {
|
||||||
|
/* When the secp256k1_ge_storage type is exactly 64 byte, use its
|
||||||
|
* representation inside secp256k1_pubkey, as conversion is very fast.
|
||||||
|
* Note that secp256k1_pubkey_save must use the same representation. */
|
||||||
|
secp256k1_ge_storage s;
|
||||||
|
memcpy(&s, &pubkey->data[0], 64);
|
||||||
|
secp256k1_ge_from_storage(ge, &s);
|
||||||
} else {
|
} else {
|
||||||
ret = -1;
|
/* Otherwise, fall back to 32-byte big endian for X and Y. */
|
||||||
|
secp256k1_fe x, y;
|
||||||
|
secp256k1_fe_set_b32(&x, pubkey->data);
|
||||||
|
secp256k1_fe_set_b32(&y, pubkey->data + 32);
|
||||||
|
secp256k1_ge_set_xy(ge, &x, &y);
|
||||||
|
}
|
||||||
|
ARG_CHECK(!secp256k1_fe_is_zero(&ge->x));
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void secp256k1_pubkey_save(secp256k1_pubkey* pubkey, secp256k1_ge* ge) {
|
||||||
|
if (sizeof(secp256k1_ge_storage) == 64) {
|
||||||
|
secp256k1_ge_storage s;
|
||||||
|
secp256k1_ge_to_storage(&s, ge);
|
||||||
|
memcpy(&pubkey->data[0], &s, 64);
|
||||||
|
} else {
|
||||||
|
VERIFY_CHECK(!secp256k1_ge_is_infinity(ge));
|
||||||
|
secp256k1_fe_normalize_var(&ge->x);
|
||||||
|
secp256k1_fe_normalize_var(&ge->y);
|
||||||
|
secp256k1_fe_get_b32(pubkey->data, &ge->x);
|
||||||
|
secp256k1_fe_get_b32(pubkey->data + 32, &ge->y);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_ec_pubkey_parse(const secp256k1_context* ctx, secp256k1_pubkey* pubkey, const unsigned char *input, size_t inputlen) {
|
||||||
|
secp256k1_ge Q;
|
||||||
|
|
||||||
|
(void)ctx;
|
||||||
|
VERIFY_CHECK(ctx != NULL);
|
||||||
|
ARG_CHECK(pubkey != NULL);
|
||||||
|
memset(pubkey, 0, sizeof(*pubkey));
|
||||||
|
ARG_CHECK(input != NULL);
|
||||||
|
if (!secp256k1_eckey_pubkey_parse(&Q, input, inputlen)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
secp256k1_pubkey_save(pubkey, &Q);
|
||||||
|
secp256k1_ge_clear(&Q);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_ec_pubkey_serialize(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_pubkey* pubkey, unsigned int flags) {
|
||||||
|
secp256k1_ge Q;
|
||||||
|
size_t len;
|
||||||
|
int ret = 0;
|
||||||
|
|
||||||
|
(void)ctx;
|
||||||
|
VERIFY_CHECK(ctx != NULL);
|
||||||
|
ARG_CHECK(outputlen != NULL);
|
||||||
|
ARG_CHECK(*outputlen >= ((flags & SECP256K1_FLAGS_BIT_COMPRESSION) ? 33 : 65));
|
||||||
|
len = *outputlen;
|
||||||
|
*outputlen = 0;
|
||||||
|
ARG_CHECK(output != NULL);
|
||||||
|
memset(output, 0, len);
|
||||||
|
ARG_CHECK(pubkey != NULL);
|
||||||
|
ARG_CHECK((flags & SECP256K1_FLAGS_TYPE_MASK) == SECP256K1_FLAGS_TYPE_COMPRESSION);
|
||||||
|
if (secp256k1_pubkey_load(ctx, &Q, pubkey)) {
|
||||||
|
ret = secp256k1_eckey_pubkey_serialize(&Q, output, &len, flags & SECP256K1_FLAGS_BIT_COMPRESSION);
|
||||||
|
if (ret) {
|
||||||
|
*outputlen = len;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void secp256k1_ecdsa_signature_load(const secp256k1_context* ctx, secp256k1_scalar* r, secp256k1_scalar* s, const secp256k1_ecdsa_signature* sig) {
|
||||||
|
(void)ctx;
|
||||||
|
if (sizeof(secp256k1_scalar) == 32) {
|
||||||
|
/* When the secp256k1_scalar type is exactly 32 byte, use its
|
||||||
|
* representation inside secp256k1_ecdsa_signature, as conversion is very fast.
|
||||||
|
* Note that secp256k1_ecdsa_signature_save must use the same representation. */
|
||||||
|
memcpy(r, &sig->data[0], 32);
|
||||||
|
memcpy(s, &sig->data[32], 32);
|
||||||
|
} else {
|
||||||
|
secp256k1_scalar_set_b32(r, &sig->data[0], NULL);
|
||||||
|
secp256k1_scalar_set_b32(s, &sig->data[32], NULL);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void secp256k1_ecdsa_signature_save(secp256k1_ecdsa_signature* sig, const secp256k1_scalar* r, const secp256k1_scalar* s) {
|
||||||
|
if (sizeof(secp256k1_scalar) == 32) {
|
||||||
|
memcpy(&sig->data[0], r, 32);
|
||||||
|
memcpy(&sig->data[32], s, 32);
|
||||||
|
} else {
|
||||||
|
secp256k1_scalar_get_b32(&sig->data[0], r);
|
||||||
|
secp256k1_scalar_get_b32(&sig->data[32], s);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_ecdsa_signature_parse_der(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
|
||||||
|
secp256k1_scalar r, s;
|
||||||
|
|
||||||
|
(void)ctx;
|
||||||
|
ARG_CHECK(sig != NULL);
|
||||||
|
ARG_CHECK(input != NULL);
|
||||||
|
|
||||||
|
if (secp256k1_ecdsa_sig_parse(&r, &s, input, inputlen)) {
|
||||||
|
secp256k1_ecdsa_signature_save(sig, &r, &s);
|
||||||
|
return 1;
|
||||||
|
} else {
|
||||||
|
memset(sig, 0, sizeof(*sig));
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_ecdsa_signature_parse_compact(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input64) {
|
||||||
|
secp256k1_scalar r, s;
|
||||||
|
int ret = 1;
|
||||||
|
int overflow = 0;
|
||||||
|
|
||||||
|
(void)ctx;
|
||||||
|
ARG_CHECK(sig != NULL);
|
||||||
|
ARG_CHECK(input64 != NULL);
|
||||||
|
|
||||||
|
secp256k1_scalar_set_b32(&r, &input64[0], &overflow);
|
||||||
|
ret &= !overflow;
|
||||||
|
secp256k1_scalar_set_b32(&s, &input64[32], &overflow);
|
||||||
|
ret &= !overflow;
|
||||||
|
if (ret) {
|
||||||
|
secp256k1_ecdsa_signature_save(sig, &r, &s);
|
||||||
|
} else {
|
||||||
|
memset(sig, 0, sizeof(*sig));
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_ecdsa_signature_serialize_der(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_ecdsa_signature* sig) {
|
||||||
|
secp256k1_scalar r, s;
|
||||||
|
|
||||||
|
(void)ctx;
|
||||||
|
ARG_CHECK(output != NULL);
|
||||||
|
ARG_CHECK(outputlen != NULL);
|
||||||
|
ARG_CHECK(sig != NULL);
|
||||||
|
|
||||||
|
secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
|
||||||
|
return secp256k1_ecdsa_sig_serialize(output, outputlen, &r, &s);
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_ecdsa_signature_serialize_compact(const secp256k1_context* ctx, unsigned char *output64, const secp256k1_ecdsa_signature* sig) {
|
||||||
|
secp256k1_scalar r, s;
|
||||||
|
|
||||||
|
(void)ctx;
|
||||||
|
ARG_CHECK(output64 != NULL);
|
||||||
|
ARG_CHECK(sig != NULL);
|
||||||
|
|
||||||
|
secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
|
||||||
|
secp256k1_scalar_get_b32(&output64[0], &r);
|
||||||
|
secp256k1_scalar_get_b32(&output64[32], &s);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
int secp256k1_ecdsa_signature_normalize(const secp256k1_context* ctx, secp256k1_ecdsa_signature *sigout, const secp256k1_ecdsa_signature *sigin) {
|
||||||
|
secp256k1_scalar r, s;
|
||||||
|
int ret = 0;
|
||||||
|
|
||||||
|
VERIFY_CHECK(ctx != NULL);
|
||||||
|
ARG_CHECK(sigin != NULL);
|
||||||
|
|
||||||
|
secp256k1_ecdsa_signature_load(ctx, &r, &s, sigin);
|
||||||
|
ret = secp256k1_scalar_is_high(&s);
|
||||||
|
if (sigout != NULL) {
|
||||||
|
if (ret) {
|
||||||
|
secp256k1_scalar_negate(&s, &s);
|
||||||
|
}
|
||||||
|
secp256k1_ecdsa_signature_save(sigout, &r, &s);
|
||||||
}
|
}
|
||||||
|
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int nonce_function_rfc6979(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, unsigned int counter, const void *data) {
|
int secp256k1_ecdsa_verify(const secp256k1_context* ctx, const secp256k1_ecdsa_signature *sig, const unsigned char *msg32, const secp256k1_pubkey *pubkey) {
|
||||||
|
secp256k1_ge q;
|
||||||
|
secp256k1_scalar r, s;
|
||||||
|
secp256k1_scalar m;
|
||||||
|
VERIFY_CHECK(ctx != NULL);
|
||||||
|
ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
|
||||||
|
ARG_CHECK(msg32 != NULL);
|
||||||
|
ARG_CHECK(sig != NULL);
|
||||||
|
ARG_CHECK(pubkey != NULL);
|
||||||
|
|
||||||
|
secp256k1_scalar_set_b32(&m, msg32, NULL);
|
||||||
|
secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
|
||||||
|
return (!secp256k1_scalar_is_high(&s) &&
|
||||||
|
secp256k1_pubkey_load(ctx, &q, pubkey) &&
|
||||||
|
secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &r, &s, &q, &m));
|
||||||
|
}
|
||||||
|
|
||||||
|
static int nonce_function_rfc6979(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
|
||||||
|
unsigned char keydata[112];
|
||||||
|
int keylen = 64;
|
||||||
secp256k1_rfc6979_hmac_sha256_t rng;
|
secp256k1_rfc6979_hmac_sha256_t rng;
|
||||||
unsigned int i;
|
unsigned int i;
|
||||||
secp256k1_rfc6979_hmac_sha256_initialize(&rng, key32, 32, msg32, 32, (const unsigned char*)data, data != NULL ? 32 : 0);
|
/* We feed a byte array to the PRNG as input, consisting of:
|
||||||
|
* - the private key (32 bytes) and message (32 bytes), see RFC 6979 3.2d.
|
||||||
|
* - optionally 32 extra bytes of data, see RFC 6979 3.6 Additional Data.
|
||||||
|
* - optionally 16 extra bytes with the algorithm name.
|
||||||
|
* Because the arguments have distinct fixed lengths it is not possible for
|
||||||
|
* different argument mixtures to emulate each other and result in the same
|
||||||
|
* nonces.
|
||||||
|
*/
|
||||||
|
memcpy(keydata, key32, 32);
|
||||||
|
memcpy(keydata + 32, msg32, 32);
|
||||||
|
if (data != NULL) {
|
||||||
|
memcpy(keydata + 64, data, 32);
|
||||||
|
keylen = 96;
|
||||||
|
}
|
||||||
|
if (algo16 != NULL) {
|
||||||
|
memcpy(keydata + keylen, algo16, 16);
|
||||||
|
keylen += 16;
|
||||||
|
}
|
||||||
|
secp256k1_rfc6979_hmac_sha256_initialize(&rng, keydata, keylen);
|
||||||
|
memset(keydata, 0, sizeof(keydata));
|
||||||
for (i = 0; i <= counter; i++) {
|
for (i = 0; i <= counter; i++) {
|
||||||
secp256k1_rfc6979_hmac_sha256_generate(&rng, nonce32, 32);
|
secp256k1_rfc6979_hmac_sha256_generate(&rng, nonce32, 32);
|
||||||
}
|
}
|
||||||
|
@ -96,21 +343,19 @@ static int nonce_function_rfc6979(unsigned char *nonce32, const unsigned char *m
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
const secp256k1_nonce_function_t secp256k1_nonce_function_rfc6979 = nonce_function_rfc6979;
|
const secp256k1_nonce_function secp256k1_nonce_function_rfc6979 = nonce_function_rfc6979;
|
||||||
const secp256k1_nonce_function_t secp256k1_nonce_function_default = nonce_function_rfc6979;
|
const secp256k1_nonce_function secp256k1_nonce_function_default = nonce_function_rfc6979;
|
||||||
|
|
||||||
int secp256k1_ecdsa_sign(const secp256k1_context_t* ctx, const unsigned char *msg32, unsigned char *signature, int *signaturelen, const unsigned char *seckey, secp256k1_nonce_function_t noncefp, const void* noncedata) {
|
int secp256k1_ecdsa_sign(const secp256k1_context* ctx, secp256k1_ecdsa_signature *signature, const unsigned char *msg32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void* noncedata) {
|
||||||
secp256k1_ecdsa_sig_t sig;
|
secp256k1_scalar r, s;
|
||||||
secp256k1_scalar_t sec, non, msg;
|
secp256k1_scalar sec, non, msg;
|
||||||
int ret = 0;
|
int ret = 0;
|
||||||
int overflow = 0;
|
int overflow = 0;
|
||||||
unsigned int count = 0;
|
VERIFY_CHECK(ctx != NULL);
|
||||||
DEBUG_CHECK(ctx != NULL);
|
ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
|
||||||
DEBUG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
|
ARG_CHECK(msg32 != NULL);
|
||||||
DEBUG_CHECK(msg32 != NULL);
|
ARG_CHECK(signature != NULL);
|
||||||
DEBUG_CHECK(signature != NULL);
|
ARG_CHECK(seckey != NULL);
|
||||||
DEBUG_CHECK(signaturelen != NULL);
|
|
||||||
DEBUG_CHECK(seckey != NULL);
|
|
||||||
if (noncefp == NULL) {
|
if (noncefp == NULL) {
|
||||||
noncefp = secp256k1_nonce_function_default;
|
noncefp = secp256k1_nonce_function_default;
|
||||||
}
|
}
|
||||||
|
@ -118,186 +363,87 @@ int secp256k1_ecdsa_sign(const secp256k1_context_t* ctx, const unsigned char *ms
|
||||||
secp256k1_scalar_set_b32(&sec, seckey, &overflow);
|
secp256k1_scalar_set_b32(&sec, seckey, &overflow);
|
||||||
/* Fail if the secret key is invalid. */
|
/* Fail if the secret key is invalid. */
|
||||||
if (!overflow && !secp256k1_scalar_is_zero(&sec)) {
|
if (!overflow && !secp256k1_scalar_is_zero(&sec)) {
|
||||||
secp256k1_scalar_set_b32(&msg, msg32, NULL);
|
|
||||||
while (1) {
|
|
||||||
unsigned char nonce32[32];
|
|
||||||
ret = noncefp(nonce32, msg32, seckey, count, noncedata);
|
|
||||||
if (!ret) {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
secp256k1_scalar_set_b32(&non, nonce32, &overflow);
|
|
||||||
memset(nonce32, 0, 32);
|
|
||||||
if (!secp256k1_scalar_is_zero(&non) && !overflow) {
|
|
||||||
if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &sig, &sec, &msg, &non, NULL)) {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
count++;
|
|
||||||
}
|
|
||||||
if (ret) {
|
|
||||||
ret = secp256k1_ecdsa_sig_serialize(signature, signaturelen, &sig);
|
|
||||||
}
|
|
||||||
secp256k1_scalar_clear(&msg);
|
|
||||||
secp256k1_scalar_clear(&non);
|
|
||||||
secp256k1_scalar_clear(&sec);
|
|
||||||
}
|
|
||||||
if (!ret) {
|
|
||||||
*signaturelen = 0;
|
|
||||||
}
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
int secp256k1_ecdsa_sign_compact(const secp256k1_context_t* ctx, const unsigned char *msg32, unsigned char *sig64, const unsigned char *seckey, secp256k1_nonce_function_t noncefp, const void* noncedata, int *recid) {
|
|
||||||
secp256k1_ecdsa_sig_t sig;
|
|
||||||
secp256k1_scalar_t sec, non, msg;
|
|
||||||
int ret = 0;
|
|
||||||
int overflow = 0;
|
|
||||||
unsigned int count = 0;
|
unsigned int count = 0;
|
||||||
DEBUG_CHECK(ctx != NULL);
|
|
||||||
DEBUG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
|
|
||||||
DEBUG_CHECK(msg32 != NULL);
|
|
||||||
DEBUG_CHECK(sig64 != NULL);
|
|
||||||
DEBUG_CHECK(seckey != NULL);
|
|
||||||
if (noncefp == NULL) {
|
|
||||||
noncefp = secp256k1_nonce_function_default;
|
|
||||||
}
|
|
||||||
|
|
||||||
secp256k1_scalar_set_b32(&sec, seckey, &overflow);
|
|
||||||
/* Fail if the secret key is invalid. */
|
|
||||||
if (!overflow && !secp256k1_scalar_is_zero(&sec)) {
|
|
||||||
secp256k1_scalar_set_b32(&msg, msg32, NULL);
|
secp256k1_scalar_set_b32(&msg, msg32, NULL);
|
||||||
while (1) {
|
while (1) {
|
||||||
unsigned char nonce32[32];
|
unsigned char nonce32[32];
|
||||||
ret = noncefp(nonce32, msg32, seckey, count, noncedata);
|
ret = noncefp(nonce32, msg32, seckey, NULL, (void*)noncedata, count);
|
||||||
if (!ret) {
|
if (!ret) {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
secp256k1_scalar_set_b32(&non, nonce32, &overflow);
|
secp256k1_scalar_set_b32(&non, nonce32, &overflow);
|
||||||
memset(nonce32, 0, 32);
|
memset(nonce32, 0, 32);
|
||||||
if (!secp256k1_scalar_is_zero(&non) && !overflow) {
|
if (!overflow && !secp256k1_scalar_is_zero(&non)) {
|
||||||
if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &sig, &sec, &msg, &non, recid)) {
|
if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &r, &s, &sec, &msg, &non, NULL)) {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
count++;
|
count++;
|
||||||
}
|
}
|
||||||
if (ret) {
|
|
||||||
secp256k1_scalar_get_b32(sig64, &sig.r);
|
|
||||||
secp256k1_scalar_get_b32(sig64 + 32, &sig.s);
|
|
||||||
}
|
|
||||||
secp256k1_scalar_clear(&msg);
|
secp256k1_scalar_clear(&msg);
|
||||||
secp256k1_scalar_clear(&non);
|
secp256k1_scalar_clear(&non);
|
||||||
secp256k1_scalar_clear(&sec);
|
secp256k1_scalar_clear(&sec);
|
||||||
}
|
}
|
||||||
if (!ret) {
|
if (ret) {
|
||||||
memset(sig64, 0, 64);
|
secp256k1_ecdsa_signature_save(signature, &r, &s);
|
||||||
|
} else {
|
||||||
|
memset(signature, 0, sizeof(*signature));
|
||||||
}
|
}
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
int secp256k1_ecdsa_recover_compact(const secp256k1_context_t* ctx, const unsigned char *msg32, const unsigned char *sig64, unsigned char *pubkey, int *pubkeylen, int compressed, int recid) {
|
int secp256k1_ec_seckey_verify(const secp256k1_context* ctx, const unsigned char *seckey) {
|
||||||
secp256k1_ge_t q;
|
secp256k1_scalar sec;
|
||||||
secp256k1_ecdsa_sig_t sig;
|
|
||||||
secp256k1_scalar_t m;
|
|
||||||
int ret = 0;
|
|
||||||
int overflow = 0;
|
|
||||||
DEBUG_CHECK(ctx != NULL);
|
|
||||||
DEBUG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
|
|
||||||
DEBUG_CHECK(msg32 != NULL);
|
|
||||||
DEBUG_CHECK(sig64 != NULL);
|
|
||||||
DEBUG_CHECK(pubkey != NULL);
|
|
||||||
DEBUG_CHECK(pubkeylen != NULL);
|
|
||||||
DEBUG_CHECK(recid >= 0 && recid <= 3);
|
|
||||||
|
|
||||||
secp256k1_scalar_set_b32(&sig.r, sig64, &overflow);
|
|
||||||
if (!overflow) {
|
|
||||||
secp256k1_scalar_set_b32(&sig.s, sig64 + 32, &overflow);
|
|
||||||
if (!overflow) {
|
|
||||||
secp256k1_scalar_set_b32(&m, msg32, NULL);
|
|
||||||
|
|
||||||
if (secp256k1_ecdsa_sig_recover(&ctx->ecmult_ctx, &sig, &q, &m, recid)) {
|
|
||||||
ret = secp256k1_eckey_pubkey_serialize(&q, pubkey, pubkeylen, compressed);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
int secp256k1_ec_seckey_verify(const secp256k1_context_t* ctx, const unsigned char *seckey) {
|
|
||||||
secp256k1_scalar_t sec;
|
|
||||||
int ret;
|
int ret;
|
||||||
int overflow;
|
int overflow;
|
||||||
DEBUG_CHECK(ctx != NULL);
|
VERIFY_CHECK(ctx != NULL);
|
||||||
DEBUG_CHECK(seckey != NULL);
|
ARG_CHECK(seckey != NULL);
|
||||||
(void)ctx;
|
(void)ctx;
|
||||||
|
|
||||||
secp256k1_scalar_set_b32(&sec, seckey, &overflow);
|
secp256k1_scalar_set_b32(&sec, seckey, &overflow);
|
||||||
ret = !secp256k1_scalar_is_zero(&sec) && !overflow;
|
ret = !overflow && !secp256k1_scalar_is_zero(&sec);
|
||||||
secp256k1_scalar_clear(&sec);
|
secp256k1_scalar_clear(&sec);
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
int secp256k1_ec_pubkey_verify(const secp256k1_context_t* ctx, const unsigned char *pubkey, int pubkeylen) {
|
int secp256k1_ec_pubkey_create(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *seckey) {
|
||||||
secp256k1_ge_t q;
|
secp256k1_gej pj;
|
||||||
DEBUG_CHECK(ctx != NULL);
|
secp256k1_ge p;
|
||||||
DEBUG_CHECK(pubkey != NULL);
|
secp256k1_scalar sec;
|
||||||
(void)ctx;
|
|
||||||
|
|
||||||
return secp256k1_eckey_pubkey_parse(&q, pubkey, pubkeylen);
|
|
||||||
}
|
|
||||||
|
|
||||||
int secp256k1_ec_pubkey_create(const secp256k1_context_t* ctx, unsigned char *pubkey, int *pubkeylen, const unsigned char *seckey, int compressed) {
|
|
||||||
secp256k1_gej_t pj;
|
|
||||||
secp256k1_ge_t p;
|
|
||||||
secp256k1_scalar_t sec;
|
|
||||||
int overflow;
|
int overflow;
|
||||||
int ret = 0;
|
int ret = 0;
|
||||||
DEBUG_CHECK(ctx != NULL);
|
VERIFY_CHECK(ctx != NULL);
|
||||||
DEBUG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
|
ARG_CHECK(pubkey != NULL);
|
||||||
DEBUG_CHECK(pubkey != NULL);
|
memset(pubkey, 0, sizeof(*pubkey));
|
||||||
DEBUG_CHECK(pubkeylen != NULL);
|
ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
|
||||||
DEBUG_CHECK(seckey != NULL);
|
ARG_CHECK(seckey != NULL);
|
||||||
|
|
||||||
secp256k1_scalar_set_b32(&sec, seckey, &overflow);
|
secp256k1_scalar_set_b32(&sec, seckey, &overflow);
|
||||||
if (!overflow) {
|
ret = (!overflow) & (!secp256k1_scalar_is_zero(&sec));
|
||||||
|
if (ret) {
|
||||||
secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pj, &sec);
|
secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pj, &sec);
|
||||||
secp256k1_scalar_clear(&sec);
|
|
||||||
secp256k1_ge_set_gej(&p, &pj);
|
secp256k1_ge_set_gej(&p, &pj);
|
||||||
ret = secp256k1_eckey_pubkey_serialize(&p, pubkey, pubkeylen, compressed);
|
secp256k1_pubkey_save(pubkey, &p);
|
||||||
}
|
|
||||||
if (!ret) {
|
|
||||||
*pubkeylen = 0;
|
|
||||||
}
|
}
|
||||||
|
secp256k1_scalar_clear(&sec);
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
int secp256k1_ec_pubkey_decompress(const secp256k1_context_t* ctx, unsigned char *pubkey, int *pubkeylen) {
|
int secp256k1_ec_privkey_tweak_add(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) {
|
||||||
secp256k1_ge_t p;
|
secp256k1_scalar term;
|
||||||
int ret = 0;
|
secp256k1_scalar sec;
|
||||||
DEBUG_CHECK(pubkey != NULL);
|
|
||||||
DEBUG_CHECK(pubkeylen != NULL);
|
|
||||||
(void)ctx;
|
|
||||||
|
|
||||||
if (secp256k1_eckey_pubkey_parse(&p, pubkey, *pubkeylen)) {
|
|
||||||
ret = secp256k1_eckey_pubkey_serialize(&p, pubkey, pubkeylen, 0);
|
|
||||||
}
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
int secp256k1_ec_privkey_tweak_add(const secp256k1_context_t* ctx, unsigned char *seckey, const unsigned char *tweak) {
|
|
||||||
secp256k1_scalar_t term;
|
|
||||||
secp256k1_scalar_t sec;
|
|
||||||
int ret = 0;
|
int ret = 0;
|
||||||
int overflow = 0;
|
int overflow = 0;
|
||||||
DEBUG_CHECK(ctx != NULL);
|
VERIFY_CHECK(ctx != NULL);
|
||||||
DEBUG_CHECK(seckey != NULL);
|
ARG_CHECK(seckey != NULL);
|
||||||
DEBUG_CHECK(tweak != NULL);
|
ARG_CHECK(tweak != NULL);
|
||||||
(void)ctx;
|
(void)ctx;
|
||||||
|
|
||||||
secp256k1_scalar_set_b32(&term, tweak, &overflow);
|
secp256k1_scalar_set_b32(&term, tweak, &overflow);
|
||||||
secp256k1_scalar_set_b32(&sec, seckey, NULL);
|
secp256k1_scalar_set_b32(&sec, seckey, NULL);
|
||||||
|
|
||||||
ret = secp256k1_eckey_privkey_tweak_add(&sec, &term) && !overflow;
|
ret = !overflow && secp256k1_eckey_privkey_tweak_add(&sec, &term);
|
||||||
|
memset(seckey, 0, 32);
|
||||||
if (ret) {
|
if (ret) {
|
||||||
secp256k1_scalar_get_b32(seckey, &sec);
|
secp256k1_scalar_get_b32(seckey, &sec);
|
||||||
}
|
}
|
||||||
|
@ -307,45 +453,44 @@ int secp256k1_ec_privkey_tweak_add(const secp256k1_context_t* ctx, unsigned char
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
int secp256k1_ec_pubkey_tweak_add(const secp256k1_context_t* ctx, unsigned char *pubkey, int pubkeylen, const unsigned char *tweak) {
|
int secp256k1_ec_pubkey_tweak_add(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak) {
|
||||||
secp256k1_ge_t p;
|
secp256k1_ge p;
|
||||||
secp256k1_scalar_t term;
|
secp256k1_scalar term;
|
||||||
int ret = 0;
|
int ret = 0;
|
||||||
int overflow = 0;
|
int overflow = 0;
|
||||||
DEBUG_CHECK(ctx != NULL);
|
VERIFY_CHECK(ctx != NULL);
|
||||||
DEBUG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
|
ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
|
||||||
DEBUG_CHECK(pubkey != NULL);
|
ARG_CHECK(pubkey != NULL);
|
||||||
DEBUG_CHECK(tweak != NULL);
|
ARG_CHECK(tweak != NULL);
|
||||||
|
|
||||||
secp256k1_scalar_set_b32(&term, tweak, &overflow);
|
secp256k1_scalar_set_b32(&term, tweak, &overflow);
|
||||||
if (!overflow) {
|
ret = !overflow && secp256k1_pubkey_load(ctx, &p, pubkey);
|
||||||
ret = secp256k1_eckey_pubkey_parse(&p, pubkey, pubkeylen);
|
memset(pubkey, 0, sizeof(*pubkey));
|
||||||
if (ret) {
|
if (ret) {
|
||||||
ret = secp256k1_eckey_pubkey_tweak_add(&ctx->ecmult_ctx, &p, &term);
|
if (secp256k1_eckey_pubkey_tweak_add(&ctx->ecmult_ctx, &p, &term)) {
|
||||||
}
|
secp256k1_pubkey_save(pubkey, &p);
|
||||||
if (ret) {
|
} else {
|
||||||
int oldlen = pubkeylen;
|
ret = 0;
|
||||||
ret = secp256k1_eckey_pubkey_serialize(&p, pubkey, &pubkeylen, oldlen <= 33);
|
|
||||||
VERIFY_CHECK(pubkeylen == oldlen);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
int secp256k1_ec_privkey_tweak_mul(const secp256k1_context_t* ctx, unsigned char *seckey, const unsigned char *tweak) {
|
int secp256k1_ec_privkey_tweak_mul(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) {
|
||||||
secp256k1_scalar_t factor;
|
secp256k1_scalar factor;
|
||||||
secp256k1_scalar_t sec;
|
secp256k1_scalar sec;
|
||||||
int ret = 0;
|
int ret = 0;
|
||||||
int overflow = 0;
|
int overflow = 0;
|
||||||
DEBUG_CHECK(ctx != NULL);
|
VERIFY_CHECK(ctx != NULL);
|
||||||
DEBUG_CHECK(seckey != NULL);
|
ARG_CHECK(seckey != NULL);
|
||||||
DEBUG_CHECK(tweak != NULL);
|
ARG_CHECK(tweak != NULL);
|
||||||
(void)ctx;
|
(void)ctx;
|
||||||
|
|
||||||
secp256k1_scalar_set_b32(&factor, tweak, &overflow);
|
secp256k1_scalar_set_b32(&factor, tweak, &overflow);
|
||||||
secp256k1_scalar_set_b32(&sec, seckey, NULL);
|
secp256k1_scalar_set_b32(&sec, seckey, NULL);
|
||||||
ret = secp256k1_eckey_privkey_tweak_mul(&sec, &factor) && !overflow;
|
ret = !overflow && secp256k1_eckey_privkey_tweak_mul(&sec, &factor);
|
||||||
|
memset(seckey, 0, 32);
|
||||||
if (ret) {
|
if (ret) {
|
||||||
secp256k1_scalar_get_b32(seckey, &sec);
|
secp256k1_scalar_get_b32(seckey, &sec);
|
||||||
}
|
}
|
||||||
|
@ -355,65 +500,69 @@ int secp256k1_ec_privkey_tweak_mul(const secp256k1_context_t* ctx, unsigned char
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
int secp256k1_ec_pubkey_tweak_mul(const secp256k1_context_t* ctx, unsigned char *pubkey, int pubkeylen, const unsigned char *tweak) {
|
int secp256k1_ec_pubkey_tweak_mul(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak) {
|
||||||
secp256k1_ge_t p;
|
secp256k1_ge p;
|
||||||
secp256k1_scalar_t factor;
|
secp256k1_scalar factor;
|
||||||
int ret = 0;
|
int ret = 0;
|
||||||
int overflow = 0;
|
int overflow = 0;
|
||||||
DEBUG_CHECK(ctx != NULL);
|
VERIFY_CHECK(ctx != NULL);
|
||||||
DEBUG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
|
ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
|
||||||
DEBUG_CHECK(pubkey != NULL);
|
ARG_CHECK(pubkey != NULL);
|
||||||
DEBUG_CHECK(tweak != NULL);
|
ARG_CHECK(tweak != NULL);
|
||||||
|
|
||||||
secp256k1_scalar_set_b32(&factor, tweak, &overflow);
|
secp256k1_scalar_set_b32(&factor, tweak, &overflow);
|
||||||
if (!overflow) {
|
ret = !overflow && secp256k1_pubkey_load(ctx, &p, pubkey);
|
||||||
ret = secp256k1_eckey_pubkey_parse(&p, pubkey, pubkeylen);
|
memset(pubkey, 0, sizeof(*pubkey));
|
||||||
if (ret) {
|
if (ret) {
|
||||||
ret = secp256k1_eckey_pubkey_tweak_mul(&ctx->ecmult_ctx, &p, &factor);
|
if (secp256k1_eckey_pubkey_tweak_mul(&ctx->ecmult_ctx, &p, &factor)) {
|
||||||
}
|
secp256k1_pubkey_save(pubkey, &p);
|
||||||
if (ret) {
|
} else {
|
||||||
int oldlen = pubkeylen;
|
ret = 0;
|
||||||
ret = secp256k1_eckey_pubkey_serialize(&p, pubkey, &pubkeylen, oldlen <= 33);
|
|
||||||
VERIFY_CHECK(pubkeylen == oldlen);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
int secp256k1_ec_privkey_export(const secp256k1_context_t* ctx, const unsigned char *seckey, unsigned char *privkey, int *privkeylen, int compressed) {
|
int secp256k1_context_randomize(secp256k1_context* ctx, const unsigned char *seed32) {
|
||||||
secp256k1_scalar_t key;
|
VERIFY_CHECK(ctx != NULL);
|
||||||
int ret = 0;
|
ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
|
||||||
DEBUG_CHECK(seckey != NULL);
|
|
||||||
DEBUG_CHECK(privkey != NULL);
|
|
||||||
DEBUG_CHECK(privkeylen != NULL);
|
|
||||||
DEBUG_CHECK(ctx != NULL);
|
|
||||||
DEBUG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
|
|
||||||
|
|
||||||
secp256k1_scalar_set_b32(&key, seckey, NULL);
|
|
||||||
ret = secp256k1_eckey_privkey_serialize(&ctx->ecmult_gen_ctx, privkey, privkeylen, &key, compressed);
|
|
||||||
secp256k1_scalar_clear(&key);
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
int secp256k1_ec_privkey_import(const secp256k1_context_t* ctx, unsigned char *seckey, const unsigned char *privkey, int privkeylen) {
|
|
||||||
secp256k1_scalar_t key;
|
|
||||||
int ret = 0;
|
|
||||||
DEBUG_CHECK(seckey != NULL);
|
|
||||||
DEBUG_CHECK(privkey != NULL);
|
|
||||||
(void)ctx;
|
|
||||||
|
|
||||||
ret = secp256k1_eckey_privkey_parse(&key, privkey, privkeylen);
|
|
||||||
if (ret) {
|
|
||||||
secp256k1_scalar_get_b32(seckey, &key);
|
|
||||||
}
|
|
||||||
secp256k1_scalar_clear(&key);
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
int secp256k1_context_randomize(secp256k1_context_t* ctx, const unsigned char *seed32) {
|
|
||||||
DEBUG_CHECK(ctx != NULL);
|
|
||||||
DEBUG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
|
|
||||||
secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, seed32);
|
secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, seed32);
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
int secp256k1_ec_pubkey_combine(const secp256k1_context* ctx, secp256k1_pubkey *pubnonce, const secp256k1_pubkey * const *pubnonces, size_t n) {
|
||||||
|
size_t i;
|
||||||
|
secp256k1_gej Qj;
|
||||||
|
secp256k1_ge Q;
|
||||||
|
|
||||||
|
ARG_CHECK(pubnonce != NULL);
|
||||||
|
memset(pubnonce, 0, sizeof(*pubnonce));
|
||||||
|
ARG_CHECK(n >= 1);
|
||||||
|
ARG_CHECK(pubnonces != NULL);
|
||||||
|
|
||||||
|
secp256k1_gej_set_infinity(&Qj);
|
||||||
|
|
||||||
|
for (i = 0; i < n; i++) {
|
||||||
|
secp256k1_pubkey_load(ctx, &Q, pubnonces[i]);
|
||||||
|
secp256k1_gej_add_ge(&Qj, &Qj, &Q);
|
||||||
|
}
|
||||||
|
if (secp256k1_gej_is_infinity(&Qj)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
secp256k1_ge_set_gej(&Q, &Qj);
|
||||||
|
secp256k1_pubkey_save(pubnonce, &Q);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef ENABLE_MODULE_ECDH
|
||||||
|
# include "modules/ecdh/main_impl.h"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef ENABLE_MODULE_SCHNORR
|
||||||
|
# include "modules/schnorr/main_impl.h"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef ENABLE_MODULE_RECOVERY
|
||||||
|
# include "modules/recovery/main_impl.h"
|
||||||
|
#endif
|
||||||
|
|
|
@ -16,13 +16,23 @@
|
||||||
/** Seed the pseudorandom number generator for testing. */
|
/** Seed the pseudorandom number generator for testing. */
|
||||||
SECP256K1_INLINE static void secp256k1_rand_seed(const unsigned char *seed16);
|
SECP256K1_INLINE static void secp256k1_rand_seed(const unsigned char *seed16);
|
||||||
|
|
||||||
/** Generate a pseudorandom 32-bit number. */
|
/** Generate a pseudorandom number in the range [0..2**32-1]. */
|
||||||
static uint32_t secp256k1_rand32(void);
|
static uint32_t secp256k1_rand32(void);
|
||||||
|
|
||||||
|
/** Generate a pseudorandom number in the range [0..2**bits-1]. Bits must be 1 or
|
||||||
|
* more. */
|
||||||
|
static uint32_t secp256k1_rand_bits(int bits);
|
||||||
|
|
||||||
|
/** Generate a pseudorandom number in the range [0..range-1]. */
|
||||||
|
static uint32_t secp256k1_rand_int(uint32_t range);
|
||||||
|
|
||||||
/** Generate a pseudorandom 32-byte array. */
|
/** Generate a pseudorandom 32-byte array. */
|
||||||
static void secp256k1_rand256(unsigned char *b32);
|
static void secp256k1_rand256(unsigned char *b32);
|
||||||
|
|
||||||
/** Generate a pseudorandom 32-byte array with long sequences of zero and one bits. */
|
/** Generate a pseudorandom 32-byte array with long sequences of zero and one bits. */
|
||||||
static void secp256k1_rand256_test(unsigned char *b32);
|
static void secp256k1_rand256_test(unsigned char *b32);
|
||||||
|
|
||||||
|
/** Generate pseudorandom bytes with long sequences of zero and one bits. */
|
||||||
|
static void secp256k1_rand_bytes_test(unsigned char *bytes, size_t len);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
/**********************************************************************
|
/**********************************************************************
|
||||||
* Copyright (c) 2013, 2014 Pieter Wuille *
|
* Copyright (c) 2013-2015 Pieter Wuille *
|
||||||
* Distributed under the MIT software license, see the accompanying *
|
* Distributed under the MIT software license, see the accompanying *
|
||||||
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
|
||||||
**********************************************************************/
|
**********************************************************************/
|
||||||
|
@ -16,9 +16,11 @@
|
||||||
static secp256k1_rfc6979_hmac_sha256_t secp256k1_test_rng;
|
static secp256k1_rfc6979_hmac_sha256_t secp256k1_test_rng;
|
||||||
static uint32_t secp256k1_test_rng_precomputed[8];
|
static uint32_t secp256k1_test_rng_precomputed[8];
|
||||||
static int secp256k1_test_rng_precomputed_used = 8;
|
static int secp256k1_test_rng_precomputed_used = 8;
|
||||||
|
static uint64_t secp256k1_test_rng_integer;
|
||||||
|
static int secp256k1_test_rng_integer_bits_left = 0;
|
||||||
|
|
||||||
SECP256K1_INLINE static void secp256k1_rand_seed(const unsigned char *seed16) {
|
SECP256K1_INLINE static void secp256k1_rand_seed(const unsigned char *seed16) {
|
||||||
secp256k1_rfc6979_hmac_sha256_initialize(&secp256k1_test_rng, (const unsigned char*)"TestRNG", 7, seed16, 16, NULL, 0);
|
secp256k1_rfc6979_hmac_sha256_initialize(&secp256k1_test_rng, seed16, 16);
|
||||||
}
|
}
|
||||||
|
|
||||||
SECP256K1_INLINE static uint32_t secp256k1_rand32(void) {
|
SECP256K1_INLINE static uint32_t secp256k1_rand32(void) {
|
||||||
|
@ -29,32 +31,80 @@ SECP256K1_INLINE static uint32_t secp256k1_rand32(void) {
|
||||||
return secp256k1_test_rng_precomputed[secp256k1_test_rng_precomputed_used++];
|
return secp256k1_test_rng_precomputed[secp256k1_test_rng_precomputed_used++];
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static uint32_t secp256k1_rand_bits(int bits) {
|
||||||
|
uint32_t ret;
|
||||||
|
if (secp256k1_test_rng_integer_bits_left < bits) {
|
||||||
|
secp256k1_test_rng_integer |= (((uint64_t)secp256k1_rand32()) << secp256k1_test_rng_integer_bits_left);
|
||||||
|
secp256k1_test_rng_integer_bits_left += 32;
|
||||||
|
}
|
||||||
|
ret = secp256k1_test_rng_integer;
|
||||||
|
secp256k1_test_rng_integer >>= bits;
|
||||||
|
secp256k1_test_rng_integer_bits_left -= bits;
|
||||||
|
ret &= ((~((uint32_t)0)) >> (32 - bits));
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
static uint32_t secp256k1_rand_int(uint32_t range) {
|
||||||
|
/* We want a uniform integer between 0 and range-1, inclusive.
|
||||||
|
* B is the smallest number such that range <= 2**B.
|
||||||
|
* two mechanisms implemented here:
|
||||||
|
* - generate B bits numbers until one below range is found, and return it
|
||||||
|
* - find the largest multiple M of range that is <= 2**(B+A), generate B+A
|
||||||
|
* bits numbers until one below M is found, and return it modulo range
|
||||||
|
* The second mechanism consumes A more bits of entropy in every iteration,
|
||||||
|
* but may need fewer iterations due to M being closer to 2**(B+A) then
|
||||||
|
* range is to 2**B. The array below (indexed by B) contains a 0 when the
|
||||||
|
* first mechanism is to be used, and the number A otherwise.
|
||||||
|
*/
|
||||||
|
static const int addbits[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0};
|
||||||
|
uint32_t trange, mult;
|
||||||
|
int bits = 0;
|
||||||
|
if (range <= 1) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
trange = range - 1;
|
||||||
|
while (trange > 0) {
|
||||||
|
trange >>= 1;
|
||||||
|
bits++;
|
||||||
|
}
|
||||||
|
if (addbits[bits]) {
|
||||||
|
bits = bits + addbits[bits];
|
||||||
|
mult = ((~((uint32_t)0)) >> (32 - bits)) / range;
|
||||||
|
trange = range * mult;
|
||||||
|
} else {
|
||||||
|
trange = range;
|
||||||
|
mult = 1;
|
||||||
|
}
|
||||||
|
while(1) {
|
||||||
|
uint32_t x = secp256k1_rand_bits(bits);
|
||||||
|
if (x < trange) {
|
||||||
|
return (mult == 1) ? x : (x % range);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
static void secp256k1_rand256(unsigned char *b32) {
|
static void secp256k1_rand256(unsigned char *b32) {
|
||||||
secp256k1_rfc6979_hmac_sha256_generate(&secp256k1_test_rng, b32, 32);
|
secp256k1_rfc6979_hmac_sha256_generate(&secp256k1_test_rng, b32, 32);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void secp256k1_rand256_test(unsigned char *b32) {
|
static void secp256k1_rand_bytes_test(unsigned char *bytes, size_t len) {
|
||||||
int bits=0;
|
size_t bits = 0;
|
||||||
uint64_t ent = 0;
|
memset(bytes, 0, len);
|
||||||
int entleft = 0;
|
while (bits < len * 8) {
|
||||||
memset(b32, 0, 32);
|
|
||||||
while (bits < 256) {
|
|
||||||
int now;
|
int now;
|
||||||
uint32_t val;
|
uint32_t val;
|
||||||
if (entleft < 12) {
|
now = 1 + (secp256k1_rand_bits(6) * secp256k1_rand_bits(5) + 16) / 31;
|
||||||
ent |= ((uint64_t)secp256k1_rand32()) << entleft;
|
val = secp256k1_rand_bits(1);
|
||||||
entleft += 32;
|
while (now > 0 && bits < len * 8) {
|
||||||
}
|
bytes[bits / 8] |= val << (bits % 8);
|
||||||
now = 1 + ((ent % 64)*((ent >> 6) % 32)+16)/31;
|
|
||||||
val = 1 & (ent >> 11);
|
|
||||||
ent >>= 12;
|
|
||||||
entleft -= 12;
|
|
||||||
while (now > 0 && bits < 256) {
|
|
||||||
b32[bits / 8] |= val << (bits % 8);
|
|
||||||
now--;
|
now--;
|
||||||
bits++;
|
bits++;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static void secp256k1_rand256_test(unsigned char *b32) {
|
||||||
|
secp256k1_rand_bytes_test(b32, 32);
|
||||||
|
}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
3410
src/tests.c
3410
src/tests.c
File diff suppressed because it is too large
Load Diff
26
src/util.h
26
src/util.h
|
@ -15,6 +15,15 @@
|
||||||
#include <stdint.h>
|
#include <stdint.h>
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
|
|
||||||
|
typedef struct {
|
||||||
|
void (*fn)(const char *text, void* data);
|
||||||
|
const void* data;
|
||||||
|
} secp256k1_callback;
|
||||||
|
|
||||||
|
static SECP256K1_INLINE void secp256k1_callback_call(const secp256k1_callback * const cb, const char * const text) {
|
||||||
|
cb->fn(text, (void*)cb->data);
|
||||||
|
}
|
||||||
|
|
||||||
#ifdef DETERMINISTIC
|
#ifdef DETERMINISTIC
|
||||||
#define TEST_FAILURE(msg) do { \
|
#define TEST_FAILURE(msg) do { \
|
||||||
fprintf(stderr, "%s\n", msg); \
|
fprintf(stderr, "%s\n", msg); \
|
||||||
|
@ -47,23 +56,20 @@
|
||||||
} while(0)
|
} while(0)
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* Like assert(), but safe to use on expressions with side effects. */
|
/* Like assert(), but when VERIFY is defined, and side-effect safe. */
|
||||||
#ifndef NDEBUG
|
|
||||||
#define DEBUG_CHECK CHECK
|
|
||||||
#else
|
|
||||||
#define DEBUG_CHECK(cond) do { (void)(cond); } while(0)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Like DEBUG_CHECK(), but when VERIFY is defined instead of NDEBUG not defined. */
|
|
||||||
#ifdef VERIFY
|
#ifdef VERIFY
|
||||||
#define VERIFY_CHECK CHECK
|
#define VERIFY_CHECK CHECK
|
||||||
|
#define VERIFY_SETUP(stmt) do { stmt; } while(0)
|
||||||
#else
|
#else
|
||||||
#define VERIFY_CHECK(cond) do { (void)(cond); } while(0)
|
#define VERIFY_CHECK(cond) do { (void)(cond); } while(0)
|
||||||
|
#define VERIFY_SETUP(stmt)
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
static SECP256K1_INLINE void *checked_malloc(size_t size) {
|
static SECP256K1_INLINE void *checked_malloc(const secp256k1_callback* cb, size_t size) {
|
||||||
void *ret = malloc(size);
|
void *ret = malloc(size);
|
||||||
CHECK(ret != NULL);
|
if (ret == NULL) {
|
||||||
|
secp256k1_callback_call(cb, "Out of memory");
|
||||||
|
}
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
Loading…
Reference in New Issue