@onekeyfe/react-native-lite-card 6.7.0-6 → 6.7.0-60
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 +134 -43
- package/ReactNativeLiteCard.podspec +31 -2
- package/android/build.gradle +8 -0
- package/android/consumer-rules.pro +4 -0
- package/android/src/main/cpp/CMakeLists.txt +6 -2
- package/android/src/main/java/com/onekeyfe/reactnativelitecard/ReactNativeLiteCardModule.kt +60 -49
- 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 +117 -39
- 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 +24 -2
- package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/nfc/Connection.kt +46 -19
- package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/nfc/GPCAPDUGenerator.kt +2 -2
- package/ios/Classes/OKLiteCommand/OKLiteCommandTool.m +38 -1
- package/ios/Classes/OKNFCBridge.mm +24 -1
- package/ios/Classes/OKNFTLite/OKLiteV1.m +20 -10
- package/ios/Classes/OKNFTLite/OKLiteV2.m +13 -5
- package/ios/Classes/OKNFTLite/OKNFCManager.h +2 -2
- package/ios/Classes/OKNFTLite/OKNFCManager.m +110 -18
- package/ios/ReactNativeLiteCard.mm +23 -11
- package/lib/module/index.js +4 -4
- package/lib/typescript/src/NativeReactNativeLiteCard.d.ts +4 -4
- package/lib/typescript/src/index.d.ts +2 -2
- package/package.json +9 -8
- package/sdk/CMakeLists.txt +121 -0
- package/sdk/README.md +190 -0
- package/sdk/android/implJni.cpp +216 -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/scripts/generate-source-id.rb +22 -0
- package/sdk/source-id-manifest.txt +19 -0
- package/sdk/source-id.cmake +31 -0
- package/sdk/src/ApduBuilder.cpp +332 -0
- package/sdk/src/GPChannelSDK.cpp +258 -0
- package/sdk/src/random.c +25 -0
- package/sdk/src/version.c +3 -0
- package/sdk/tests/android/GPChannelProxy.java +55 -0
- package/sdk/tests/android_verify.py +124 -0
- package/sdk/tests/safety.cpp +757 -0
- package/sdk/tests/verify.py +284 -0
- package/src/NativeReactNativeLiteCard.ts +4 -2
- package/src/index.tsx +14 -3
- 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,1314 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Copyright (c) 2000-2001 Aaron D. Gifford
|
|
3
|
+
* Copyright (c) 2013-2014 Pavol Rusnak
|
|
4
|
+
* All rights reserved.
|
|
5
|
+
*
|
|
6
|
+
* Redistribution and use in source and binary forms, with or without
|
|
7
|
+
* modification, are permitted provided that the following conditions
|
|
8
|
+
* are met:
|
|
9
|
+
* 1. Redistributions of source code must retain the above copyright
|
|
10
|
+
* notice, this list of conditions and the following disclaimer.
|
|
11
|
+
* 2. Redistributions in binary form must reproduce the above copyright
|
|
12
|
+
* notice, this list of conditions and the following disclaimer in the
|
|
13
|
+
* documentation and/or other materials provided with the distribution.
|
|
14
|
+
* 3. Neither the name of the copyright holder nor the names of contributors
|
|
15
|
+
* may be used to endorse or promote products derived from this software
|
|
16
|
+
* without specific prior written permission.
|
|
17
|
+
*
|
|
18
|
+
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
|
|
19
|
+
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
20
|
+
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
21
|
+
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
|
|
22
|
+
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
23
|
+
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
24
|
+
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
25
|
+
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
26
|
+
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
27
|
+
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
28
|
+
* SUCH DAMAGE.
|
|
29
|
+
*/
|
|
30
|
+
|
|
31
|
+
#include <string.h>
|
|
32
|
+
#include <stdint.h>
|
|
33
|
+
#include <TrezorCrypto/sha2.h>
|
|
34
|
+
#include <TrezorCrypto/memzero.h>
|
|
35
|
+
|
|
36
|
+
/*
|
|
37
|
+
* ASSERT NOTE:
|
|
38
|
+
* Some sanity checking code is included using assert(). On my FreeBSD
|
|
39
|
+
* system, this additional code can be removed by compiling with NDEBUG
|
|
40
|
+
* defined. Check your own systems manpage on assert() to see how to
|
|
41
|
+
* compile WITHOUT the sanity checking code on your system.
|
|
42
|
+
*
|
|
43
|
+
* UNROLLED TRANSFORM LOOP NOTE:
|
|
44
|
+
* You can define SHA2_UNROLL_TRANSFORM to use the unrolled transform
|
|
45
|
+
* loop version for the hash transform rounds (defined using macros
|
|
46
|
+
* later in this file). Either define on the command line, for example:
|
|
47
|
+
*
|
|
48
|
+
* cc -DSHA2_UNROLL_TRANSFORM -o sha2 sha2.c sha2prog.c
|
|
49
|
+
*
|
|
50
|
+
* or define below:
|
|
51
|
+
*
|
|
52
|
+
* #define SHA2_UNROLL_TRANSFORM
|
|
53
|
+
*
|
|
54
|
+
*/
|
|
55
|
+
|
|
56
|
+
|
|
57
|
+
/*** SHA-256/384/512 Machine Architecture Definitions *****************/
|
|
58
|
+
/*
|
|
59
|
+
* BYTE_ORDER NOTE:
|
|
60
|
+
*
|
|
61
|
+
* Please make sure that your system defines BYTE_ORDER. If your
|
|
62
|
+
* architecture is little-endian, make sure it also defines
|
|
63
|
+
* LITTLE_ENDIAN and that the two (BYTE_ORDER and LITTLE_ENDIAN) are
|
|
64
|
+
* equivilent.
|
|
65
|
+
*
|
|
66
|
+
* If your system does not define the above, then you can do so by
|
|
67
|
+
* hand like this:
|
|
68
|
+
*
|
|
69
|
+
* #define LITTLE_ENDIAN 1234
|
|
70
|
+
* #define BIG_ENDIAN 4321
|
|
71
|
+
*
|
|
72
|
+
* And for little-endian machines, add:
|
|
73
|
+
*
|
|
74
|
+
* #define BYTE_ORDER LITTLE_ENDIAN
|
|
75
|
+
*
|
|
76
|
+
* Or for big-endian machines:
|
|
77
|
+
*
|
|
78
|
+
* #define BYTE_ORDER BIG_ENDIAN
|
|
79
|
+
*
|
|
80
|
+
* The FreeBSD machine this was written on defines BYTE_ORDER
|
|
81
|
+
* appropriately by including <sys/types.h> (which in turn includes
|
|
82
|
+
* <machine/endian.h> where the appropriate definitions are actually
|
|
83
|
+
* made).
|
|
84
|
+
*/
|
|
85
|
+
|
|
86
|
+
#if !defined(BYTE_ORDER) || (BYTE_ORDER != LITTLE_ENDIAN && BYTE_ORDER != BIG_ENDIAN)
|
|
87
|
+
#error Define BYTE_ORDER to be equal to either LITTLE_ENDIAN or BIG_ENDIAN
|
|
88
|
+
#endif
|
|
89
|
+
|
|
90
|
+
typedef uint8_t sha2_byte; /* Exactly 1 byte */
|
|
91
|
+
typedef uint32_t sha2_word32; /* Exactly 4 bytes */
|
|
92
|
+
typedef uint64_t sha2_word64; /* Exactly 8 bytes */
|
|
93
|
+
|
|
94
|
+
/*** SHA-256/384/512 Various Length Definitions ***********************/
|
|
95
|
+
/* NOTE: Most of these are in sha2.h */
|
|
96
|
+
#define SHA1_SHORT_BLOCK_LENGTH (SHA1_BLOCK_LENGTH - 8)
|
|
97
|
+
#define SHA256_SHORT_BLOCK_LENGTH (SHA256_BLOCK_LENGTH - 8)
|
|
98
|
+
#define SHA512_SHORT_BLOCK_LENGTH (SHA512_BLOCK_LENGTH - 16)
|
|
99
|
+
|
|
100
|
+
/*
|
|
101
|
+
* Macro for incrementally adding the unsigned 64-bit integer n to the
|
|
102
|
+
* unsigned 128-bit integer (represented using a two-element array of
|
|
103
|
+
* 64-bit words):
|
|
104
|
+
*/
|
|
105
|
+
#define ADDINC128(w,n) { \
|
|
106
|
+
(w)[0] += (sha2_word64)(n); \
|
|
107
|
+
if ((w)[0] < (n)) { \
|
|
108
|
+
(w)[1]++; \
|
|
109
|
+
} \
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
#define MEMCPY_BCOPY(d,s,l) memcpy((d), (s), (l))
|
|
113
|
+
|
|
114
|
+
/*** THE SIX LOGICAL FUNCTIONS ****************************************/
|
|
115
|
+
/*
|
|
116
|
+
* Bit shifting and rotation (used by the six SHA-XYZ logical functions:
|
|
117
|
+
*
|
|
118
|
+
* NOTE: In the original SHA-256/384/512 document, the shift-right
|
|
119
|
+
* function was named R and the rotate-right function was called S.
|
|
120
|
+
* (See: http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf on the
|
|
121
|
+
* web.)
|
|
122
|
+
*
|
|
123
|
+
* The newer NIST FIPS 180-2 document uses a much clearer naming
|
|
124
|
+
* scheme, SHR for shift-right, ROTR for rotate-right, and ROTL for
|
|
125
|
+
* rotate-left. (See:
|
|
126
|
+
* http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
|
|
127
|
+
* on the web.)
|
|
128
|
+
*
|
|
129
|
+
* WARNING: These macros must be used cautiously, since they reference
|
|
130
|
+
* supplied parameters sometimes more than once, and thus could have
|
|
131
|
+
* unexpected side-effects if used without taking this into account.
|
|
132
|
+
*/
|
|
133
|
+
|
|
134
|
+
/* Shift-right (used in SHA-256, SHA-384, and SHA-512): */
|
|
135
|
+
#define SHR(b,x) ((x) >> (b))
|
|
136
|
+
/* 32-bit Rotate-right (used in SHA-256): */
|
|
137
|
+
#define ROTR32(b,x) (((x) >> (b)) | ((x) << (32 - (b))))
|
|
138
|
+
/* 64-bit Rotate-right (used in SHA-384 and SHA-512): */
|
|
139
|
+
#define ROTR64(b,x) (((x) >> (b)) | ((x) << (64 - (b))))
|
|
140
|
+
/* 32-bit Rotate-left (used in SHA-1): */
|
|
141
|
+
#define ROTL32(b,x) (((x) << (b)) | ((x) >> (32 - (b))))
|
|
142
|
+
|
|
143
|
+
/* Two of six logical functions used in SHA-1, SHA-256, SHA-384, and SHA-512: */
|
|
144
|
+
#define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
|
|
145
|
+
#define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
|
|
146
|
+
|
|
147
|
+
/* Function used in SHA-1: */
|
|
148
|
+
#define Parity(x,y,z) ((x) ^ (y) ^ (z))
|
|
149
|
+
|
|
150
|
+
/* Four of six logical functions used in SHA-256: */
|
|
151
|
+
#define Sigma0_256(x) (ROTR32(2, (x)) ^ ROTR32(13, (x)) ^ ROTR32(22, (x)))
|
|
152
|
+
#define Sigma1_256(x) (ROTR32(6, (x)) ^ ROTR32(11, (x)) ^ ROTR32(25, (x)))
|
|
153
|
+
#define sigma0_256(x) (ROTR32(7, (x)) ^ ROTR32(18, (x)) ^ SHR(3 , (x)))
|
|
154
|
+
#define sigma1_256(x) (ROTR32(17, (x)) ^ ROTR32(19, (x)) ^ SHR(10, (x)))
|
|
155
|
+
|
|
156
|
+
/* Four of six logical functions used in SHA-384 and SHA-512: */
|
|
157
|
+
#define Sigma0_512(x) (ROTR64(28, (x)) ^ ROTR64(34, (x)) ^ ROTR64(39, (x)))
|
|
158
|
+
#define Sigma1_512(x) (ROTR64(14, (x)) ^ ROTR64(18, (x)) ^ ROTR64(41, (x)))
|
|
159
|
+
#define sigma0_512(x) (ROTR64( 1, (x)) ^ ROTR64( 8, (x)) ^ SHR( 7, (x)))
|
|
160
|
+
#define sigma1_512(x) (ROTR64(19, (x)) ^ ROTR64(61, (x)) ^ SHR( 6, (x)))
|
|
161
|
+
|
|
162
|
+
/*** INTERNAL FUNCTION PROTOTYPES *************************************/
|
|
163
|
+
/* NOTE: These should not be accessed directly from outside this
|
|
164
|
+
* library -- they are intended for private internal visibility/use
|
|
165
|
+
* only.
|
|
166
|
+
*/
|
|
167
|
+
static void sha512_Last(SHA512_CTX*);
|
|
168
|
+
|
|
169
|
+
|
|
170
|
+
/*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
|
|
171
|
+
|
|
172
|
+
/* Hash constant words K for SHA-1: */
|
|
173
|
+
#define K1_0_TO_19 0x5a827999UL
|
|
174
|
+
#define K1_20_TO_39 0x6ed9eba1UL
|
|
175
|
+
#define K1_40_TO_59 0x8f1bbcdcUL
|
|
176
|
+
#define K1_60_TO_79 0xca62c1d6UL
|
|
177
|
+
|
|
178
|
+
/* Initial hash value H for SHA-1: */
|
|
179
|
+
const sha2_word32 sha1_initial_hash_value[SHA1_DIGEST_LENGTH / sizeof(sha2_word32)] = {
|
|
180
|
+
0x67452301UL,
|
|
181
|
+
0xefcdab89UL,
|
|
182
|
+
0x98badcfeUL,
|
|
183
|
+
0x10325476UL,
|
|
184
|
+
0xc3d2e1f0UL
|
|
185
|
+
};
|
|
186
|
+
|
|
187
|
+
/* Hash constant words K for SHA-256: */
|
|
188
|
+
static const sha2_word32 K256[64] = {
|
|
189
|
+
0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
|
|
190
|
+
0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
|
|
191
|
+
0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,
|
|
192
|
+
0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL,
|
|
193
|
+
0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
|
|
194
|
+
0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL,
|
|
195
|
+
0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL,
|
|
196
|
+
0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL,
|
|
197
|
+
0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL,
|
|
198
|
+
0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
|
|
199
|
+
0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL,
|
|
200
|
+
0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL,
|
|
201
|
+
0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL,
|
|
202
|
+
0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL,
|
|
203
|
+
0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
|
|
204
|
+
0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
|
|
205
|
+
};
|
|
206
|
+
|
|
207
|
+
/* Initial hash value H for SHA-256: */
|
|
208
|
+
const sha2_word32 sha256_initial_hash_value[8] = {
|
|
209
|
+
0x6a09e667UL,
|
|
210
|
+
0xbb67ae85UL,
|
|
211
|
+
0x3c6ef372UL,
|
|
212
|
+
0xa54ff53aUL,
|
|
213
|
+
0x510e527fUL,
|
|
214
|
+
0x9b05688cUL,
|
|
215
|
+
0x1f83d9abUL,
|
|
216
|
+
0x5be0cd19UL
|
|
217
|
+
};
|
|
218
|
+
|
|
219
|
+
/* Hash constant words K for SHA-384 and SHA-512: */
|
|
220
|
+
static const sha2_word64 K512[80] = {
|
|
221
|
+
0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,
|
|
222
|
+
0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
|
|
223
|
+
0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
|
|
224
|
+
0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
|
|
225
|
+
0xd807aa98a3030242ULL, 0x12835b0145706fbeULL,
|
|
226
|
+
0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
|
|
227
|
+
0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL,
|
|
228
|
+
0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
|
|
229
|
+
0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
|
|
230
|
+
0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,
|
|
231
|
+
0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL,
|
|
232
|
+
0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
|
|
233
|
+
0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL,
|
|
234
|
+
0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,
|
|
235
|
+
0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
|
|
236
|
+
0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
|
|
237
|
+
0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL,
|
|
238
|
+
0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
|
|
239
|
+
0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL,
|
|
240
|
+
0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
|
|
241
|
+
0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
|
|
242
|
+
0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,
|
|
243
|
+
0xd192e819d6ef5218ULL, 0xd69906245565a910ULL,
|
|
244
|
+
0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
|
|
245
|
+
0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL,
|
|
246
|
+
0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,
|
|
247
|
+
0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
|
|
248
|
+
0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
|
|
249
|
+
0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL,
|
|
250
|
+
0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
|
|
251
|
+
0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL,
|
|
252
|
+
0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
|
|
253
|
+
0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
|
|
254
|
+
0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,
|
|
255
|
+
0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL,
|
|
256
|
+
0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
|
|
257
|
+
0x28db77f523047d84ULL, 0x32caab7b40c72493ULL,
|
|
258
|
+
0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,
|
|
259
|
+
0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
|
|
260
|
+
0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL
|
|
261
|
+
};
|
|
262
|
+
|
|
263
|
+
/* Initial hash value H for SHA-512 */
|
|
264
|
+
const sha2_word64 sha512_initial_hash_value[8] = {
|
|
265
|
+
0x6a09e667f3bcc908ULL,
|
|
266
|
+
0xbb67ae8584caa73bULL,
|
|
267
|
+
0x3c6ef372fe94f82bULL,
|
|
268
|
+
0xa54ff53a5f1d36f1ULL,
|
|
269
|
+
0x510e527fade682d1ULL,
|
|
270
|
+
0x9b05688c2b3e6c1fULL,
|
|
271
|
+
0x1f83d9abfb41bd6bULL,
|
|
272
|
+
0x5be0cd19137e2179ULL
|
|
273
|
+
};
|
|
274
|
+
|
|
275
|
+
const sha2_word64 sha512_256_initial_hash_value[8] = {
|
|
276
|
+
0x22312194fc2bf72cULL,
|
|
277
|
+
0x9f555fa3c84c64c2ULL,
|
|
278
|
+
0x2393b86b6f53b151ULL,
|
|
279
|
+
0x963877195940eabdULL,
|
|
280
|
+
0x96283ee2a88effe3ULL,
|
|
281
|
+
0xbe5e1e2553863992ULL,
|
|
282
|
+
0x2b0199fc2c85b8aaULL,
|
|
283
|
+
0x0eb72ddc81c52ca2ULL,
|
|
284
|
+
};
|
|
285
|
+
|
|
286
|
+
/*
|
|
287
|
+
* Constant used by SHA256/384/512_End() functions for converting the
|
|
288
|
+
* digest to a readable hexadecimal character string:
|
|
289
|
+
*/
|
|
290
|
+
static const char *sha2_hex_digits = "0123456789abcdef";
|
|
291
|
+
|
|
292
|
+
|
|
293
|
+
/*** SHA-1: ***********************************************************/
|
|
294
|
+
void sha1_Init(SHA1_CTX* context) {
|
|
295
|
+
MEMCPY_BCOPY(context->state, sha1_initial_hash_value, SHA1_DIGEST_LENGTH);
|
|
296
|
+
memzero(context->buffer, SHA1_BLOCK_LENGTH);
|
|
297
|
+
context->bitcount = 0;
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
#ifdef SHA2_UNROLL_TRANSFORM
|
|
301
|
+
|
|
302
|
+
/* Unrolled SHA-1 round macros: */
|
|
303
|
+
|
|
304
|
+
#define ROUND1_0_TO_15(a,b,c,d,e) \
|
|
305
|
+
(e) = ROTL32(5, (a)) + Ch((b), (c), (d)) + (e) + \
|
|
306
|
+
K1_0_TO_19 + ( W1[j] = *data++ ); \
|
|
307
|
+
(b) = ROTL32(30, (b)); \
|
|
308
|
+
j++;
|
|
309
|
+
|
|
310
|
+
#define ROUND1_16_TO_19(a,b,c,d,e) \
|
|
311
|
+
T1 = W1[(j+13)&0x0f] ^ W1[(j+8)&0x0f] ^ W1[(j+2)&0x0f] ^ W1[j&0x0f]; \
|
|
312
|
+
(e) = ROTL32(5, a) + Ch(b,c,d) + e + K1_0_TO_19 + ( W1[j&0x0f] = ROTL32(1, T1) ); \
|
|
313
|
+
(b) = ROTL32(30, b); \
|
|
314
|
+
j++;
|
|
315
|
+
|
|
316
|
+
#define ROUND1_20_TO_39(a,b,c,d,e) \
|
|
317
|
+
T1 = W1[(j+13)&0x0f] ^ W1[(j+8)&0x0f] ^ W1[(j+2)&0x0f] ^ W1[j&0x0f]; \
|
|
318
|
+
(e) = ROTL32(5, a) + Parity(b,c,d) + e + K1_20_TO_39 + ( W1[j&0x0f] = ROTL32(1, T1) ); \
|
|
319
|
+
(b) = ROTL32(30, b); \
|
|
320
|
+
j++;
|
|
321
|
+
|
|
322
|
+
#define ROUND1_40_TO_59(a,b,c,d,e) \
|
|
323
|
+
T1 = W1[(j+13)&0x0f] ^ W1[(j+8)&0x0f] ^ W1[(j+2)&0x0f] ^ W1[j&0x0f]; \
|
|
324
|
+
(e) = ROTL32(5, a) + Maj(b,c,d) + e + K1_40_TO_59 + ( W1[j&0x0f] = ROTL32(1, T1) ); \
|
|
325
|
+
(b) = ROTL32(30, b); \
|
|
326
|
+
j++;
|
|
327
|
+
|
|
328
|
+
#define ROUND1_60_TO_79(a,b,c,d,e) \
|
|
329
|
+
T1 = W1[(j+13)&0x0f] ^ W1[(j+8)&0x0f] ^ W1[(j+2)&0x0f] ^ W1[j&0x0f]; \
|
|
330
|
+
(e) = ROTL32(5, a) + Parity(b,c,d) + e + K1_60_TO_79 + ( W1[j&0x0f] = ROTL32(1, T1) ); \
|
|
331
|
+
(b) = ROTL32(30, b); \
|
|
332
|
+
j++;
|
|
333
|
+
|
|
334
|
+
void sha1_Transform(const sha2_word32* state_in, const sha2_word32* data, sha2_word32* state_out) {
|
|
335
|
+
sha2_word32 a, b, c, d, e;
|
|
336
|
+
sha2_word32 T1;
|
|
337
|
+
sha2_word32 W1[16];
|
|
338
|
+
int j;
|
|
339
|
+
|
|
340
|
+
/* Initialize registers with the prev. intermediate value */
|
|
341
|
+
a = state_in[0];
|
|
342
|
+
b = state_in[1];
|
|
343
|
+
c = state_in[2];
|
|
344
|
+
d = state_in[3];
|
|
345
|
+
e = state_in[4];
|
|
346
|
+
|
|
347
|
+
j = 0;
|
|
348
|
+
|
|
349
|
+
/* Rounds 0 to 15 unrolled: */
|
|
350
|
+
ROUND1_0_TO_15(a,b,c,d,e);
|
|
351
|
+
ROUND1_0_TO_15(e,a,b,c,d);
|
|
352
|
+
ROUND1_0_TO_15(d,e,a,b,c);
|
|
353
|
+
ROUND1_0_TO_15(c,d,e,a,b);
|
|
354
|
+
ROUND1_0_TO_15(b,c,d,e,a);
|
|
355
|
+
ROUND1_0_TO_15(a,b,c,d,e);
|
|
356
|
+
ROUND1_0_TO_15(e,a,b,c,d);
|
|
357
|
+
ROUND1_0_TO_15(d,e,a,b,c);
|
|
358
|
+
ROUND1_0_TO_15(c,d,e,a,b);
|
|
359
|
+
ROUND1_0_TO_15(b,c,d,e,a);
|
|
360
|
+
ROUND1_0_TO_15(a,b,c,d,e);
|
|
361
|
+
ROUND1_0_TO_15(e,a,b,c,d);
|
|
362
|
+
ROUND1_0_TO_15(d,e,a,b,c);
|
|
363
|
+
ROUND1_0_TO_15(c,d,e,a,b);
|
|
364
|
+
ROUND1_0_TO_15(b,c,d,e,a);
|
|
365
|
+
ROUND1_0_TO_15(a,b,c,d,e);
|
|
366
|
+
|
|
367
|
+
/* Rounds 16 to 19 unrolled: */
|
|
368
|
+
ROUND1_16_TO_19(e,a,b,c,d);
|
|
369
|
+
ROUND1_16_TO_19(d,e,a,b,c);
|
|
370
|
+
ROUND1_16_TO_19(c,d,e,a,b);
|
|
371
|
+
ROUND1_16_TO_19(b,c,d,e,a);
|
|
372
|
+
|
|
373
|
+
/* Rounds 20 to 39 unrolled: */
|
|
374
|
+
ROUND1_20_TO_39(a,b,c,d,e);
|
|
375
|
+
ROUND1_20_TO_39(e,a,b,c,d);
|
|
376
|
+
ROUND1_20_TO_39(d,e,a,b,c);
|
|
377
|
+
ROUND1_20_TO_39(c,d,e,a,b);
|
|
378
|
+
ROUND1_20_TO_39(b,c,d,e,a);
|
|
379
|
+
ROUND1_20_TO_39(a,b,c,d,e);
|
|
380
|
+
ROUND1_20_TO_39(e,a,b,c,d);
|
|
381
|
+
ROUND1_20_TO_39(d,e,a,b,c);
|
|
382
|
+
ROUND1_20_TO_39(c,d,e,a,b);
|
|
383
|
+
ROUND1_20_TO_39(b,c,d,e,a);
|
|
384
|
+
ROUND1_20_TO_39(a,b,c,d,e);
|
|
385
|
+
ROUND1_20_TO_39(e,a,b,c,d);
|
|
386
|
+
ROUND1_20_TO_39(d,e,a,b,c);
|
|
387
|
+
ROUND1_20_TO_39(c,d,e,a,b);
|
|
388
|
+
ROUND1_20_TO_39(b,c,d,e,a);
|
|
389
|
+
ROUND1_20_TO_39(a,b,c,d,e);
|
|
390
|
+
ROUND1_20_TO_39(e,a,b,c,d);
|
|
391
|
+
ROUND1_20_TO_39(d,e,a,b,c);
|
|
392
|
+
ROUND1_20_TO_39(c,d,e,a,b);
|
|
393
|
+
ROUND1_20_TO_39(b,c,d,e,a);
|
|
394
|
+
|
|
395
|
+
/* Rounds 40 to 59 unrolled: */
|
|
396
|
+
ROUND1_40_TO_59(a,b,c,d,e);
|
|
397
|
+
ROUND1_40_TO_59(e,a,b,c,d);
|
|
398
|
+
ROUND1_40_TO_59(d,e,a,b,c);
|
|
399
|
+
ROUND1_40_TO_59(c,d,e,a,b);
|
|
400
|
+
ROUND1_40_TO_59(b,c,d,e,a);
|
|
401
|
+
ROUND1_40_TO_59(a,b,c,d,e);
|
|
402
|
+
ROUND1_40_TO_59(e,a,b,c,d);
|
|
403
|
+
ROUND1_40_TO_59(d,e,a,b,c);
|
|
404
|
+
ROUND1_40_TO_59(c,d,e,a,b);
|
|
405
|
+
ROUND1_40_TO_59(b,c,d,e,a);
|
|
406
|
+
ROUND1_40_TO_59(a,b,c,d,e);
|
|
407
|
+
ROUND1_40_TO_59(e,a,b,c,d);
|
|
408
|
+
ROUND1_40_TO_59(d,e,a,b,c);
|
|
409
|
+
ROUND1_40_TO_59(c,d,e,a,b);
|
|
410
|
+
ROUND1_40_TO_59(b,c,d,e,a);
|
|
411
|
+
ROUND1_40_TO_59(a,b,c,d,e);
|
|
412
|
+
ROUND1_40_TO_59(e,a,b,c,d);
|
|
413
|
+
ROUND1_40_TO_59(d,e,a,b,c);
|
|
414
|
+
ROUND1_40_TO_59(c,d,e,a,b);
|
|
415
|
+
ROUND1_40_TO_59(b,c,d,e,a);
|
|
416
|
+
|
|
417
|
+
/* Rounds 60 to 79 unrolled: */
|
|
418
|
+
ROUND1_60_TO_79(a,b,c,d,e);
|
|
419
|
+
ROUND1_60_TO_79(e,a,b,c,d);
|
|
420
|
+
ROUND1_60_TO_79(d,e,a,b,c);
|
|
421
|
+
ROUND1_60_TO_79(c,d,e,a,b);
|
|
422
|
+
ROUND1_60_TO_79(b,c,d,e,a);
|
|
423
|
+
ROUND1_60_TO_79(a,b,c,d,e);
|
|
424
|
+
ROUND1_60_TO_79(e,a,b,c,d);
|
|
425
|
+
ROUND1_60_TO_79(d,e,a,b,c);
|
|
426
|
+
ROUND1_60_TO_79(c,d,e,a,b);
|
|
427
|
+
ROUND1_60_TO_79(b,c,d,e,a);
|
|
428
|
+
ROUND1_60_TO_79(a,b,c,d,e);
|
|
429
|
+
ROUND1_60_TO_79(e,a,b,c,d);
|
|
430
|
+
ROUND1_60_TO_79(d,e,a,b,c);
|
|
431
|
+
ROUND1_60_TO_79(c,d,e,a,b);
|
|
432
|
+
ROUND1_60_TO_79(b,c,d,e,a);
|
|
433
|
+
ROUND1_60_TO_79(a,b,c,d,e);
|
|
434
|
+
ROUND1_60_TO_79(e,a,b,c,d);
|
|
435
|
+
ROUND1_60_TO_79(d,e,a,b,c);
|
|
436
|
+
ROUND1_60_TO_79(c,d,e,a,b);
|
|
437
|
+
ROUND1_60_TO_79(b,c,d,e,a);
|
|
438
|
+
|
|
439
|
+
/* Compute the current intermediate hash value */
|
|
440
|
+
state_out[0] = state_in[0] + a;
|
|
441
|
+
state_out[1] = state_in[1] + b;
|
|
442
|
+
state_out[2] = state_in[2] + c;
|
|
443
|
+
state_out[3] = state_in[3] + d;
|
|
444
|
+
state_out[4] = state_in[4] + e;
|
|
445
|
+
|
|
446
|
+
/* Clean up */
|
|
447
|
+
a = b = c = d = e = T1 = 0;
|
|
448
|
+
}
|
|
449
|
+
|
|
450
|
+
#else /* SHA2_UNROLL_TRANSFORM */
|
|
451
|
+
|
|
452
|
+
void sha1_Transform(const sha2_word32* state_in, const sha2_word32* data, sha2_word32* state_out) {
|
|
453
|
+
sha2_word32 a, b, c, d, e;
|
|
454
|
+
sha2_word32 T1;
|
|
455
|
+
sha2_word32 W1[16];
|
|
456
|
+
int j;
|
|
457
|
+
|
|
458
|
+
/* Initialize registers with the prev. intermediate value */
|
|
459
|
+
a = state_in[0];
|
|
460
|
+
b = state_in[1];
|
|
461
|
+
c = state_in[2];
|
|
462
|
+
d = state_in[3];
|
|
463
|
+
e = state_in[4];
|
|
464
|
+
j = 0;
|
|
465
|
+
do {
|
|
466
|
+
T1 = ROTL32(5, a) + Ch(b, c, d) + e + K1_0_TO_19 + (W1[j] = *data++);
|
|
467
|
+
e = d;
|
|
468
|
+
d = c;
|
|
469
|
+
c = ROTL32(30, b);
|
|
470
|
+
b = a;
|
|
471
|
+
a = T1;
|
|
472
|
+
j++;
|
|
473
|
+
} while (j < 16);
|
|
474
|
+
|
|
475
|
+
do {
|
|
476
|
+
T1 = W1[(j+13)&0x0f] ^ W1[(j+8)&0x0f] ^ W1[(j+2)&0x0f] ^ W1[j&0x0f];
|
|
477
|
+
T1 = ROTL32(5, a) + Ch(b,c,d) + e + K1_0_TO_19 + (W1[j&0x0f] = ROTL32(1, T1));
|
|
478
|
+
e = d;
|
|
479
|
+
d = c;
|
|
480
|
+
c = ROTL32(30, b);
|
|
481
|
+
b = a;
|
|
482
|
+
a = T1;
|
|
483
|
+
j++;
|
|
484
|
+
} while (j < 20);
|
|
485
|
+
|
|
486
|
+
do {
|
|
487
|
+
T1 = W1[(j+13)&0x0f] ^ W1[(j+8)&0x0f] ^ W1[(j+2)&0x0f] ^ W1[j&0x0f];
|
|
488
|
+
T1 = ROTL32(5, a) + Parity(b,c,d) + e + K1_20_TO_39 + (W1[j&0x0f] = ROTL32(1, T1));
|
|
489
|
+
e = d;
|
|
490
|
+
d = c;
|
|
491
|
+
c = ROTL32(30, b);
|
|
492
|
+
b = a;
|
|
493
|
+
a = T1;
|
|
494
|
+
j++;
|
|
495
|
+
} while (j < 40);
|
|
496
|
+
|
|
497
|
+
do {
|
|
498
|
+
T1 = W1[(j+13)&0x0f] ^ W1[(j+8)&0x0f] ^ W1[(j+2)&0x0f] ^ W1[j&0x0f];
|
|
499
|
+
T1 = ROTL32(5, a) + Maj(b,c,d) + e + K1_40_TO_59 + (W1[j&0x0f] = ROTL32(1, T1));
|
|
500
|
+
e = d;
|
|
501
|
+
d = c;
|
|
502
|
+
c = ROTL32(30, b);
|
|
503
|
+
b = a;
|
|
504
|
+
a = T1;
|
|
505
|
+
j++;
|
|
506
|
+
} while (j < 60);
|
|
507
|
+
|
|
508
|
+
do {
|
|
509
|
+
T1 = W1[(j+13)&0x0f] ^ W1[(j+8)&0x0f] ^ W1[(j+2)&0x0f] ^ W1[j&0x0f];
|
|
510
|
+
T1 = ROTL32(5, a) + Parity(b,c,d) + e + K1_60_TO_79 + (W1[j&0x0f] = ROTL32(1, T1));
|
|
511
|
+
e = d;
|
|
512
|
+
d = c;
|
|
513
|
+
c = ROTL32(30, b);
|
|
514
|
+
b = a;
|
|
515
|
+
a = T1;
|
|
516
|
+
j++;
|
|
517
|
+
} while (j < 80);
|
|
518
|
+
|
|
519
|
+
|
|
520
|
+
/* Compute the current intermediate hash value */
|
|
521
|
+
state_out[0] = state_in[0] + a;
|
|
522
|
+
state_out[1] = state_in[1] + b;
|
|
523
|
+
state_out[2] = state_in[2] + c;
|
|
524
|
+
state_out[3] = state_in[3] + d;
|
|
525
|
+
state_out[4] = state_in[4] + e;
|
|
526
|
+
|
|
527
|
+
/* Clean up */
|
|
528
|
+
a = b = c = d = e = T1 = 0;
|
|
529
|
+
}
|
|
530
|
+
|
|
531
|
+
#endif /* SHA2_UNROLL_TRANSFORM */
|
|
532
|
+
|
|
533
|
+
void sha1_Update(SHA1_CTX* context, const sha2_byte *data, size_t len) {
|
|
534
|
+
unsigned int freespace, usedspace;
|
|
535
|
+
|
|
536
|
+
if (len == 0) {
|
|
537
|
+
/* Calling with no data is valid - we do nothing */
|
|
538
|
+
return;
|
|
539
|
+
}
|
|
540
|
+
|
|
541
|
+
usedspace = (context->bitcount >> 3) % SHA1_BLOCK_LENGTH;
|
|
542
|
+
if (usedspace > 0) {
|
|
543
|
+
/* Calculate how much free space is available in the buffer */
|
|
544
|
+
freespace = SHA1_BLOCK_LENGTH - usedspace;
|
|
545
|
+
|
|
546
|
+
if (len >= freespace) {
|
|
547
|
+
/* Fill the buffer completely and process it */
|
|
548
|
+
MEMCPY_BCOPY(((uint8_t*)context->buffer) + usedspace, data, freespace);
|
|
549
|
+
context->bitcount += freespace << 3;
|
|
550
|
+
len -= freespace;
|
|
551
|
+
data += freespace;
|
|
552
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
553
|
+
/* Convert TO host byte order */
|
|
554
|
+
for (int j = 0; j < 16; j++) {
|
|
555
|
+
REVERSE32(context->buffer[j],context->buffer[j]);
|
|
556
|
+
}
|
|
557
|
+
#endif
|
|
558
|
+
sha1_Transform(context->state, context->buffer, context->state);
|
|
559
|
+
} else {
|
|
560
|
+
/* The buffer is not yet full */
|
|
561
|
+
MEMCPY_BCOPY(((uint8_t*)context->buffer) + usedspace, data, len);
|
|
562
|
+
context->bitcount += len << 3;
|
|
563
|
+
/* Clean up: */
|
|
564
|
+
usedspace = freespace = 0;
|
|
565
|
+
return;
|
|
566
|
+
}
|
|
567
|
+
}
|
|
568
|
+
while (len >= SHA1_BLOCK_LENGTH) {
|
|
569
|
+
/* Process as many complete blocks as we can */
|
|
570
|
+
MEMCPY_BCOPY(context->buffer, data, SHA1_BLOCK_LENGTH);
|
|
571
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
572
|
+
/* Convert TO host byte order */
|
|
573
|
+
for (int j = 0; j < 16; j++) {
|
|
574
|
+
REVERSE32(context->buffer[j],context->buffer[j]);
|
|
575
|
+
}
|
|
576
|
+
#endif
|
|
577
|
+
sha1_Transform(context->state, context->buffer, context->state);
|
|
578
|
+
context->bitcount += SHA1_BLOCK_LENGTH << 3;
|
|
579
|
+
len -= SHA1_BLOCK_LENGTH;
|
|
580
|
+
data += SHA1_BLOCK_LENGTH;
|
|
581
|
+
}
|
|
582
|
+
if (len > 0) {
|
|
583
|
+
/* There's left-overs, so save 'em */
|
|
584
|
+
MEMCPY_BCOPY(context->buffer, data, len);
|
|
585
|
+
context->bitcount += len << 3;
|
|
586
|
+
}
|
|
587
|
+
/* Clean up: */
|
|
588
|
+
usedspace = freespace = 0;
|
|
589
|
+
}
|
|
590
|
+
|
|
591
|
+
void sha1_Final(SHA1_CTX* context, sha2_byte digest[]) {
|
|
592
|
+
unsigned int usedspace;
|
|
593
|
+
|
|
594
|
+
/* If no digest buffer is passed, we don't bother doing this: */
|
|
595
|
+
if (digest != (sha2_byte*)0) {
|
|
596
|
+
usedspace = (context->bitcount >> 3) % SHA1_BLOCK_LENGTH;
|
|
597
|
+
/* Begin padding with a 1 bit: */
|
|
598
|
+
((uint8_t*)context->buffer)[usedspace++] = 0x80;
|
|
599
|
+
|
|
600
|
+
if (usedspace > SHA1_SHORT_BLOCK_LENGTH) {
|
|
601
|
+
memzero(((uint8_t*)context->buffer) + usedspace, SHA1_BLOCK_LENGTH - usedspace);
|
|
602
|
+
|
|
603
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
604
|
+
/* Convert TO host byte order */
|
|
605
|
+
for (int j = 0; j < 16; j++) {
|
|
606
|
+
REVERSE32(context->buffer[j],context->buffer[j]);
|
|
607
|
+
}
|
|
608
|
+
#endif
|
|
609
|
+
/* Do second-to-last transform: */
|
|
610
|
+
sha1_Transform(context->state, context->buffer, context->state);
|
|
611
|
+
|
|
612
|
+
/* And prepare the last transform: */
|
|
613
|
+
usedspace = 0;
|
|
614
|
+
}
|
|
615
|
+
/* Set-up for the last transform: */
|
|
616
|
+
memzero(((uint8_t*)context->buffer) + usedspace, SHA1_SHORT_BLOCK_LENGTH - usedspace);
|
|
617
|
+
|
|
618
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
619
|
+
/* Convert TO host byte order */
|
|
620
|
+
for (int j = 0; j < 14; j++) {
|
|
621
|
+
REVERSE32(context->buffer[j],context->buffer[j]);
|
|
622
|
+
}
|
|
623
|
+
#endif
|
|
624
|
+
/* Set the bit count: */
|
|
625
|
+
context->buffer[14] = context->bitcount >> 32;
|
|
626
|
+
context->buffer[15] = context->bitcount & 0xffffffff;
|
|
627
|
+
|
|
628
|
+
/* Final transform: */
|
|
629
|
+
sha1_Transform(context->state, context->buffer, context->state);
|
|
630
|
+
|
|
631
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
632
|
+
/* Convert FROM host byte order */
|
|
633
|
+
for (int j = 0; j < 5; j++) {
|
|
634
|
+
REVERSE32(context->state[j],context->state[j]);
|
|
635
|
+
}
|
|
636
|
+
#endif
|
|
637
|
+
MEMCPY_BCOPY(digest, context->state, SHA1_DIGEST_LENGTH);
|
|
638
|
+
}
|
|
639
|
+
|
|
640
|
+
/* Clean up state data: */
|
|
641
|
+
memzero(context, sizeof(SHA1_CTX));
|
|
642
|
+
usedspace = 0;
|
|
643
|
+
}
|
|
644
|
+
|
|
645
|
+
char *sha1_End(SHA1_CTX* context, char buffer[]) {
|
|
646
|
+
sha2_byte digest[SHA1_DIGEST_LENGTH], *d = digest;
|
|
647
|
+
int i;
|
|
648
|
+
|
|
649
|
+
if (buffer != (char*)0) {
|
|
650
|
+
sha1_Final(context, digest);
|
|
651
|
+
|
|
652
|
+
for (i = 0; i < SHA1_DIGEST_LENGTH; i++) {
|
|
653
|
+
*buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
|
|
654
|
+
*buffer++ = sha2_hex_digits[*d & 0x0f];
|
|
655
|
+
d++;
|
|
656
|
+
}
|
|
657
|
+
*buffer = (char)0;
|
|
658
|
+
} else {
|
|
659
|
+
memzero(context, sizeof(SHA1_CTX));
|
|
660
|
+
}
|
|
661
|
+
memzero(digest, SHA1_DIGEST_LENGTH);
|
|
662
|
+
return buffer;
|
|
663
|
+
}
|
|
664
|
+
|
|
665
|
+
void sha1_Raw(const sha2_byte* data, size_t len, uint8_t digest[SHA1_DIGEST_LENGTH]) {
|
|
666
|
+
SHA1_CTX context;
|
|
667
|
+
sha1_Init(&context);
|
|
668
|
+
sha1_Update(&context, data, len);
|
|
669
|
+
sha1_Final(&context, digest);
|
|
670
|
+
}
|
|
671
|
+
|
|
672
|
+
char* sha1_Data(const sha2_byte* data, size_t len, char digest[SHA1_DIGEST_STRING_LENGTH]) {
|
|
673
|
+
SHA1_CTX context;
|
|
674
|
+
|
|
675
|
+
sha1_Init(&context);
|
|
676
|
+
sha1_Update(&context, data, len);
|
|
677
|
+
return sha1_End(&context, digest);
|
|
678
|
+
}
|
|
679
|
+
|
|
680
|
+
/*** SHA-256: *********************************************************/
|
|
681
|
+
void sha256_Init(SHA256_CTX* context) {
|
|
682
|
+
if (context == (SHA256_CTX*)0) {
|
|
683
|
+
return;
|
|
684
|
+
}
|
|
685
|
+
MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
|
|
686
|
+
memzero(context->buffer, SHA256_BLOCK_LENGTH);
|
|
687
|
+
context->bitcount = 0;
|
|
688
|
+
}
|
|
689
|
+
|
|
690
|
+
#ifdef SHA2_UNROLL_TRANSFORM
|
|
691
|
+
|
|
692
|
+
/* Unrolled SHA-256 round macros: */
|
|
693
|
+
|
|
694
|
+
#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \
|
|
695
|
+
T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
|
|
696
|
+
K256[j] + (W256[j] = *data++); \
|
|
697
|
+
(d) += T1; \
|
|
698
|
+
(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
|
|
699
|
+
j++
|
|
700
|
+
|
|
701
|
+
#define ROUND256(a,b,c,d,e,f,g,h) \
|
|
702
|
+
s0 = W256[(j+1)&0x0f]; \
|
|
703
|
+
s0 = sigma0_256(s0); \
|
|
704
|
+
s1 = W256[(j+14)&0x0f]; \
|
|
705
|
+
s1 = sigma1_256(s1); \
|
|
706
|
+
T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \
|
|
707
|
+
(W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \
|
|
708
|
+
(d) += T1; \
|
|
709
|
+
(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
|
|
710
|
+
j++
|
|
711
|
+
|
|
712
|
+
void sha256_Transform(const sha2_word32* state_in, const sha2_word32* data, sha2_word32* state_out) {
|
|
713
|
+
sha2_word32 a, b, c, d, e, f, g, h, s0, s1;
|
|
714
|
+
sha2_word32 T1;
|
|
715
|
+
sha2_word32 W256[16];
|
|
716
|
+
int j;
|
|
717
|
+
|
|
718
|
+
/* Initialize registers with the prev. intermediate value */
|
|
719
|
+
a = state_in[0];
|
|
720
|
+
b = state_in[1];
|
|
721
|
+
c = state_in[2];
|
|
722
|
+
d = state_in[3];
|
|
723
|
+
e = state_in[4];
|
|
724
|
+
f = state_in[5];
|
|
725
|
+
g = state_in[6];
|
|
726
|
+
h = state_in[7];
|
|
727
|
+
|
|
728
|
+
j = 0;
|
|
729
|
+
do {
|
|
730
|
+
/* Rounds 0 to 15 (unrolled): */
|
|
731
|
+
ROUND256_0_TO_15(a,b,c,d,e,f,g,h);
|
|
732
|
+
ROUND256_0_TO_15(h,a,b,c,d,e,f,g);
|
|
733
|
+
ROUND256_0_TO_15(g,h,a,b,c,d,e,f);
|
|
734
|
+
ROUND256_0_TO_15(f,g,h,a,b,c,d,e);
|
|
735
|
+
ROUND256_0_TO_15(e,f,g,h,a,b,c,d);
|
|
736
|
+
ROUND256_0_TO_15(d,e,f,g,h,a,b,c);
|
|
737
|
+
ROUND256_0_TO_15(c,d,e,f,g,h,a,b);
|
|
738
|
+
ROUND256_0_TO_15(b,c,d,e,f,g,h,a);
|
|
739
|
+
} while (j < 16);
|
|
740
|
+
|
|
741
|
+
/* Now for the remaining rounds to 64: */
|
|
742
|
+
do {
|
|
743
|
+
ROUND256(a,b,c,d,e,f,g,h);
|
|
744
|
+
ROUND256(h,a,b,c,d,e,f,g);
|
|
745
|
+
ROUND256(g,h,a,b,c,d,e,f);
|
|
746
|
+
ROUND256(f,g,h,a,b,c,d,e);
|
|
747
|
+
ROUND256(e,f,g,h,a,b,c,d);
|
|
748
|
+
ROUND256(d,e,f,g,h,a,b,c);
|
|
749
|
+
ROUND256(c,d,e,f,g,h,a,b);
|
|
750
|
+
ROUND256(b,c,d,e,f,g,h,a);
|
|
751
|
+
} while (j < 64);
|
|
752
|
+
|
|
753
|
+
/* Compute the current intermediate hash value */
|
|
754
|
+
state_out[0] = state_in[0] + a;
|
|
755
|
+
state_out[1] = state_in[1] + b;
|
|
756
|
+
state_out[2] = state_in[2] + c;
|
|
757
|
+
state_out[3] = state_in[3] + d;
|
|
758
|
+
state_out[4] = state_in[4] + e;
|
|
759
|
+
state_out[5] = state_in[5] + f;
|
|
760
|
+
state_out[6] = state_in[6] + g;
|
|
761
|
+
state_out[7] = state_in[7] + h;
|
|
762
|
+
|
|
763
|
+
/* Clean up */
|
|
764
|
+
a = b = c = d = e = f = g = h = T1 = 0;
|
|
765
|
+
}
|
|
766
|
+
|
|
767
|
+
#else /* SHA2_UNROLL_TRANSFORM */
|
|
768
|
+
|
|
769
|
+
void sha256_Transform(const sha2_word32* state_in, const sha2_word32* data, sha2_word32* state_out) {
|
|
770
|
+
sha2_word32 a, b, c, d, e, f, g, h, s0, s1;
|
|
771
|
+
sha2_word32 T1, T2, W256[16];
|
|
772
|
+
int j;
|
|
773
|
+
|
|
774
|
+
/* Initialize registers with the prev. intermediate value */
|
|
775
|
+
a = state_in[0];
|
|
776
|
+
b = state_in[1];
|
|
777
|
+
c = state_in[2];
|
|
778
|
+
d = state_in[3];
|
|
779
|
+
e = state_in[4];
|
|
780
|
+
f = state_in[5];
|
|
781
|
+
g = state_in[6];
|
|
782
|
+
h = state_in[7];
|
|
783
|
+
|
|
784
|
+
j = 0;
|
|
785
|
+
do {
|
|
786
|
+
/* Apply the SHA-256 compression function to update a..h with copy */
|
|
787
|
+
T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++);
|
|
788
|
+
T2 = Sigma0_256(a) + Maj(a, b, c);
|
|
789
|
+
h = g;
|
|
790
|
+
g = f;
|
|
791
|
+
f = e;
|
|
792
|
+
e = d + T1;
|
|
793
|
+
d = c;
|
|
794
|
+
c = b;
|
|
795
|
+
b = a;
|
|
796
|
+
a = T1 + T2;
|
|
797
|
+
|
|
798
|
+
j++;
|
|
799
|
+
} while (j < 16);
|
|
800
|
+
|
|
801
|
+
do {
|
|
802
|
+
/* Part of the message block expansion: */
|
|
803
|
+
s0 = W256[(j+1)&0x0f];
|
|
804
|
+
s0 = sigma0_256(s0);
|
|
805
|
+
s1 = W256[(j+14)&0x0f];
|
|
806
|
+
s1 = sigma1_256(s1);
|
|
807
|
+
|
|
808
|
+
/* Apply the SHA-256 compression function to update a..h */
|
|
809
|
+
T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] +
|
|
810
|
+
(W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0);
|
|
811
|
+
T2 = Sigma0_256(a) + Maj(a, b, c);
|
|
812
|
+
h = g;
|
|
813
|
+
g = f;
|
|
814
|
+
f = e;
|
|
815
|
+
e = d + T1;
|
|
816
|
+
d = c;
|
|
817
|
+
c = b;
|
|
818
|
+
b = a;
|
|
819
|
+
a = T1 + T2;
|
|
820
|
+
|
|
821
|
+
j++;
|
|
822
|
+
} while (j < 64);
|
|
823
|
+
|
|
824
|
+
/* Compute the current intermediate hash value */
|
|
825
|
+
state_out[0] = state_in[0] + a;
|
|
826
|
+
state_out[1] = state_in[1] + b;
|
|
827
|
+
state_out[2] = state_in[2] + c;
|
|
828
|
+
state_out[3] = state_in[3] + d;
|
|
829
|
+
state_out[4] = state_in[4] + e;
|
|
830
|
+
state_out[5] = state_in[5] + f;
|
|
831
|
+
state_out[6] = state_in[6] + g;
|
|
832
|
+
state_out[7] = state_in[7] + h;
|
|
833
|
+
|
|
834
|
+
/* Clean up */
|
|
835
|
+
a = b = c = d = e = f = g = h = T1 = T2 = 0;
|
|
836
|
+
}
|
|
837
|
+
|
|
838
|
+
#endif /* SHA2_UNROLL_TRANSFORM */
|
|
839
|
+
|
|
840
|
+
void sha256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
|
|
841
|
+
unsigned int freespace, usedspace;
|
|
842
|
+
|
|
843
|
+
if (len == 0) {
|
|
844
|
+
/* Calling with no data is valid - we do nothing */
|
|
845
|
+
return;
|
|
846
|
+
}
|
|
847
|
+
|
|
848
|
+
usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
|
|
849
|
+
if (usedspace > 0) {
|
|
850
|
+
/* Calculate how much free space is available in the buffer */
|
|
851
|
+
freespace = SHA256_BLOCK_LENGTH - usedspace;
|
|
852
|
+
|
|
853
|
+
if (len >= freespace) {
|
|
854
|
+
/* Fill the buffer completely and process it */
|
|
855
|
+
MEMCPY_BCOPY(((uint8_t*)context->buffer) + usedspace, data, freespace);
|
|
856
|
+
context->bitcount += freespace << 3;
|
|
857
|
+
len -= freespace;
|
|
858
|
+
data += freespace;
|
|
859
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
860
|
+
/* Convert TO host byte order */
|
|
861
|
+
for (int j = 0; j < 16; j++) {
|
|
862
|
+
REVERSE32(context->buffer[j],context->buffer[j]);
|
|
863
|
+
}
|
|
864
|
+
#endif
|
|
865
|
+
sha256_Transform(context->state, context->buffer, context->state);
|
|
866
|
+
} else {
|
|
867
|
+
/* The buffer is not yet full */
|
|
868
|
+
MEMCPY_BCOPY(((uint8_t*)context->buffer) + usedspace, data, len);
|
|
869
|
+
context->bitcount += len << 3;
|
|
870
|
+
/* Clean up: */
|
|
871
|
+
usedspace = freespace = 0;
|
|
872
|
+
return;
|
|
873
|
+
}
|
|
874
|
+
}
|
|
875
|
+
while (len >= SHA256_BLOCK_LENGTH) {
|
|
876
|
+
/* Process as many complete blocks as we can */
|
|
877
|
+
MEMCPY_BCOPY(context->buffer, data, SHA256_BLOCK_LENGTH);
|
|
878
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
879
|
+
/* Convert TO host byte order */
|
|
880
|
+
for (int j = 0; j < 16; j++) {
|
|
881
|
+
REVERSE32(context->buffer[j],context->buffer[j]);
|
|
882
|
+
}
|
|
883
|
+
#endif
|
|
884
|
+
sha256_Transform(context->state, context->buffer, context->state);
|
|
885
|
+
context->bitcount += SHA256_BLOCK_LENGTH << 3;
|
|
886
|
+
len -= SHA256_BLOCK_LENGTH;
|
|
887
|
+
data += SHA256_BLOCK_LENGTH;
|
|
888
|
+
}
|
|
889
|
+
if (len > 0) {
|
|
890
|
+
/* There's left-overs, so save 'em */
|
|
891
|
+
MEMCPY_BCOPY(context->buffer, data, len);
|
|
892
|
+
context->bitcount += len << 3;
|
|
893
|
+
}
|
|
894
|
+
/* Clean up: */
|
|
895
|
+
usedspace = freespace = 0;
|
|
896
|
+
}
|
|
897
|
+
|
|
898
|
+
void sha256_Final(SHA256_CTX* context, sha2_byte digest[]) {
|
|
899
|
+
unsigned int usedspace;
|
|
900
|
+
|
|
901
|
+
/* If no digest buffer is passed, we don't bother doing this: */
|
|
902
|
+
if (digest != (sha2_byte*)0) {
|
|
903
|
+
usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
|
|
904
|
+
/* Begin padding with a 1 bit: */
|
|
905
|
+
((uint8_t*)context->buffer)[usedspace++] = 0x80;
|
|
906
|
+
|
|
907
|
+
if (usedspace > SHA256_SHORT_BLOCK_LENGTH) {
|
|
908
|
+
memzero(((uint8_t*)context->buffer) + usedspace, SHA256_BLOCK_LENGTH - usedspace);
|
|
909
|
+
|
|
910
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
911
|
+
/* Convert TO host byte order */
|
|
912
|
+
for (int j = 0; j < 16; j++) {
|
|
913
|
+
REVERSE32(context->buffer[j],context->buffer[j]);
|
|
914
|
+
}
|
|
915
|
+
#endif
|
|
916
|
+
/* Do second-to-last transform: */
|
|
917
|
+
sha256_Transform(context->state, context->buffer, context->state);
|
|
918
|
+
|
|
919
|
+
/* And prepare the last transform: */
|
|
920
|
+
usedspace = 0;
|
|
921
|
+
}
|
|
922
|
+
/* Set-up for the last transform: */
|
|
923
|
+
memzero(((uint8_t*)context->buffer) + usedspace, SHA256_SHORT_BLOCK_LENGTH - usedspace);
|
|
924
|
+
|
|
925
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
926
|
+
/* Convert TO host byte order */
|
|
927
|
+
for (int j = 0; j < 14; j++) {
|
|
928
|
+
REVERSE32(context->buffer[j],context->buffer[j]);
|
|
929
|
+
}
|
|
930
|
+
#endif
|
|
931
|
+
/* Set the bit count: */
|
|
932
|
+
context->buffer[14] = context->bitcount >> 32;
|
|
933
|
+
context->buffer[15] = context->bitcount & 0xffffffff;
|
|
934
|
+
|
|
935
|
+
/* Final transform: */
|
|
936
|
+
sha256_Transform(context->state, context->buffer, context->state);
|
|
937
|
+
|
|
938
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
939
|
+
/* Convert FROM host byte order */
|
|
940
|
+
for (int j = 0; j < 8; j++) {
|
|
941
|
+
REVERSE32(context->state[j],context->state[j]);
|
|
942
|
+
}
|
|
943
|
+
#endif
|
|
944
|
+
MEMCPY_BCOPY(digest, context->state, SHA256_DIGEST_LENGTH);
|
|
945
|
+
}
|
|
946
|
+
|
|
947
|
+
/* Clean up state data: */
|
|
948
|
+
memzero(context, sizeof(SHA256_CTX));
|
|
949
|
+
usedspace = 0;
|
|
950
|
+
}
|
|
951
|
+
|
|
952
|
+
char *sha256_End(SHA256_CTX* context, char buffer[]) {
|
|
953
|
+
sha2_byte digest[SHA256_DIGEST_LENGTH], *d = digest;
|
|
954
|
+
int i;
|
|
955
|
+
|
|
956
|
+
if (buffer != (char*)0) {
|
|
957
|
+
sha256_Final(context, digest);
|
|
958
|
+
|
|
959
|
+
for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
|
|
960
|
+
*buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
|
|
961
|
+
*buffer++ = sha2_hex_digits[*d & 0x0f];
|
|
962
|
+
d++;
|
|
963
|
+
}
|
|
964
|
+
*buffer = (char)0;
|
|
965
|
+
} else {
|
|
966
|
+
memzero(context, sizeof(SHA256_CTX));
|
|
967
|
+
}
|
|
968
|
+
memzero(digest, SHA256_DIGEST_LENGTH);
|
|
969
|
+
return buffer;
|
|
970
|
+
}
|
|
971
|
+
|
|
972
|
+
void sha256_Raw(const sha2_byte* data, size_t len, uint8_t digest[SHA256_DIGEST_LENGTH]) {
|
|
973
|
+
SHA256_CTX context;
|
|
974
|
+
sha256_Init(&context);
|
|
975
|
+
sha256_Update(&context, data, len);
|
|
976
|
+
sha256_Final(&context, digest);
|
|
977
|
+
}
|
|
978
|
+
|
|
979
|
+
char* sha256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) {
|
|
980
|
+
SHA256_CTX context;
|
|
981
|
+
|
|
982
|
+
sha256_Init(&context);
|
|
983
|
+
sha256_Update(&context, data, len);
|
|
984
|
+
return sha256_End(&context, digest);
|
|
985
|
+
}
|
|
986
|
+
|
|
987
|
+
|
|
988
|
+
/*** SHA-512: *********************************************************/
|
|
989
|
+
void sha512_Init(SHA512_CTX* context) {
|
|
990
|
+
if (context == (SHA512_CTX*)0) {
|
|
991
|
+
return;
|
|
992
|
+
}
|
|
993
|
+
MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
|
|
994
|
+
memzero(context->buffer, SHA512_BLOCK_LENGTH);
|
|
995
|
+
context->bitcount[0] = context->bitcount[1] = 0;
|
|
996
|
+
}
|
|
997
|
+
|
|
998
|
+
void sha512_256_Init(SHA512_CTX* context) {
|
|
999
|
+
if (context == (SHA512_CTX*)0) {
|
|
1000
|
+
return;
|
|
1001
|
+
}
|
|
1002
|
+
MEMCPY_BCOPY(context->state, sha512_256_initial_hash_value, SHA512_DIGEST_LENGTH);
|
|
1003
|
+
memzero(context->buffer, SHA512_BLOCK_LENGTH);
|
|
1004
|
+
context->bitcount[0] = context->bitcount[1] = 0;
|
|
1005
|
+
}
|
|
1006
|
+
|
|
1007
|
+
#ifdef SHA2_UNROLL_TRANSFORM
|
|
1008
|
+
|
|
1009
|
+
/* Unrolled SHA-512 round macros: */
|
|
1010
|
+
#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \
|
|
1011
|
+
T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
|
|
1012
|
+
K512[j] + (W512[j] = *data++); \
|
|
1013
|
+
(d) += T1; \
|
|
1014
|
+
(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
|
|
1015
|
+
j++
|
|
1016
|
+
|
|
1017
|
+
#define ROUND512(a,b,c,d,e,f,g,h) \
|
|
1018
|
+
s0 = W512[(j+1)&0x0f]; \
|
|
1019
|
+
s0 = sigma0_512(s0); \
|
|
1020
|
+
s1 = W512[(j+14)&0x0f]; \
|
|
1021
|
+
s1 = sigma1_512(s1); \
|
|
1022
|
+
T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + K512[j] + \
|
|
1023
|
+
(W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); \
|
|
1024
|
+
(d) += T1; \
|
|
1025
|
+
(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
|
|
1026
|
+
j++
|
|
1027
|
+
|
|
1028
|
+
void sha512_Transform(const sha2_word64* state_in, const sha2_word64* data, sha2_word64* state_out) {
|
|
1029
|
+
sha2_word64 a, b, c, d, e, f, g, h, s0, s1;
|
|
1030
|
+
sha2_word64 T1, W512[16];
|
|
1031
|
+
int j;
|
|
1032
|
+
|
|
1033
|
+
/* Initialize registers with the prev. intermediate value */
|
|
1034
|
+
a = state_in[0];
|
|
1035
|
+
b = state_in[1];
|
|
1036
|
+
c = state_in[2];
|
|
1037
|
+
d = state_in[3];
|
|
1038
|
+
e = state_in[4];
|
|
1039
|
+
f = state_in[5];
|
|
1040
|
+
g = state_in[6];
|
|
1041
|
+
h = state_in[7];
|
|
1042
|
+
|
|
1043
|
+
j = 0;
|
|
1044
|
+
do {
|
|
1045
|
+
ROUND512_0_TO_15(a,b,c,d,e,f,g,h);
|
|
1046
|
+
ROUND512_0_TO_15(h,a,b,c,d,e,f,g);
|
|
1047
|
+
ROUND512_0_TO_15(g,h,a,b,c,d,e,f);
|
|
1048
|
+
ROUND512_0_TO_15(f,g,h,a,b,c,d,e);
|
|
1049
|
+
ROUND512_0_TO_15(e,f,g,h,a,b,c,d);
|
|
1050
|
+
ROUND512_0_TO_15(d,e,f,g,h,a,b,c);
|
|
1051
|
+
ROUND512_0_TO_15(c,d,e,f,g,h,a,b);
|
|
1052
|
+
ROUND512_0_TO_15(b,c,d,e,f,g,h,a);
|
|
1053
|
+
} while (j < 16);
|
|
1054
|
+
|
|
1055
|
+
/* Now for the remaining rounds up to 79: */
|
|
1056
|
+
do {
|
|
1057
|
+
ROUND512(a,b,c,d,e,f,g,h);
|
|
1058
|
+
ROUND512(h,a,b,c,d,e,f,g);
|
|
1059
|
+
ROUND512(g,h,a,b,c,d,e,f);
|
|
1060
|
+
ROUND512(f,g,h,a,b,c,d,e);
|
|
1061
|
+
ROUND512(e,f,g,h,a,b,c,d);
|
|
1062
|
+
ROUND512(d,e,f,g,h,a,b,c);
|
|
1063
|
+
ROUND512(c,d,e,f,g,h,a,b);
|
|
1064
|
+
ROUND512(b,c,d,e,f,g,h,a);
|
|
1065
|
+
} while (j < 80);
|
|
1066
|
+
|
|
1067
|
+
/* Compute the current intermediate hash value */
|
|
1068
|
+
state_out[0] = state_in[0] + a;
|
|
1069
|
+
state_out[1] = state_in[1] + b;
|
|
1070
|
+
state_out[2] = state_in[2] + c;
|
|
1071
|
+
state_out[3] = state_in[3] + d;
|
|
1072
|
+
state_out[4] = state_in[4] + e;
|
|
1073
|
+
state_out[5] = state_in[5] + f;
|
|
1074
|
+
state_out[6] = state_in[6] + g;
|
|
1075
|
+
state_out[7] = state_in[7] + h;
|
|
1076
|
+
|
|
1077
|
+
/* Clean up */
|
|
1078
|
+
a = b = c = d = e = f = g = h = T1 = 0;
|
|
1079
|
+
}
|
|
1080
|
+
|
|
1081
|
+
#else /* SHA2_UNROLL_TRANSFORM */
|
|
1082
|
+
|
|
1083
|
+
void sha512_Transform(const sha2_word64* state_in, const sha2_word64* data, sha2_word64* state_out) {
|
|
1084
|
+
sha2_word64 a, b, c, d, e, f, g, h, s0, s1;
|
|
1085
|
+
sha2_word64 T1, T2, W512[16];
|
|
1086
|
+
int j;
|
|
1087
|
+
|
|
1088
|
+
/* Initialize registers with the prev. intermediate value */
|
|
1089
|
+
a = state_in[0];
|
|
1090
|
+
b = state_in[1];
|
|
1091
|
+
c = state_in[2];
|
|
1092
|
+
d = state_in[3];
|
|
1093
|
+
e = state_in[4];
|
|
1094
|
+
f = state_in[5];
|
|
1095
|
+
g = state_in[6];
|
|
1096
|
+
h = state_in[7];
|
|
1097
|
+
|
|
1098
|
+
j = 0;
|
|
1099
|
+
do {
|
|
1100
|
+
/* Apply the SHA-512 compression function to update a..h with copy */
|
|
1101
|
+
T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + (W512[j] = *data++);
|
|
1102
|
+
T2 = Sigma0_512(a) + Maj(a, b, c);
|
|
1103
|
+
h = g;
|
|
1104
|
+
g = f;
|
|
1105
|
+
f = e;
|
|
1106
|
+
e = d + T1;
|
|
1107
|
+
d = c;
|
|
1108
|
+
c = b;
|
|
1109
|
+
b = a;
|
|
1110
|
+
a = T1 + T2;
|
|
1111
|
+
|
|
1112
|
+
j++;
|
|
1113
|
+
} while (j < 16);
|
|
1114
|
+
|
|
1115
|
+
do {
|
|
1116
|
+
/* Part of the message block expansion: */
|
|
1117
|
+
s0 = W512[(j+1)&0x0f];
|
|
1118
|
+
s0 = sigma0_512(s0);
|
|
1119
|
+
s1 = W512[(j+14)&0x0f];
|
|
1120
|
+
s1 = sigma1_512(s1);
|
|
1121
|
+
|
|
1122
|
+
/* Apply the SHA-512 compression function to update a..h */
|
|
1123
|
+
T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] +
|
|
1124
|
+
(W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0);
|
|
1125
|
+
T2 = Sigma0_512(a) + Maj(a, b, c);
|
|
1126
|
+
h = g;
|
|
1127
|
+
g = f;
|
|
1128
|
+
f = e;
|
|
1129
|
+
e = d + T1;
|
|
1130
|
+
d = c;
|
|
1131
|
+
c = b;
|
|
1132
|
+
b = a;
|
|
1133
|
+
a = T1 + T2;
|
|
1134
|
+
|
|
1135
|
+
j++;
|
|
1136
|
+
} while (j < 80);
|
|
1137
|
+
|
|
1138
|
+
/* Compute the current intermediate hash value */
|
|
1139
|
+
state_out[0] = state_in[0] + a;
|
|
1140
|
+
state_out[1] = state_in[1] + b;
|
|
1141
|
+
state_out[2] = state_in[2] + c;
|
|
1142
|
+
state_out[3] = state_in[3] + d;
|
|
1143
|
+
state_out[4] = state_in[4] + e;
|
|
1144
|
+
state_out[5] = state_in[5] + f;
|
|
1145
|
+
state_out[6] = state_in[6] + g;
|
|
1146
|
+
state_out[7] = state_in[7] + h;
|
|
1147
|
+
|
|
1148
|
+
/* Clean up */
|
|
1149
|
+
a = b = c = d = e = f = g = h = T1 = T2 = 0;
|
|
1150
|
+
}
|
|
1151
|
+
|
|
1152
|
+
#endif /* SHA2_UNROLL_TRANSFORM */
|
|
1153
|
+
|
|
1154
|
+
void sha512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
|
|
1155
|
+
unsigned int freespace, usedspace;
|
|
1156
|
+
|
|
1157
|
+
if (len == 0) {
|
|
1158
|
+
/* Calling with no data is valid - we do nothing */
|
|
1159
|
+
return;
|
|
1160
|
+
}
|
|
1161
|
+
|
|
1162
|
+
usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
|
|
1163
|
+
if (usedspace > 0) {
|
|
1164
|
+
/* Calculate how much free space is available in the buffer */
|
|
1165
|
+
freespace = SHA512_BLOCK_LENGTH - usedspace;
|
|
1166
|
+
|
|
1167
|
+
if (len >= freespace) {
|
|
1168
|
+
/* Fill the buffer completely and process it */
|
|
1169
|
+
MEMCPY_BCOPY(((uint8_t*)context->buffer) + usedspace, data, freespace);
|
|
1170
|
+
ADDINC128(context->bitcount, freespace << 3);
|
|
1171
|
+
len -= freespace;
|
|
1172
|
+
data += freespace;
|
|
1173
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
1174
|
+
/* Convert TO host byte order */
|
|
1175
|
+
for (int j = 0; j < 16; j++) {
|
|
1176
|
+
REVERSE64(context->buffer[j],context->buffer[j]);
|
|
1177
|
+
}
|
|
1178
|
+
#endif
|
|
1179
|
+
sha512_Transform(context->state, context->buffer, context->state);
|
|
1180
|
+
} else {
|
|
1181
|
+
/* The buffer is not yet full */
|
|
1182
|
+
MEMCPY_BCOPY(((uint8_t*)context->buffer) + usedspace, data, len);
|
|
1183
|
+
ADDINC128(context->bitcount, len << 3);
|
|
1184
|
+
/* Clean up: */
|
|
1185
|
+
usedspace = freespace = 0;
|
|
1186
|
+
return;
|
|
1187
|
+
}
|
|
1188
|
+
}
|
|
1189
|
+
while (len >= SHA512_BLOCK_LENGTH) {
|
|
1190
|
+
/* Process as many complete blocks as we can */
|
|
1191
|
+
MEMCPY_BCOPY(context->buffer, data, SHA512_BLOCK_LENGTH);
|
|
1192
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
1193
|
+
/* Convert TO host byte order */
|
|
1194
|
+
for (int j = 0; j < 16; j++) {
|
|
1195
|
+
REVERSE64(context->buffer[j],context->buffer[j]);
|
|
1196
|
+
}
|
|
1197
|
+
#endif
|
|
1198
|
+
sha512_Transform(context->state, context->buffer, context->state);
|
|
1199
|
+
ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3);
|
|
1200
|
+
len -= SHA512_BLOCK_LENGTH;
|
|
1201
|
+
data += SHA512_BLOCK_LENGTH;
|
|
1202
|
+
}
|
|
1203
|
+
if (len > 0) {
|
|
1204
|
+
/* There's left-overs, so save 'em */
|
|
1205
|
+
MEMCPY_BCOPY(context->buffer, data, len);
|
|
1206
|
+
ADDINC128(context->bitcount, len << 3);
|
|
1207
|
+
}
|
|
1208
|
+
/* Clean up: */
|
|
1209
|
+
usedspace = freespace = 0;
|
|
1210
|
+
}
|
|
1211
|
+
|
|
1212
|
+
static void sha512_Last(SHA512_CTX* context) {
|
|
1213
|
+
unsigned int usedspace;
|
|
1214
|
+
|
|
1215
|
+
usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
|
|
1216
|
+
/* Begin padding with a 1 bit: */
|
|
1217
|
+
((uint8_t*)context->buffer)[usedspace++] = 0x80;
|
|
1218
|
+
|
|
1219
|
+
if (usedspace > SHA512_SHORT_BLOCK_LENGTH) {
|
|
1220
|
+
memzero(((uint8_t*)context->buffer) + usedspace, SHA512_BLOCK_LENGTH - usedspace);
|
|
1221
|
+
|
|
1222
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
1223
|
+
/* Convert TO host byte order */
|
|
1224
|
+
for (int j = 0; j < 16; j++) {
|
|
1225
|
+
REVERSE64(context->buffer[j],context->buffer[j]);
|
|
1226
|
+
}
|
|
1227
|
+
#endif
|
|
1228
|
+
/* Do second-to-last transform: */
|
|
1229
|
+
sha512_Transform(context->state, context->buffer, context->state);
|
|
1230
|
+
|
|
1231
|
+
/* And prepare the last transform: */
|
|
1232
|
+
usedspace = 0;
|
|
1233
|
+
}
|
|
1234
|
+
/* Set-up for the last transform: */
|
|
1235
|
+
memzero(((uint8_t*)context->buffer) + usedspace, SHA512_SHORT_BLOCK_LENGTH - usedspace);
|
|
1236
|
+
|
|
1237
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
1238
|
+
/* Convert TO host byte order */
|
|
1239
|
+
for (int j = 0; j < 14; j++) {
|
|
1240
|
+
REVERSE64(context->buffer[j],context->buffer[j]);
|
|
1241
|
+
}
|
|
1242
|
+
#endif
|
|
1243
|
+
/* Store the length of input data (in bits): */
|
|
1244
|
+
context->buffer[14] = context->bitcount[1];
|
|
1245
|
+
context->buffer[15] = context->bitcount[0];
|
|
1246
|
+
|
|
1247
|
+
/* Final transform: */
|
|
1248
|
+
sha512_Transform(context->state, context->buffer, context->state);
|
|
1249
|
+
}
|
|
1250
|
+
|
|
1251
|
+
void sha512_Final(SHA512_CTX* context, sha2_byte digest[]) {
|
|
1252
|
+
/* If no digest buffer is passed, we don't bother doing this: */
|
|
1253
|
+
if (digest != (sha2_byte*)0) {
|
|
1254
|
+
sha512_Last(context);
|
|
1255
|
+
|
|
1256
|
+
/* Save the hash data for output: */
|
|
1257
|
+
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
1258
|
+
/* Convert FROM host byte order */
|
|
1259
|
+
for (int j = 0; j < 8; j++) {
|
|
1260
|
+
REVERSE64(context->state[j],context->state[j]);
|
|
1261
|
+
}
|
|
1262
|
+
#endif
|
|
1263
|
+
MEMCPY_BCOPY(digest, context->state, SHA512_DIGEST_LENGTH);
|
|
1264
|
+
}
|
|
1265
|
+
|
|
1266
|
+
/* Zero out state data */
|
|
1267
|
+
memzero(context, sizeof(SHA512_CTX));
|
|
1268
|
+
}
|
|
1269
|
+
|
|
1270
|
+
char *sha512_End(SHA512_CTX* context, char buffer[]) {
|
|
1271
|
+
sha2_byte digest[SHA512_DIGEST_LENGTH], *d = digest;
|
|
1272
|
+
int i;
|
|
1273
|
+
|
|
1274
|
+
if (buffer != (char*)0) {
|
|
1275
|
+
sha512_Final(context, digest);
|
|
1276
|
+
|
|
1277
|
+
for (i = 0; i < SHA512_DIGEST_LENGTH; i++) {
|
|
1278
|
+
*buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
|
|
1279
|
+
*buffer++ = sha2_hex_digits[*d & 0x0f];
|
|
1280
|
+
d++;
|
|
1281
|
+
}
|
|
1282
|
+
*buffer = (char)0;
|
|
1283
|
+
} else {
|
|
1284
|
+
memzero(context, sizeof(SHA512_CTX));
|
|
1285
|
+
}
|
|
1286
|
+
memzero(digest, SHA512_DIGEST_LENGTH);
|
|
1287
|
+
return buffer;
|
|
1288
|
+
}
|
|
1289
|
+
|
|
1290
|
+
void sha512_Raw(const sha2_byte* data, size_t len, uint8_t digest[SHA512_DIGEST_LENGTH]) {
|
|
1291
|
+
SHA512_CTX context;
|
|
1292
|
+
sha512_Init(&context);
|
|
1293
|
+
sha512_Update(&context, data, len);
|
|
1294
|
+
sha512_Final(&context, digest);
|
|
1295
|
+
}
|
|
1296
|
+
|
|
1297
|
+
void sha512_256_Raw(const sha2_byte* data, size_t len, uint8_t digest[SHA256_DIGEST_LENGTH]) {
|
|
1298
|
+
SHA512_CTX context;
|
|
1299
|
+
uint8_t result[SHA512_DIGEST_LENGTH];
|
|
1300
|
+
sha512_256_Init(&context);
|
|
1301
|
+
sha512_Update(&context, data, len);
|
|
1302
|
+
sha512_Final(&context, result);
|
|
1303
|
+
|
|
1304
|
+
memcpy(digest, result, SHA256_DIGEST_LENGTH);
|
|
1305
|
+
memzero(result, SHA512_DIGEST_LENGTH);
|
|
1306
|
+
}
|
|
1307
|
+
|
|
1308
|
+
char* sha512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) {
|
|
1309
|
+
SHA512_CTX context;
|
|
1310
|
+
|
|
1311
|
+
sha512_Init(&context);
|
|
1312
|
+
sha512_Update(&context, data, len);
|
|
1313
|
+
return sha512_End(&context, digest);
|
|
1314
|
+
}
|