@onekeyfe/react-native-lite-card 6.7.0-20 → 6.7.0-22
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +9 -1
- package/ReactNativeLiteCard.podspec +25 -2
- package/android/build.gradle +7 -0
- package/android/src/main/cpp/CMakeLists.txt +6 -2
- package/android/src/main/java/com/onekeyfe/reactnativelitecard/ReactNativeLiteCardModule.kt +29 -11
- package/android/src/main/java/com/onekeyfe/reactnativelitecard/nfc/gpchannel/GPChannelNatives.kt +7 -7
- package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/OnekeyLiteCard.kt +14 -3
- package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/entitys/SendResponse.kt +6 -3
- package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/nfc/CommandGenerator.kt +5 -1
- package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/nfc/Connection.kt +36 -17
- package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/nfc/GPCAPDUGenerator.kt +2 -2
- package/ios/Classes/OKLiteCommand/OKLiteCommandTool.m +4 -1
- package/ios/Classes/OKNFCBridge.mm +1 -1
- package/ios/Classes/OKNFTLite/OKLiteV1.m +6 -3
- package/ios/Classes/OKNFTLite/OKLiteV2.m +13 -5
- package/ios/Classes/OKNFTLite/OKNFCManager.m +26 -6
- package/ios/ReactNativeLiteCard.mm +16 -7
- package/package.json +8 -8
- package/sdk/CMakeLists.txt +120 -0
- package/sdk/README.md +175 -0
- package/sdk/android/implJni.cpp +177 -0
- package/sdk/deps/jsoncpp/LICENSE +55 -0
- package/sdk/deps/jsoncpp/include/CMakeLists.txt +2 -0
- package/sdk/deps/jsoncpp/include/json/allocator.h +98 -0
- package/sdk/deps/jsoncpp/include/json/assertions.h +54 -0
- package/sdk/deps/jsoncpp/include/json/autolink.h +25 -0
- package/sdk/deps/jsoncpp/include/json/config.h +187 -0
- package/sdk/deps/jsoncpp/include/json/features.h +61 -0
- package/sdk/deps/jsoncpp/include/json/forwards.h +37 -0
- package/sdk/deps/jsoncpp/include/json/json.h +15 -0
- package/sdk/deps/jsoncpp/include/json/reader.h +411 -0
- package/sdk/deps/jsoncpp/include/json/value.h +888 -0
- package/sdk/deps/jsoncpp/include/json/version.h +20 -0
- package/sdk/deps/jsoncpp/include/json/writer.h +357 -0
- package/sdk/deps/jsoncpp/src/lib_json/CMakeLists.txt +117 -0
- package/sdk/deps/jsoncpp/src/lib_json/json_reader.cpp +2060 -0
- package/sdk/deps/jsoncpp/src/lib_json/json_tool.h +114 -0
- package/sdk/deps/jsoncpp/src/lib_json/json_value.cpp +1661 -0
- package/sdk/deps/jsoncpp/src/lib_json/json_valueiterator.inl +167 -0
- package/sdk/deps/jsoncpp/src/lib_json/json_writer.cpp +1233 -0
- package/sdk/deps/jsoncpp/src/lib_json/version.h.in +20 -0
- package/sdk/deps/trezor-crypto/AUTHORS +2 -0
- package/sdk/deps/trezor-crypto/LICENSE +22 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/TrezorCrypto.h +29 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/address.h +44 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/aes.h +224 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/base32.h +49 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/base58.h +58 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/bignum.h +169 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/bip32.h +114 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/bip39.h +66 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/blake256.h +61 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/blake2b.h +50 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/blake2s.h +49 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/cash_addr.h +109 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/chacha20poly1305/ecrypt-config.h +316 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/chacha20poly1305/ecrypt-sync.h +289 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/chacha20poly1305/ecrypt-types.h +53 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/chacha20poly1305/poly1305-donna.h +28 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/chacha20poly1305.h +27 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/cmac.h +44 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/curves.h +60 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ecdsa.h +112 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/curve25519-donna-32bit.h +87 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/curve25519-donna-helpers.h +30 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-blake2b.h +21 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-donna-32bit-tables.h +25 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-donna-basepoint-table.h +10 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-donna-impl-base.h +110 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-donna-portable.h +32 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-donna.h +60 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-keccak.h +21 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-sha3.h +21 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/modm-donna-32bit.h +87 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna.h +60 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519.h +42 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/endian.h +132 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/groestl.h +104 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/hasher.h +90 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/hmac.h +60 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/memzero.h +16 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/monero/base58.h +42 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/monero/monero.h +13 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/monero/range_proof.h +30 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/monero/serialize.h +15 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/monero/xmr.h +67 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/nano.h +56 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/nem.h +199 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/nist256p1.h +35 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/pbkdf2.h +64 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/rand.h +44 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/rc4.h +37 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/rfc6979.h +40 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ripemd160.h +28 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/ripple/base58.h +45 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/schnorr.h +48 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/script.h +30 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/scrypt.h +68 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/secp256k1.h +59 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/sha2.h +125 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/sha3.h +86 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/sodium/keypair.h +20 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/sodium/private/ed25519_ref10.h +85 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/sodium/private/ed25519_ref10_fe_25_5.h +43 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/sodium/private/fe_25_5/constants.h +29 -0
- package/sdk/deps/trezor-crypto/include/TrezorCrypto/sodium/private/fe_25_5/fe.h +25 -0
- package/sdk/deps/trezor-crypto/src/address.c +87 -0
- package/sdk/deps/trezor-crypto/src/aes/aes_modes.c +959 -0
- package/sdk/deps/trezor-crypto/src/aes/aescrypt.c +307 -0
- package/sdk/deps/trezor-crypto/src/aes/aeskey.c +560 -0
- package/sdk/deps/trezor-crypto/src/aes/aesopt.h +784 -0
- package/sdk/deps/trezor-crypto/src/aes/aestab.c +418 -0
- package/sdk/deps/trezor-crypto/src/aes/aestab.h +173 -0
- package/sdk/deps/trezor-crypto/src/base32.c +233 -0
- package/sdk/deps/trezor-crypto/src/base58.c +298 -0
- package/sdk/deps/trezor-crypto/src/bignum.c +808 -0
- package/sdk/deps/trezor-crypto/src/bip32.c +852 -0
- package/sdk/deps/trezor-crypto/src/bip39.c +266 -0
- package/sdk/deps/trezor-crypto/src/bip39_english.h +2074 -0
- package/sdk/deps/trezor-crypto/src/blake256.c +235 -0
- package/sdk/deps/trezor-crypto/src/blake2_common.h +39 -0
- package/sdk/deps/trezor-crypto/src/blake2b.c +333 -0
- package/sdk/deps/trezor-crypto/src/blake2s.c +318 -0
- package/sdk/deps/trezor-crypto/src/cash_addr.c +195 -0
- package/sdk/deps/trezor-crypto/src/chacha20poly1305/chacha20poly1305.c +60 -0
- package/sdk/deps/trezor-crypto/src/chacha20poly1305/chacha_merged.c +246 -0
- package/sdk/deps/trezor-crypto/src/chacha20poly1305/ecrypt-machine.h +49 -0
- package/sdk/deps/trezor-crypto/src/chacha20poly1305/ecrypt-portable.h +275 -0
- package/sdk/deps/trezor-crypto/src/chacha20poly1305/poly1305-donna-32.h +219 -0
- package/sdk/deps/trezor-crypto/src/chacha20poly1305/poly1305-donna.c +179 -0
- package/sdk/deps/trezor-crypto/src/chacha20poly1305/rfc7539.c +48 -0
- package/sdk/deps/trezor-crypto/src/chacha20poly1305/rfc7539.h +10 -0
- package/sdk/deps/trezor-crypto/src/check_mem.h +30 -0
- package/sdk/deps/trezor-crypto/src/cmac.c +342 -0
- package/sdk/deps/trezor-crypto/src/curves.c +48 -0
- package/sdk/deps/trezor-crypto/src/ecdsa.c +1355 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/README.md +183 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/curve25519-donna-32bit.c +681 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/curve25519-donna-helpers.c +66 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/curve25519-donna-scalarmult-base.c +67 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/curve25519-donna-scalarmult-base.h +8 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-blake2b.c +8 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-donna-32bit-tables.c +63 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-donna-basepoint-table.c +261 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-donna-impl-base.c +722 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-hash-custom-blake2b.h +23 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-hash-custom-keccak.h +23 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-hash-custom-sha3.h +23 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-hash-custom.h +23 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-keccak.c +8 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-sha3.c +8 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519.c +311 -0
- package/sdk/deps/trezor-crypto/src/ed25519-donna/modm-donna-32bit.c +517 -0
- package/sdk/deps/trezor-crypto/src/groestl.c +783 -0
- package/sdk/deps/trezor-crypto/src/groestl_internal.h +419 -0
- package/sdk/deps/trezor-crypto/src/hasher.c +186 -0
- package/sdk/deps/trezor-crypto/src/hmac.c +179 -0
- package/sdk/deps/trezor-crypto/src/memzero.c +6 -0
- package/sdk/deps/trezor-crypto/src/monero/base58.c +245 -0
- package/sdk/deps/trezor-crypto/src/monero/int-util.h +77 -0
- package/sdk/deps/trezor-crypto/src/monero/range_proof.c +115 -0
- package/sdk/deps/trezor-crypto/src/monero/serialize.c +54 -0
- package/sdk/deps/trezor-crypto/src/monero/xmr.c +136 -0
- package/sdk/deps/trezor-crypto/src/nano.c +151 -0
- package/sdk/deps/trezor-crypto/src/nem.c +569 -0
- package/sdk/deps/trezor-crypto/src/nist256p1.c +63 -0
- package/sdk/deps/trezor-crypto/src/nist256p1.table +1664 -0
- package/sdk/deps/trezor-crypto/src/options.h +43 -0
- package/sdk/deps/trezor-crypto/src/pbkdf2.c +177 -0
- package/sdk/deps/trezor-crypto/src/rand.c +51 -0
- package/sdk/deps/trezor-crypto/src/rc4.c +56 -0
- package/sdk/deps/trezor-crypto/src/ripemd160.c +343 -0
- package/sdk/deps/trezor-crypto/src/ripple/base58.c +76 -0
- package/sdk/deps/trezor-crypto/src/schnorr.c +208 -0
- package/sdk/deps/trezor-crypto/src/script.c +64 -0
- package/sdk/deps/trezor-crypto/src/scrypt.c +343 -0
- package/sdk/deps/trezor-crypto/src/secp256k1.c +160 -0
- package/sdk/deps/trezor-crypto/src/secp256k1.table +1664 -0
- package/sdk/deps/trezor-crypto/src/setup.py +38 -0
- package/sdk/deps/trezor-crypto/src/sha2.c +1314 -0
- package/sdk/deps/trezor-crypto/src/sha3.c +395 -0
- package/sdk/deps/trezor-crypto/src/shell.nix +6 -0
- package/sdk/deps/trezor-crypto/src/sodium/keypair.c +63 -0
- package/sdk/deps/trezor-crypto/src/sodium/private/ed25519_ref10.c +481 -0
- package/sdk/deps/trezor-crypto/src/sodium/private/ed25519_ref10_fe_25_5.c +885 -0
- package/sdk/deps/trezor-crypto/src/sodium/private/fe_25_5/fe.c +237 -0
- package/sdk/gpc/include/scp03/scp03.hpp +80 -0
- package/sdk/gpc/include/scp11/scp11.hpp +492 -0
- package/sdk/gpc/include/scp11/scp11c.hpp +58 -0
- package/sdk/gpc/include/tag.h +68 -0
- package/sdk/gpc/include/tlv.hpp +94 -0
- package/sdk/gpc/include/tlvparse.hpp +24 -0
- package/sdk/gpc/src/scp03.cpp +243 -0
- package/sdk/gpc/src/scp11.cpp +798 -0
- package/sdk/gpc/src/scp11c.cpp +136 -0
- package/sdk/gpc/src/tlv.cpp +159 -0
- package/sdk/gpc/src/tlvparse.c +174 -0
- package/{framework/GPChannelSDKCore.xcframework/ios-arm64/GPChannelSDKCore.framework/Headers → sdk/include}/GPChannelSDK.h +0 -0
- package/sdk/include/GPChannelSDKCore.h +10 -0
- package/sdk/include/context/BaseContext.h +56 -0
- package/sdk/include/device/ApduBuilder.hpp +72 -0
- package/sdk/include/mSIGNA/stdutils/uchar_vector.h +36 -0
- package/sdk/include/utility/Apdu.hpp +172 -0
- package/sdk/include/utility/Debug.hpp +3 -0
- package/sdk/include/utility/util.h +104 -0
- package/sdk/src/ApduBuilder.cpp +332 -0
- package/sdk/src/GPChannelSDK.cpp +252 -0
- package/sdk/src/random.c +25 -0
- package/sdk/src/version.c +2 -0
- package/sdk/tests/android/GPChannelProxy.java +55 -0
- package/sdk/tests/android_verify.py +121 -0
- package/sdk/tests/safety.cpp +603 -0
- package/sdk/tests/verify.py +267 -0
- package/android/src/main/jniLibs/arm64-v8a/libgpchannelNDK.so +0 -0
- package/android/src/main/jniLibs/armeabi-v7a/libgpchannelNDK.so +0 -0
- package/framework/GPChannelSDKCore.xcframework/Info.plist +0 -52
- package/framework/GPChannelSDKCore.xcframework/ios-arm64/GPChannelSDKCore.framework/GPChannelSDKCore +0 -0
- package/framework/GPChannelSDKCore.xcframework/ios-arm64/GPChannelSDKCore.framework/Headers/GPChannelSDKCore.h +0 -19
- package/framework/GPChannelSDKCore.xcframework/ios-arm64/GPChannelSDKCore.framework/Info.plist +0 -0
- package/framework/GPChannelSDKCore.xcframework/ios-arm64/GPChannelSDKCore.framework/Modules/module.modulemap +0 -7
- package/framework/GPChannelSDKCore.xcframework/ios-arm64/GPChannelSDKCore.framework/_CodeSignature/CodeResources +0 -147
- package/framework/GPChannelSDKCore.xcframework/ios-arm64_x86_64-simulator/GPChannelSDKCore.framework/GPChannelSDKCore +0 -0
- package/framework/GPChannelSDKCore.xcframework/ios-arm64_x86_64-simulator/GPChannelSDKCore.framework/Headers/GPChannelSDK.h +0 -315
- package/framework/GPChannelSDKCore.xcframework/ios-arm64_x86_64-simulator/GPChannelSDKCore.framework/Headers/GPChannelSDKCore.h +0 -19
- package/framework/GPChannelSDKCore.xcframework/ios-arm64_x86_64-simulator/GPChannelSDKCore.framework/Info.plist +0 -0
- package/framework/GPChannelSDKCore.xcframework/ios-arm64_x86_64-simulator/GPChannelSDKCore.framework/Modules/module.modulemap +0 -7
- package/framework/GPChannelSDKCore.xcframework/ios-arm64_x86_64-simulator/GPChannelSDKCore.framework/_CodeSignature/CodeResources +0 -147
|
@@ -0,0 +1,808 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Copyright (c) 2013-2014 Tomas Dzetkulic
|
|
3
|
+
* Copyright (c) 2013-2014 Pavol Rusnak
|
|
4
|
+
* Copyright (c) 2015 Jochen Hoenicke
|
|
5
|
+
* Copyright (c) 2016 Alex Beregszaszi
|
|
6
|
+
*
|
|
7
|
+
* Permission is hereby granted, free of charge, to any person obtaining
|
|
8
|
+
* a copy of this software and associated documentation files (the "Software"),
|
|
9
|
+
* to deal in the Software without restriction, including without limitation
|
|
10
|
+
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
11
|
+
* and/or sell copies of the Software, and to permit persons to whom the
|
|
12
|
+
* Software is furnished to do so, subject to the following conditions:
|
|
13
|
+
*
|
|
14
|
+
* The above copyright notice and this permission notice shall be included
|
|
15
|
+
* in all copies or substantial portions of the Software.
|
|
16
|
+
*
|
|
17
|
+
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
18
|
+
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
19
|
+
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
20
|
+
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
|
|
21
|
+
* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
22
|
+
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
23
|
+
* OTHER DEALINGS IN THE SOFTWARE.
|
|
24
|
+
*/
|
|
25
|
+
|
|
26
|
+
#include <stdio.h>
|
|
27
|
+
#include <string.h>
|
|
28
|
+
#include <assert.h>
|
|
29
|
+
|
|
30
|
+
#include <TrezorCrypto/bignum.h>
|
|
31
|
+
#include <TrezorCrypto/memzero.h>
|
|
32
|
+
|
|
33
|
+
/* big number library */
|
|
34
|
+
|
|
35
|
+
/* The structure bignum256 is an array of nine 32-bit values, which
|
|
36
|
+
* are digits in base 2^30 representation. I.e. the number
|
|
37
|
+
* bignum256 a;
|
|
38
|
+
* represents the value
|
|
39
|
+
* sum_{i=0}^8 a.val[i] * 2^{30 i}.
|
|
40
|
+
*
|
|
41
|
+
* The number is *normalized* iff every digit is < 2^30.
|
|
42
|
+
*
|
|
43
|
+
* As the name suggests, a bignum256 is intended to represent a 256
|
|
44
|
+
* bit number, but it can represent 270 bits. Numbers are usually
|
|
45
|
+
* reduced using a prime, either the group order or the field prime.
|
|
46
|
+
* The reduction is often partly done by bn_fast_mod, and similarly
|
|
47
|
+
* implicitly in bn_multiply. A *partly reduced number* is a
|
|
48
|
+
* normalized number between 0 (inclusive) and 2*prime (exclusive).
|
|
49
|
+
*
|
|
50
|
+
* A partly reduced number can be fully reduced by calling bn_mod.
|
|
51
|
+
* Only a fully reduced number is guaranteed to fit in 256 bit.
|
|
52
|
+
*
|
|
53
|
+
* All functions assume that the prime in question is slightly smaller
|
|
54
|
+
* than 2^256. In particular it must be between 2^256-2^224 and
|
|
55
|
+
* 2^256 and it must be a prime number.
|
|
56
|
+
*/
|
|
57
|
+
|
|
58
|
+
inline uint32_t read_be(const uint8_t *data)
|
|
59
|
+
{
|
|
60
|
+
return (((uint32_t)data[0]) << 24) |
|
|
61
|
+
(((uint32_t)data[1]) << 16) |
|
|
62
|
+
(((uint32_t)data[2]) << 8) |
|
|
63
|
+
(((uint32_t)data[3]));
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
inline void write_be(uint8_t *data, uint32_t x)
|
|
67
|
+
{
|
|
68
|
+
data[0] = x >> 24;
|
|
69
|
+
data[1] = x >> 16;
|
|
70
|
+
data[2] = x >> 8;
|
|
71
|
+
data[3] = x;
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
inline uint32_t read_le(const uint8_t *data)
|
|
75
|
+
{
|
|
76
|
+
return (((uint32_t)data[3]) << 24) |
|
|
77
|
+
(((uint32_t)data[2]) << 16) |
|
|
78
|
+
(((uint32_t)data[1]) << 8) |
|
|
79
|
+
(((uint32_t)data[0]));
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
inline void write_le(uint8_t *data, uint32_t x)
|
|
83
|
+
{
|
|
84
|
+
data[3] = x >> 24;
|
|
85
|
+
data[2] = x >> 16;
|
|
86
|
+
data[1] = x >> 8;
|
|
87
|
+
data[0] = x;
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
// convert a raw bigendian 256 bit value into a normalized bignum.
|
|
91
|
+
// out_number is partly reduced (since it fits in 256 bit).
|
|
92
|
+
void bn_read_be(const uint8_t *in_number, bignum256 *out_number)
|
|
93
|
+
{
|
|
94
|
+
int i;
|
|
95
|
+
uint32_t temp = 0;
|
|
96
|
+
for (i = 0; i < 8; i++) {
|
|
97
|
+
// invariant: temp = (in_number % 2^(32i)) >> 30i
|
|
98
|
+
// get next limb = (in_number % 2^(32(i+1))) >> 32i
|
|
99
|
+
uint32_t limb = read_be(in_number + (7 - i) * 4);
|
|
100
|
+
// temp = (in_number % 2^(32(i+1))) << 30i
|
|
101
|
+
temp |= limb << (2*i);
|
|
102
|
+
// store 30 bits into val[i]
|
|
103
|
+
out_number->val[i]= temp & 0x3FFFFFFF;
|
|
104
|
+
// prepare temp for next round
|
|
105
|
+
temp = limb >> (30 - 2*i);
|
|
106
|
+
}
|
|
107
|
+
out_number->val[8] = temp;
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
// convert a normalized bignum to a raw bigendian 256 bit number.
|
|
111
|
+
// in_number must be fully reduced.
|
|
112
|
+
void bn_write_be(const bignum256 *in_number, uint8_t *out_number)
|
|
113
|
+
{
|
|
114
|
+
int i;
|
|
115
|
+
uint32_t temp = in_number->val[8];
|
|
116
|
+
for (i = 0; i < 8; i++) {
|
|
117
|
+
// invariant: temp = (in_number >> 30*(8-i))
|
|
118
|
+
uint32_t limb = in_number->val[7 - i];
|
|
119
|
+
temp = (temp << (16 + 2*i)) | (limb >> (14 - 2*i));
|
|
120
|
+
write_be(out_number + i * 4, temp);
|
|
121
|
+
temp = limb;
|
|
122
|
+
}
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
// convert a raw little endian 256 bit value into a normalized bignum.
|
|
126
|
+
// out_number is partly reduced (since it fits in 256 bit).
|
|
127
|
+
void bn_read_le(const uint8_t *in_number, bignum256 *out_number)
|
|
128
|
+
{
|
|
129
|
+
int i;
|
|
130
|
+
uint32_t temp = 0;
|
|
131
|
+
for (i = 0; i < 8; i++) {
|
|
132
|
+
// invariant: temp = (in_number % 2^(32i)) >> 30i
|
|
133
|
+
// get next limb = (in_number % 2^(32(i+1))) >> 32i
|
|
134
|
+
uint32_t limb = read_le(in_number + i * 4);
|
|
135
|
+
// temp = (in_number % 2^(32(i+1))) << 30i
|
|
136
|
+
temp |= limb << (2*i);
|
|
137
|
+
// store 30 bits into val[i]
|
|
138
|
+
out_number->val[i]= temp & 0x3FFFFFFF;
|
|
139
|
+
// prepare temp for next round
|
|
140
|
+
temp = limb >> (30 - 2*i);
|
|
141
|
+
}
|
|
142
|
+
out_number->val[8] = temp;
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
// convert a normalized bignum to a raw little endian 256 bit number.
|
|
146
|
+
// in_number must be fully reduced.
|
|
147
|
+
void bn_write_le(const bignum256 *in_number, uint8_t *out_number)
|
|
148
|
+
{
|
|
149
|
+
int i;
|
|
150
|
+
uint32_t temp = in_number->val[8];
|
|
151
|
+
for (i = 0; i < 8; i++) {
|
|
152
|
+
// invariant: temp = (in_number >> 30*(8-i))
|
|
153
|
+
uint32_t limb = in_number->val[7 - i];
|
|
154
|
+
temp = (temp << (16 + 2*i)) | (limb >> (14 - 2*i));
|
|
155
|
+
write_le(out_number + (7 - i) * 4, temp);
|
|
156
|
+
temp = limb;
|
|
157
|
+
}
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
void bn_read_uint32(uint32_t in_number, bignum256 *out_number)
|
|
161
|
+
{
|
|
162
|
+
out_number->val[0] = in_number & 0x3FFFFFFF;
|
|
163
|
+
out_number->val[1] = in_number >> 30;
|
|
164
|
+
out_number->val[2] = 0;
|
|
165
|
+
out_number->val[3] = 0;
|
|
166
|
+
out_number->val[4] = 0;
|
|
167
|
+
out_number->val[5] = 0;
|
|
168
|
+
out_number->val[6] = 0;
|
|
169
|
+
out_number->val[7] = 0;
|
|
170
|
+
out_number->val[8] = 0;
|
|
171
|
+
}
|
|
172
|
+
|
|
173
|
+
void bn_read_uint64(uint64_t in_number, bignum256 *out_number)
|
|
174
|
+
{
|
|
175
|
+
out_number->val[0] = in_number & 0x3FFFFFFF;
|
|
176
|
+
out_number->val[1] = (in_number >>= 30) & 0x3FFFFFFF;
|
|
177
|
+
out_number->val[2] = in_number >>= 30;
|
|
178
|
+
out_number->val[3] = 0;
|
|
179
|
+
out_number->val[4] = 0;
|
|
180
|
+
out_number->val[5] = 0;
|
|
181
|
+
out_number->val[6] = 0;
|
|
182
|
+
out_number->val[7] = 0;
|
|
183
|
+
out_number->val[8] = 0;
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
// a must be normalized
|
|
187
|
+
int bn_bitcount(const bignum256 *a)
|
|
188
|
+
{
|
|
189
|
+
int i;
|
|
190
|
+
for (i = 8; i >= 0; i--) {
|
|
191
|
+
int tmp = a->val[i];
|
|
192
|
+
if (tmp != 0) {
|
|
193
|
+
return i * 30 + (32 - __builtin_clz(tmp));
|
|
194
|
+
}
|
|
195
|
+
}
|
|
196
|
+
return 0;
|
|
197
|
+
}
|
|
198
|
+
|
|
199
|
+
#define DIGITS 78 // log10(2 ^ 256)
|
|
200
|
+
|
|
201
|
+
unsigned int bn_digitcount(const bignum256 *a)
|
|
202
|
+
{
|
|
203
|
+
bignum256 val;
|
|
204
|
+
memcpy(&val, a, sizeof(bignum256));
|
|
205
|
+
|
|
206
|
+
unsigned int digits = 1;
|
|
207
|
+
|
|
208
|
+
for (unsigned int i = 0; i < DIGITS; i += 3) {
|
|
209
|
+
uint32_t limb;
|
|
210
|
+
bn_divmod1000(&val, &limb);
|
|
211
|
+
|
|
212
|
+
if (limb >= 100) {
|
|
213
|
+
digits = i + 3;
|
|
214
|
+
} else if (limb >= 10) {
|
|
215
|
+
digits = i + 2;
|
|
216
|
+
} else if (limb >= 1) {
|
|
217
|
+
digits = i + 1;
|
|
218
|
+
}
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
return digits;
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
// sets a bignum to zero.
|
|
225
|
+
void bn_zero(bignum256 *a)
|
|
226
|
+
{
|
|
227
|
+
int i;
|
|
228
|
+
for (i = 0; i < 9; i++) {
|
|
229
|
+
a->val[i] = 0;
|
|
230
|
+
}
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
// sets a bignum to one.
|
|
234
|
+
void bn_one(bignum256 *a)
|
|
235
|
+
{
|
|
236
|
+
a->val[0] = 1;
|
|
237
|
+
a->val[1] = 0;
|
|
238
|
+
a->val[2] = 0;
|
|
239
|
+
a->val[3] = 0;
|
|
240
|
+
a->val[4] = 0;
|
|
241
|
+
a->val[5] = 0;
|
|
242
|
+
a->val[6] = 0;
|
|
243
|
+
a->val[7] = 0;
|
|
244
|
+
a->val[8] = 0;
|
|
245
|
+
}
|
|
246
|
+
|
|
247
|
+
// checks that a bignum is zero.
|
|
248
|
+
// a must be normalized
|
|
249
|
+
// function is constant time (on some architectures, in particular ARM).
|
|
250
|
+
int bn_is_zero(const bignum256 *a)
|
|
251
|
+
{
|
|
252
|
+
int i;
|
|
253
|
+
uint32_t result = 0;
|
|
254
|
+
for (i = 0; i < 9; i++) {
|
|
255
|
+
result |= a->val[i];
|
|
256
|
+
}
|
|
257
|
+
return !result;
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
// Check whether a < b
|
|
261
|
+
// a and b must be normalized
|
|
262
|
+
// function is constant time (on some architectures, in particular ARM).
|
|
263
|
+
int bn_is_less(const bignum256 *a, const bignum256 *b)
|
|
264
|
+
{
|
|
265
|
+
int i;
|
|
266
|
+
uint32_t res1 = 0;
|
|
267
|
+
uint32_t res2 = 0;
|
|
268
|
+
for (i = 8; i >= 0; i--) {
|
|
269
|
+
res1 = (res1 << 1) | (a->val[i] < b->val[i]);
|
|
270
|
+
res2 = (res2 << 1) | (a->val[i] > b->val[i]);
|
|
271
|
+
}
|
|
272
|
+
return res1 > res2;
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
// Check whether a == b
|
|
276
|
+
// a and b must be normalized
|
|
277
|
+
// function is constant time (on some architectures, in particular ARM).
|
|
278
|
+
int bn_is_equal(const bignum256 *a, const bignum256 *b) {
|
|
279
|
+
int i;
|
|
280
|
+
uint32_t result = 0;
|
|
281
|
+
for (i = 0; i < 9; i++) {
|
|
282
|
+
result |= (a->val[i] ^ b->val[i]);
|
|
283
|
+
}
|
|
284
|
+
return !result;
|
|
285
|
+
}
|
|
286
|
+
|
|
287
|
+
// Assigns res = cond ? truecase : falsecase
|
|
288
|
+
// assumes that cond is either 0 or 1.
|
|
289
|
+
// function is constant time.
|
|
290
|
+
void bn_cmov(bignum256 *res, int cond, const bignum256 *truecase, const bignum256 *falsecase)
|
|
291
|
+
{
|
|
292
|
+
int i;
|
|
293
|
+
uint32_t tmask = (uint32_t) -cond;
|
|
294
|
+
uint32_t fmask = ~tmask;
|
|
295
|
+
|
|
296
|
+
assert (cond == 1 || cond == 0);
|
|
297
|
+
for (i = 0; i < 9; i++) {
|
|
298
|
+
res->val[i] = (truecase->val[i] & tmask) |
|
|
299
|
+
(falsecase->val[i] & fmask);
|
|
300
|
+
}
|
|
301
|
+
}
|
|
302
|
+
|
|
303
|
+
// shift number to the left, i.e multiply it by 2.
|
|
304
|
+
// a must be normalized. The result is normalized but not reduced.
|
|
305
|
+
void bn_lshift(bignum256 *a)
|
|
306
|
+
{
|
|
307
|
+
int i;
|
|
308
|
+
for (i = 8; i > 0; i--) {
|
|
309
|
+
a->val[i] = ((a->val[i] << 1) & 0x3FFFFFFF) | ((a->val[i - 1] & 0x20000000) >> 29);
|
|
310
|
+
}
|
|
311
|
+
a->val[0] = (a->val[0] << 1) & 0x3FFFFFFF;
|
|
312
|
+
}
|
|
313
|
+
|
|
314
|
+
// shift number to the right, i.e divide by 2 while rounding down.
|
|
315
|
+
// a must be normalized. The result is normalized.
|
|
316
|
+
void bn_rshift(bignum256 *a)
|
|
317
|
+
{
|
|
318
|
+
int i;
|
|
319
|
+
for (i = 0; i < 8; i++) {
|
|
320
|
+
a->val[i] = (a->val[i] >> 1) | ((a->val[i + 1] & 1) << 29);
|
|
321
|
+
}
|
|
322
|
+
a->val[8] >>= 1;
|
|
323
|
+
}
|
|
324
|
+
|
|
325
|
+
// sets bit in bignum
|
|
326
|
+
void bn_setbit(bignum256 *a, uint8_t bit)
|
|
327
|
+
{
|
|
328
|
+
a->val[bit / 30] |= (1u << (bit % 30));
|
|
329
|
+
}
|
|
330
|
+
|
|
331
|
+
// clears bit in bignum
|
|
332
|
+
void bn_clearbit(bignum256 *a, uint8_t bit)
|
|
333
|
+
{
|
|
334
|
+
a->val[bit / 30] &= ~(1u << (bit % 30));
|
|
335
|
+
}
|
|
336
|
+
|
|
337
|
+
// tests bit in bignum
|
|
338
|
+
uint32_t bn_testbit(bignum256 *a, uint8_t bit)
|
|
339
|
+
{
|
|
340
|
+
return a->val[bit / 30] & (1u << (bit % 30));
|
|
341
|
+
}
|
|
342
|
+
|
|
343
|
+
// a = b ^ c
|
|
344
|
+
void bn_xor(bignum256 *a, const bignum256 *b, const bignum256 *c)
|
|
345
|
+
{
|
|
346
|
+
int i;
|
|
347
|
+
for (i = 0; i < 9; i++) {
|
|
348
|
+
a->val[i] = b->val[i] ^ c->val[i];
|
|
349
|
+
}
|
|
350
|
+
}
|
|
351
|
+
|
|
352
|
+
// multiply x by 1/2 modulo prime.
|
|
353
|
+
// it computes x = (x & 1) ? (x + prime) >> 1 : x >> 1.
|
|
354
|
+
// assumes x is normalized.
|
|
355
|
+
// if x was partly reduced, it is also partly reduced on exit.
|
|
356
|
+
// function is constant time.
|
|
357
|
+
void bn_mult_half(bignum256 * x, const bignum256 *prime)
|
|
358
|
+
{
|
|
359
|
+
int j;
|
|
360
|
+
uint32_t xodd = -(x->val[0] & 1);
|
|
361
|
+
// compute x = x/2 mod prime
|
|
362
|
+
// if x is odd compute (x+prime)/2
|
|
363
|
+
uint32_t tmp1 = (x->val[0] + (prime->val[0] & xodd)) >> 1;
|
|
364
|
+
for (j = 0; j < 8; j++) {
|
|
365
|
+
uint32_t tmp2 = (x->val[j+1] + (prime->val[j+1] & xodd));
|
|
366
|
+
tmp1 += (tmp2 & 1) << 29;
|
|
367
|
+
x->val[j] = tmp1 & 0x3fffffff;
|
|
368
|
+
tmp1 >>= 30;
|
|
369
|
+
tmp1 += tmp2 >> 1;
|
|
370
|
+
}
|
|
371
|
+
x->val[8] = tmp1;
|
|
372
|
+
}
|
|
373
|
+
|
|
374
|
+
// multiply x by k modulo prime.
|
|
375
|
+
// assumes x is normalized, 0 <= k <= 4.
|
|
376
|
+
// guarantees x is partly reduced.
|
|
377
|
+
void bn_mult_k(bignum256 *x, uint8_t k, const bignum256 *prime)
|
|
378
|
+
{
|
|
379
|
+
int j;
|
|
380
|
+
for (j = 0; j < 9; j++) {
|
|
381
|
+
x->val[j] = k * x->val[j];
|
|
382
|
+
}
|
|
383
|
+
bn_fast_mod(x, prime);
|
|
384
|
+
}
|
|
385
|
+
|
|
386
|
+
// compute x = x mod prime by computing x >= prime ? x - prime : x.
|
|
387
|
+
// assumes x partly reduced, guarantees x fully reduced.
|
|
388
|
+
void bn_mod(bignum256 *x, const bignum256 *prime)
|
|
389
|
+
{
|
|
390
|
+
const int flag = bn_is_less(x, prime); // x < prime
|
|
391
|
+
bignum256 temp;
|
|
392
|
+
bn_subtract(x, prime, &temp); // temp = x - prime
|
|
393
|
+
bn_cmov(x, flag, x, &temp);
|
|
394
|
+
}
|
|
395
|
+
|
|
396
|
+
// auxiliary function for multiplication.
|
|
397
|
+
// compute k * x as a 540 bit number in base 2^30 (normalized).
|
|
398
|
+
// assumes that k and x are normalized.
|
|
399
|
+
void bn_multiply_long(const bignum256 *k, const bignum256 *x, uint32_t res[18])
|
|
400
|
+
{
|
|
401
|
+
int i, j;
|
|
402
|
+
uint64_t temp = 0;
|
|
403
|
+
|
|
404
|
+
// compute lower half of long multiplication
|
|
405
|
+
for (i = 0; i < 9; i++)
|
|
406
|
+
{
|
|
407
|
+
for (j = 0; j <= i; j++) {
|
|
408
|
+
// no overflow, since 9*2^60 < 2^64
|
|
409
|
+
temp += k->val[j] * (uint64_t)x->val[i - j];
|
|
410
|
+
}
|
|
411
|
+
res[i] = temp & 0x3FFFFFFFu;
|
|
412
|
+
temp >>= 30;
|
|
413
|
+
}
|
|
414
|
+
// compute upper half
|
|
415
|
+
for (; i < 17; i++)
|
|
416
|
+
{
|
|
417
|
+
for (j = i - 8; j < 9 ; j++) {
|
|
418
|
+
// no overflow, since 9*2^60 < 2^64
|
|
419
|
+
temp += k->val[j] * (uint64_t)x->val[i - j];
|
|
420
|
+
}
|
|
421
|
+
res[i] = temp & 0x3FFFFFFFu;
|
|
422
|
+
temp >>= 30;
|
|
423
|
+
}
|
|
424
|
+
res[17] = temp;
|
|
425
|
+
}
|
|
426
|
+
|
|
427
|
+
// auxiliary function for multiplication.
|
|
428
|
+
// reduces res modulo prime.
|
|
429
|
+
// assumes res normalized, res < 2^(30(i-7)) * 2 * prime
|
|
430
|
+
// guarantees res normalized, res < 2^(30(i-8)) * 2 * prime
|
|
431
|
+
void bn_multiply_reduce_step(uint32_t res[18], const bignum256 *prime, uint32_t i) {
|
|
432
|
+
// let k = i-8.
|
|
433
|
+
// on entry:
|
|
434
|
+
// 0 <= res < 2^(30k + 31) * prime
|
|
435
|
+
// estimate coef = (res / prime / 2^30k)
|
|
436
|
+
// by coef = res / 2^(30k + 256) rounded down
|
|
437
|
+
// 0 <= coef < 2^31
|
|
438
|
+
// subtract (coef * 2^(30k) * prime) from res
|
|
439
|
+
// note that we unrolled the first iteration
|
|
440
|
+
uint32_t j;
|
|
441
|
+
uint32_t coef = (res[i] >> 16) + (res[i + 1] << 14);
|
|
442
|
+
uint64_t temp = 0x2000000000000000ull + res[i - 8] - prime->val[0] * (uint64_t)coef;
|
|
443
|
+
assert (coef < 0x80000000u);
|
|
444
|
+
res[i - 8] = temp & 0x3FFFFFFF;
|
|
445
|
+
for (j = 1; j < 9; j++) {
|
|
446
|
+
temp >>= 30;
|
|
447
|
+
// Note: coeff * prime->val[j] <= (2^31-1) * (2^30-1)
|
|
448
|
+
// Hence, this addition will not underflow.
|
|
449
|
+
temp += 0x1FFFFFFF80000000ull + res[i - 8 + j] - prime->val[j] * (uint64_t)coef;
|
|
450
|
+
res[i - 8 + j] = temp & 0x3FFFFFFF;
|
|
451
|
+
// 0 <= temp < 2^61 + 2^30
|
|
452
|
+
}
|
|
453
|
+
temp >>= 30;
|
|
454
|
+
temp += 0x1FFFFFFF80000000ull + res[i - 8 + j];
|
|
455
|
+
res[i - 8 + j] = temp & 0x3FFFFFFF;
|
|
456
|
+
// we rely on the fact that prime > 2^256 - 2^224
|
|
457
|
+
// res = oldres - coef*2^(30k) * prime;
|
|
458
|
+
// and
|
|
459
|
+
// coef * 2^(30k + 256) <= oldres < (coef+1) * 2^(30k + 256)
|
|
460
|
+
// Hence, 0 <= res < 2^30k (2^256 + coef * (2^256 - prime))
|
|
461
|
+
// < 2^30k (2^256 + 2^31 * 2^224)
|
|
462
|
+
// < 2^30k (2 * prime)
|
|
463
|
+
}
|
|
464
|
+
|
|
465
|
+
|
|
466
|
+
// auxiliary function for multiplication.
|
|
467
|
+
// reduces x = res modulo prime.
|
|
468
|
+
// assumes res normalized, res < 2^270 * 2 * prime
|
|
469
|
+
// guarantees x partly reduced, i.e., x < 2 * prime
|
|
470
|
+
void bn_multiply_reduce(bignum256 *x, uint32_t res[18], const bignum256 *prime)
|
|
471
|
+
{
|
|
472
|
+
int i;
|
|
473
|
+
// res = k * x is a normalized number (every limb < 2^30)
|
|
474
|
+
// 0 <= res < 2^270 * 2 * prime.
|
|
475
|
+
for (i = 16; i >= 8; i--) {
|
|
476
|
+
bn_multiply_reduce_step(res, prime, i);
|
|
477
|
+
assert(res[i + 1] == 0);
|
|
478
|
+
}
|
|
479
|
+
// store the result
|
|
480
|
+
for (i = 0; i < 9; i++) {
|
|
481
|
+
x->val[i] = res[i];
|
|
482
|
+
}
|
|
483
|
+
}
|
|
484
|
+
|
|
485
|
+
// Compute x := k * x (mod prime)
|
|
486
|
+
// both inputs must be smaller than 180 * prime.
|
|
487
|
+
// result is partly reduced (0 <= x < 2 * prime)
|
|
488
|
+
// This only works for primes between 2^256-2^224 and 2^256.
|
|
489
|
+
void bn_multiply(const bignum256 *k, bignum256 *x, const bignum256 *prime)
|
|
490
|
+
{
|
|
491
|
+
uint32_t res[18] = {0};
|
|
492
|
+
bn_multiply_long(k, x, res);
|
|
493
|
+
bn_multiply_reduce(x, res, prime);
|
|
494
|
+
memzero(res, sizeof(res));
|
|
495
|
+
}
|
|
496
|
+
|
|
497
|
+
// partly reduce x modulo prime
|
|
498
|
+
// input x does not have to be normalized.
|
|
499
|
+
// x can be any number that fits.
|
|
500
|
+
// prime must be between (2^256 - 2^224) and 2^256
|
|
501
|
+
// result is partly reduced, smaller than 2*prime
|
|
502
|
+
void bn_fast_mod(bignum256 *x, const bignum256 *prime)
|
|
503
|
+
{
|
|
504
|
+
int j;
|
|
505
|
+
uint32_t coef;
|
|
506
|
+
uint64_t temp;
|
|
507
|
+
|
|
508
|
+
coef = x->val[8] >> 16;
|
|
509
|
+
// substract (coef * prime) from x
|
|
510
|
+
// note that we unrolled the first iteration
|
|
511
|
+
temp = 0x2000000000000000ull + x->val[0] - prime->val[0] * (uint64_t)coef;
|
|
512
|
+
x->val[0] = temp & 0x3FFFFFFF;
|
|
513
|
+
for (j = 1; j < 9; j++) {
|
|
514
|
+
temp >>= 30;
|
|
515
|
+
temp += 0x1FFFFFFF80000000ull + x->val[j] - prime->val[j] * (uint64_t)coef;
|
|
516
|
+
x->val[j] = temp & 0x3FFFFFFF;
|
|
517
|
+
}
|
|
518
|
+
}
|
|
519
|
+
|
|
520
|
+
// square root of x = x^((p+1)/4)
|
|
521
|
+
// http://en.wikipedia.org/wiki/Quadratic_residue#Prime_or_prime_power_modulus
|
|
522
|
+
// assumes x is normalized but not necessarily reduced.
|
|
523
|
+
// guarantees x is reduced
|
|
524
|
+
void bn_sqrt(bignum256 *x, const bignum256 *prime)
|
|
525
|
+
{
|
|
526
|
+
// this method compute x^1/2 = x^(prime+1)/4
|
|
527
|
+
uint32_t i, j, limb;
|
|
528
|
+
bignum256 res, p;
|
|
529
|
+
bn_one(&res);
|
|
530
|
+
// compute p = (prime+1)/4
|
|
531
|
+
memcpy(&p, prime, sizeof(bignum256));
|
|
532
|
+
bn_addi(&p, 1);
|
|
533
|
+
bn_rshift(&p);
|
|
534
|
+
bn_rshift(&p);
|
|
535
|
+
for (i = 0; i < 9; i++) {
|
|
536
|
+
// invariants:
|
|
537
|
+
// x = old(x)^(2^(i*30))
|
|
538
|
+
// res = old(x)^(p % 2^(i*30))
|
|
539
|
+
// get the i-th limb of prime - 2
|
|
540
|
+
limb = p.val[i];
|
|
541
|
+
for (j = 0; j < 30; j++) {
|
|
542
|
+
// invariants:
|
|
543
|
+
// x = old(x)^(2^(i*30+j))
|
|
544
|
+
// res = old(x)^(p % 2^(i*30+j))
|
|
545
|
+
// limb = (p % 2^(i*30+30)) / 2^(i*30+j)
|
|
546
|
+
if (i == 8 && limb == 0) break;
|
|
547
|
+
if (limb & 1) {
|
|
548
|
+
bn_multiply(x, &res, prime);
|
|
549
|
+
}
|
|
550
|
+
limb >>= 1;
|
|
551
|
+
bn_multiply(x, x, prime);
|
|
552
|
+
}
|
|
553
|
+
}
|
|
554
|
+
bn_mod(&res, prime);
|
|
555
|
+
memcpy(x, &res, sizeof(bignum256));
|
|
556
|
+
memzero(&res, sizeof(res));
|
|
557
|
+
memzero(&p, sizeof(p));
|
|
558
|
+
}
|
|
559
|
+
|
|
560
|
+
// in field G_prime, small but slow
|
|
561
|
+
void bn_inverse(bignum256 *x, const bignum256 *prime)
|
|
562
|
+
{
|
|
563
|
+
// this method compute x^-1 = x^(prime-2)
|
|
564
|
+
uint32_t i, j, limb;
|
|
565
|
+
bignum256 res;
|
|
566
|
+
bn_one(&res);
|
|
567
|
+
for (i = 0; i < 9; i++) {
|
|
568
|
+
// invariants:
|
|
569
|
+
// x = old(x)^(2^(i*30))
|
|
570
|
+
// res = old(x)^((prime-2) % 2^(i*30))
|
|
571
|
+
// get the i-th limb of prime - 2
|
|
572
|
+
limb = prime->val[i];
|
|
573
|
+
// this is not enough in general but fine for secp256k1 & nist256p1 because prime->val[0] > 1
|
|
574
|
+
if (i == 0) limb -= 2;
|
|
575
|
+
for (j = 0; j < 30; j++) {
|
|
576
|
+
// invariants:
|
|
577
|
+
// x = old(x)^(2^(i*30+j))
|
|
578
|
+
// res = old(x)^((prime-2) % 2^(i*30+j))
|
|
579
|
+
// limb = ((prime-2) % 2^(i*30+30)) / 2^(i*30+j)
|
|
580
|
+
// early abort when only zero bits follow
|
|
581
|
+
if (i == 8 && limb == 0) break;
|
|
582
|
+
if (limb & 1) {
|
|
583
|
+
bn_multiply(x, &res, prime);
|
|
584
|
+
}
|
|
585
|
+
limb >>= 1;
|
|
586
|
+
bn_multiply(x, x, prime);
|
|
587
|
+
}
|
|
588
|
+
}
|
|
589
|
+
bn_mod(&res, prime);
|
|
590
|
+
memcpy(x, &res, sizeof(bignum256));
|
|
591
|
+
}
|
|
592
|
+
|
|
593
|
+
void bn_normalize(bignum256 *a) {
|
|
594
|
+
bn_addi(a, 0);
|
|
595
|
+
}
|
|
596
|
+
|
|
597
|
+
// add two numbers a = a + b
|
|
598
|
+
// assumes that a, b are normalized
|
|
599
|
+
// guarantees that a is normalized
|
|
600
|
+
void bn_add(bignum256 *a, const bignum256 *b)
|
|
601
|
+
{
|
|
602
|
+
int i;
|
|
603
|
+
uint32_t tmp = 0;
|
|
604
|
+
for (i = 0; i < 9; i++) {
|
|
605
|
+
tmp += a->val[i] + b->val[i];
|
|
606
|
+
a->val[i] = tmp & 0x3FFFFFFF;
|
|
607
|
+
tmp >>= 30;
|
|
608
|
+
}
|
|
609
|
+
}
|
|
610
|
+
|
|
611
|
+
void bn_addmod(bignum256 *a, const bignum256 *b, const bignum256 *prime)
|
|
612
|
+
{
|
|
613
|
+
int i;
|
|
614
|
+
for (i = 0; i < 9; i++) {
|
|
615
|
+
a->val[i] += b->val[i];
|
|
616
|
+
}
|
|
617
|
+
bn_fast_mod(a, prime);
|
|
618
|
+
}
|
|
619
|
+
|
|
620
|
+
void bn_addi(bignum256 *a, uint32_t b) {
|
|
621
|
+
int i;
|
|
622
|
+
uint32_t tmp = b;
|
|
623
|
+
for (i = 0; i < 9; i++) {
|
|
624
|
+
tmp += a->val[i];
|
|
625
|
+
a->val[i] = tmp & 0x3FFFFFFF;
|
|
626
|
+
tmp >>= 30;
|
|
627
|
+
}
|
|
628
|
+
}
|
|
629
|
+
|
|
630
|
+
void bn_subi(bignum256 *a, uint32_t b, const bignum256 *prime) {
|
|
631
|
+
assert (b <= prime->val[0]);
|
|
632
|
+
// the possible underflow will be taken care of when adding the prime
|
|
633
|
+
a->val[0] -= b;
|
|
634
|
+
bn_add(a, prime);
|
|
635
|
+
}
|
|
636
|
+
|
|
637
|
+
// res = a - b mod prime. More exactly res = a + (2*prime - b).
|
|
638
|
+
// b must be a partly reduced number
|
|
639
|
+
// result is normalized but not reduced.
|
|
640
|
+
void bn_subtractmod(const bignum256 *a, const bignum256 *b, bignum256 *res, const bignum256 *prime)
|
|
641
|
+
{
|
|
642
|
+
int i;
|
|
643
|
+
uint32_t temp = 1;
|
|
644
|
+
for (i = 0; i < 9; i++) {
|
|
645
|
+
temp += 0x3FFFFFFF + a->val[i] + 2u * prime->val[i] - b->val[i];
|
|
646
|
+
res->val[i] = temp & 0x3FFFFFFF;
|
|
647
|
+
temp >>= 30;
|
|
648
|
+
}
|
|
649
|
+
}
|
|
650
|
+
|
|
651
|
+
// res = a - b ; a > b
|
|
652
|
+
void bn_subtract(const bignum256 *a, const bignum256 *b, bignum256 *res)
|
|
653
|
+
{
|
|
654
|
+
int i;
|
|
655
|
+
uint32_t tmp = 1;
|
|
656
|
+
for (i = 0; i < 9; i++) {
|
|
657
|
+
tmp += 0x3FFFFFFF + a->val[i] - b->val[i];
|
|
658
|
+
res->val[i] = tmp & 0x3FFFFFFF;
|
|
659
|
+
tmp >>= 30;
|
|
660
|
+
}
|
|
661
|
+
}
|
|
662
|
+
|
|
663
|
+
// a / 58 = a (+r)
|
|
664
|
+
void bn_divmod58(bignum256 *a, uint32_t *r)
|
|
665
|
+
{
|
|
666
|
+
int i;
|
|
667
|
+
uint32_t rem, tmp;
|
|
668
|
+
rem = a->val[8] % 58;
|
|
669
|
+
a->val[8] /= 58;
|
|
670
|
+
for (i = 7; i >= 0; i--) {
|
|
671
|
+
// invariants:
|
|
672
|
+
// rem = old(a) >> 30(i+1) % 58
|
|
673
|
+
// a[i+1..8] = old(a[i+1..8])/58
|
|
674
|
+
// a[0..i] = old(a[0..i])
|
|
675
|
+
// 2^30 == 18512790*58 + 4
|
|
676
|
+
tmp = rem * 4 + a->val[i];
|
|
677
|
+
// set a[i] = (rem * 2^30 + a[i])/58
|
|
678
|
+
// = rem * 18512790 + (rem * 4 + a[i])/58
|
|
679
|
+
a->val[i] = rem * 18512790 + (tmp / 58);
|
|
680
|
+
// set rem = (rem * 2^30 + a[i]) mod 58
|
|
681
|
+
// = (rem * 4 + a[i]) mod 58
|
|
682
|
+
rem = tmp % 58;
|
|
683
|
+
}
|
|
684
|
+
*r = rem;
|
|
685
|
+
}
|
|
686
|
+
|
|
687
|
+
// a / 1000 = a (+r)
|
|
688
|
+
void bn_divmod1000(bignum256 *a, uint32_t *r)
|
|
689
|
+
{
|
|
690
|
+
int i;
|
|
691
|
+
uint32_t rem, tmp;
|
|
692
|
+
rem = a->val[8] % 1000;
|
|
693
|
+
a->val[8] /= 1000;
|
|
694
|
+
for (i = 7; i >= 0; i--) {
|
|
695
|
+
// invariants:
|
|
696
|
+
// rem = old(a) >> 30(i+1) % 1000
|
|
697
|
+
// a[i+1..8] = old(a[i+1..8])/1000
|
|
698
|
+
// a[0..i] = old(a[0..i])
|
|
699
|
+
// 2^30 == 1073741*1000 + 824
|
|
700
|
+
tmp = rem * 824 + a->val[i];
|
|
701
|
+
// set a[i] = (rem * 2^30 + a[i])/1000
|
|
702
|
+
// = rem * 1073741 + (rem * 824 + a[i])/1000
|
|
703
|
+
a->val[i] = rem * 1073741 + (tmp / 1000);
|
|
704
|
+
// set rem = (rem * 2^30 + a[i]) mod 1000
|
|
705
|
+
// = (rem * 824 + a[i]) mod 1000
|
|
706
|
+
rem = tmp % 1000;
|
|
707
|
+
}
|
|
708
|
+
*r = rem;
|
|
709
|
+
}
|
|
710
|
+
|
|
711
|
+
size_t bn_format(const bignum256 *amnt, const char *prefix, const char *suffix, unsigned int decimals, int exponent, bool trailing, char *out, size_t outlen)
|
|
712
|
+
{
|
|
713
|
+
// sanity check, 2**256 ~ 10**77; we should never need decimals/exponent bigger than that
|
|
714
|
+
if (decimals > 80 || exponent < -20 || exponent > 80) {
|
|
715
|
+
memzero(out, outlen);
|
|
716
|
+
return 0;
|
|
717
|
+
}
|
|
718
|
+
|
|
719
|
+
size_t prefixlen = prefix ? strlen(prefix) : 0;
|
|
720
|
+
size_t suffixlen = suffix ? strlen(suffix) : 0;
|
|
721
|
+
|
|
722
|
+
/* add prefix to beginning of out buffer */
|
|
723
|
+
if (prefixlen) {
|
|
724
|
+
memcpy(out, prefix, prefixlen);
|
|
725
|
+
}
|
|
726
|
+
/* add suffix to end of out buffer */
|
|
727
|
+
if (suffixlen) {
|
|
728
|
+
memcpy(&out[outlen - suffixlen - 1], suffix, suffixlen);
|
|
729
|
+
}
|
|
730
|
+
/* nul terminate (even if suffix = NULL) */
|
|
731
|
+
out[outlen - 1] = '\0';
|
|
732
|
+
|
|
733
|
+
/* fill number between prefix and suffix (between start and end) */
|
|
734
|
+
char *start = &out[prefixlen], *end = &out[outlen - suffixlen - 1];
|
|
735
|
+
char *str = end;
|
|
736
|
+
|
|
737
|
+
#define BN_FORMAT_PUSH_CHECKED(c) \
|
|
738
|
+
do { \
|
|
739
|
+
if (str == start) return 0; \
|
|
740
|
+
*--str = (c); \
|
|
741
|
+
} while (0)
|
|
742
|
+
|
|
743
|
+
#define BN_FORMAT_PUSH(n) \
|
|
744
|
+
do { \
|
|
745
|
+
if (exponent < 0) { \
|
|
746
|
+
exponent++; \
|
|
747
|
+
} else { \
|
|
748
|
+
if ((n) > 0 || trailing || str != end || decimals <= 1) { \
|
|
749
|
+
BN_FORMAT_PUSH_CHECKED('0' + (n)); \
|
|
750
|
+
} \
|
|
751
|
+
if (decimals > 0 && decimals-- == 1) { \
|
|
752
|
+
BN_FORMAT_PUSH_CHECKED('.'); \
|
|
753
|
+
} \
|
|
754
|
+
} \
|
|
755
|
+
} while (0)
|
|
756
|
+
|
|
757
|
+
bignum256 val;
|
|
758
|
+
memcpy(&val, amnt, sizeof(bignum256));
|
|
759
|
+
|
|
760
|
+
if (bn_is_zero(&val)) {
|
|
761
|
+
exponent = 0;
|
|
762
|
+
}
|
|
763
|
+
|
|
764
|
+
for (; exponent > 0; exponent--) {
|
|
765
|
+
BN_FORMAT_PUSH(0);
|
|
766
|
+
}
|
|
767
|
+
|
|
768
|
+
unsigned int digits = bn_digitcount(&val);
|
|
769
|
+
for (unsigned int i = 0; i < digits / 3; i++) {
|
|
770
|
+
uint32_t limb;
|
|
771
|
+
bn_divmod1000(&val, &limb);
|
|
772
|
+
|
|
773
|
+
BN_FORMAT_PUSH(limb % 10);
|
|
774
|
+
limb /= 10;
|
|
775
|
+
BN_FORMAT_PUSH(limb % 10);
|
|
776
|
+
limb /= 10;
|
|
777
|
+
BN_FORMAT_PUSH(limb % 10);
|
|
778
|
+
}
|
|
779
|
+
|
|
780
|
+
if (digits % 3 != 0) {
|
|
781
|
+
uint32_t limb;
|
|
782
|
+
bn_divmod1000(&val, &limb);
|
|
783
|
+
|
|
784
|
+
switch (digits % 3) {
|
|
785
|
+
case 2:
|
|
786
|
+
BN_FORMAT_PUSH(limb % 10);
|
|
787
|
+
limb /= 10;
|
|
788
|
+
//-fallthrough
|
|
789
|
+
|
|
790
|
+
case 1:
|
|
791
|
+
BN_FORMAT_PUSH(limb % 10);
|
|
792
|
+
break;
|
|
793
|
+
}
|
|
794
|
+
}
|
|
795
|
+
|
|
796
|
+
while (decimals > 0 || str[0] == '\0' || str[0] == '.') {
|
|
797
|
+
BN_FORMAT_PUSH(0);
|
|
798
|
+
}
|
|
799
|
+
|
|
800
|
+
/* finally move number to &out[prefixlen] to close the gap between
|
|
801
|
+
* prefix and str. len is length of number + suffix + traling 0
|
|
802
|
+
*/
|
|
803
|
+
size_t len = &out[outlen] - str;
|
|
804
|
+
memmove(&out[prefixlen], str, len);
|
|
805
|
+
|
|
806
|
+
/* return length of number including prefix and suffix without trailing 0 */
|
|
807
|
+
return prefixlen + len - 1;
|
|
808
|
+
}
|