@onekeyfe/react-native-lite-card 6.7.0-alpha.409 → 6.7.0-alpha.412

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.
Files changed (223) hide show
  1. package/README.md +9 -1
  2. package/ReactNativeLiteCard.podspec +25 -2
  3. package/android/build.gradle +7 -0
  4. package/android/src/main/cpp/CMakeLists.txt +6 -2
  5. package/android/src/main/java/com/onekeyfe/reactnativelitecard/nfc/gpchannel/GPChannelNatives.kt +7 -7
  6. package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/entitys/SendResponse.kt +6 -3
  7. package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/nfc/CommandGenerator.kt +5 -1
  8. package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/nfc/Connection.kt +21 -7
  9. package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/nfc/GPCAPDUGenerator.kt +2 -2
  10. package/ios/Classes/OKLiteCommand/OKLiteCommandTool.m +4 -1
  11. package/ios/Classes/OKNFCBridge.mm +1 -1
  12. package/ios/Classes/OKNFTLite/OKLiteV1.m +6 -3
  13. package/ios/Classes/OKNFTLite/OKLiteV2.m +13 -5
  14. package/package.json +2 -2
  15. package/sdk/CMakeLists.txt +120 -0
  16. package/sdk/README.md +175 -0
  17. package/sdk/android/implJni.cpp +177 -0
  18. package/sdk/deps/jsoncpp/LICENSE +55 -0
  19. package/sdk/deps/jsoncpp/include/CMakeLists.txt +2 -0
  20. package/sdk/deps/jsoncpp/include/json/allocator.h +98 -0
  21. package/sdk/deps/jsoncpp/include/json/assertions.h +54 -0
  22. package/sdk/deps/jsoncpp/include/json/autolink.h +25 -0
  23. package/sdk/deps/jsoncpp/include/json/config.h +187 -0
  24. package/sdk/deps/jsoncpp/include/json/features.h +61 -0
  25. package/sdk/deps/jsoncpp/include/json/forwards.h +37 -0
  26. package/sdk/deps/jsoncpp/include/json/json.h +15 -0
  27. package/sdk/deps/jsoncpp/include/json/reader.h +411 -0
  28. package/sdk/deps/jsoncpp/include/json/value.h +888 -0
  29. package/sdk/deps/jsoncpp/include/json/version.h +20 -0
  30. package/sdk/deps/jsoncpp/include/json/writer.h +357 -0
  31. package/sdk/deps/jsoncpp/src/lib_json/CMakeLists.txt +117 -0
  32. package/sdk/deps/jsoncpp/src/lib_json/json_reader.cpp +2060 -0
  33. package/sdk/deps/jsoncpp/src/lib_json/json_tool.h +114 -0
  34. package/sdk/deps/jsoncpp/src/lib_json/json_value.cpp +1661 -0
  35. package/sdk/deps/jsoncpp/src/lib_json/json_valueiterator.inl +167 -0
  36. package/sdk/deps/jsoncpp/src/lib_json/json_writer.cpp +1233 -0
  37. package/sdk/deps/jsoncpp/src/lib_json/version.h.in +20 -0
  38. package/sdk/deps/trezor-crypto/AUTHORS +2 -0
  39. package/sdk/deps/trezor-crypto/LICENSE +22 -0
  40. package/sdk/deps/trezor-crypto/include/TrezorCrypto/TrezorCrypto.h +29 -0
  41. package/sdk/deps/trezor-crypto/include/TrezorCrypto/address.h +44 -0
  42. package/sdk/deps/trezor-crypto/include/TrezorCrypto/aes.h +224 -0
  43. package/sdk/deps/trezor-crypto/include/TrezorCrypto/base32.h +49 -0
  44. package/sdk/deps/trezor-crypto/include/TrezorCrypto/base58.h +58 -0
  45. package/sdk/deps/trezor-crypto/include/TrezorCrypto/bignum.h +169 -0
  46. package/sdk/deps/trezor-crypto/include/TrezorCrypto/bip32.h +114 -0
  47. package/sdk/deps/trezor-crypto/include/TrezorCrypto/bip39.h +66 -0
  48. package/sdk/deps/trezor-crypto/include/TrezorCrypto/blake256.h +61 -0
  49. package/sdk/deps/trezor-crypto/include/TrezorCrypto/blake2b.h +50 -0
  50. package/sdk/deps/trezor-crypto/include/TrezorCrypto/blake2s.h +49 -0
  51. package/sdk/deps/trezor-crypto/include/TrezorCrypto/cash_addr.h +109 -0
  52. package/sdk/deps/trezor-crypto/include/TrezorCrypto/chacha20poly1305/ecrypt-config.h +316 -0
  53. package/sdk/deps/trezor-crypto/include/TrezorCrypto/chacha20poly1305/ecrypt-sync.h +289 -0
  54. package/sdk/deps/trezor-crypto/include/TrezorCrypto/chacha20poly1305/ecrypt-types.h +53 -0
  55. package/sdk/deps/trezor-crypto/include/TrezorCrypto/chacha20poly1305/poly1305-donna.h +28 -0
  56. package/sdk/deps/trezor-crypto/include/TrezorCrypto/chacha20poly1305.h +27 -0
  57. package/sdk/deps/trezor-crypto/include/TrezorCrypto/cmac.h +44 -0
  58. package/sdk/deps/trezor-crypto/include/TrezorCrypto/curves.h +60 -0
  59. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ecdsa.h +112 -0
  60. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/curve25519-donna-32bit.h +87 -0
  61. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/curve25519-donna-helpers.h +30 -0
  62. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-blake2b.h +21 -0
  63. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-donna-32bit-tables.h +25 -0
  64. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-donna-basepoint-table.h +10 -0
  65. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-donna-impl-base.h +110 -0
  66. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-donna-portable.h +32 -0
  67. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-donna.h +60 -0
  68. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-keccak.h +21 -0
  69. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/ed25519-sha3.h +21 -0
  70. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna/modm-donna-32bit.h +87 -0
  71. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519-donna.h +60 -0
  72. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ed25519.h +42 -0
  73. package/sdk/deps/trezor-crypto/include/TrezorCrypto/endian.h +132 -0
  74. package/sdk/deps/trezor-crypto/include/TrezorCrypto/groestl.h +104 -0
  75. package/sdk/deps/trezor-crypto/include/TrezorCrypto/hasher.h +90 -0
  76. package/sdk/deps/trezor-crypto/include/TrezorCrypto/hmac.h +60 -0
  77. package/sdk/deps/trezor-crypto/include/TrezorCrypto/memzero.h +16 -0
  78. package/sdk/deps/trezor-crypto/include/TrezorCrypto/monero/base58.h +42 -0
  79. package/sdk/deps/trezor-crypto/include/TrezorCrypto/monero/monero.h +13 -0
  80. package/sdk/deps/trezor-crypto/include/TrezorCrypto/monero/range_proof.h +30 -0
  81. package/sdk/deps/trezor-crypto/include/TrezorCrypto/monero/serialize.h +15 -0
  82. package/sdk/deps/trezor-crypto/include/TrezorCrypto/monero/xmr.h +67 -0
  83. package/sdk/deps/trezor-crypto/include/TrezorCrypto/nano.h +56 -0
  84. package/sdk/deps/trezor-crypto/include/TrezorCrypto/nem.h +199 -0
  85. package/sdk/deps/trezor-crypto/include/TrezorCrypto/nist256p1.h +35 -0
  86. package/sdk/deps/trezor-crypto/include/TrezorCrypto/pbkdf2.h +64 -0
  87. package/sdk/deps/trezor-crypto/include/TrezorCrypto/rand.h +44 -0
  88. package/sdk/deps/trezor-crypto/include/TrezorCrypto/rc4.h +37 -0
  89. package/sdk/deps/trezor-crypto/include/TrezorCrypto/rfc6979.h +40 -0
  90. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ripemd160.h +28 -0
  91. package/sdk/deps/trezor-crypto/include/TrezorCrypto/ripple/base58.h +45 -0
  92. package/sdk/deps/trezor-crypto/include/TrezorCrypto/schnorr.h +48 -0
  93. package/sdk/deps/trezor-crypto/include/TrezorCrypto/script.h +30 -0
  94. package/sdk/deps/trezor-crypto/include/TrezorCrypto/scrypt.h +68 -0
  95. package/sdk/deps/trezor-crypto/include/TrezorCrypto/secp256k1.h +59 -0
  96. package/sdk/deps/trezor-crypto/include/TrezorCrypto/sha2.h +125 -0
  97. package/sdk/deps/trezor-crypto/include/TrezorCrypto/sha3.h +86 -0
  98. package/sdk/deps/trezor-crypto/include/TrezorCrypto/sodium/keypair.h +20 -0
  99. package/sdk/deps/trezor-crypto/include/TrezorCrypto/sodium/private/ed25519_ref10.h +85 -0
  100. package/sdk/deps/trezor-crypto/include/TrezorCrypto/sodium/private/ed25519_ref10_fe_25_5.h +43 -0
  101. package/sdk/deps/trezor-crypto/include/TrezorCrypto/sodium/private/fe_25_5/constants.h +29 -0
  102. package/sdk/deps/trezor-crypto/include/TrezorCrypto/sodium/private/fe_25_5/fe.h +25 -0
  103. package/sdk/deps/trezor-crypto/src/address.c +87 -0
  104. package/sdk/deps/trezor-crypto/src/aes/aes_modes.c +959 -0
  105. package/sdk/deps/trezor-crypto/src/aes/aescrypt.c +307 -0
  106. package/sdk/deps/trezor-crypto/src/aes/aeskey.c +560 -0
  107. package/sdk/deps/trezor-crypto/src/aes/aesopt.h +784 -0
  108. package/sdk/deps/trezor-crypto/src/aes/aestab.c +418 -0
  109. package/sdk/deps/trezor-crypto/src/aes/aestab.h +173 -0
  110. package/sdk/deps/trezor-crypto/src/base32.c +233 -0
  111. package/sdk/deps/trezor-crypto/src/base58.c +298 -0
  112. package/sdk/deps/trezor-crypto/src/bignum.c +808 -0
  113. package/sdk/deps/trezor-crypto/src/bip32.c +852 -0
  114. package/sdk/deps/trezor-crypto/src/bip39.c +266 -0
  115. package/sdk/deps/trezor-crypto/src/bip39_english.h +2074 -0
  116. package/sdk/deps/trezor-crypto/src/blake256.c +235 -0
  117. package/sdk/deps/trezor-crypto/src/blake2_common.h +39 -0
  118. package/sdk/deps/trezor-crypto/src/blake2b.c +333 -0
  119. package/sdk/deps/trezor-crypto/src/blake2s.c +318 -0
  120. package/sdk/deps/trezor-crypto/src/cash_addr.c +195 -0
  121. package/sdk/deps/trezor-crypto/src/chacha20poly1305/chacha20poly1305.c +60 -0
  122. package/sdk/deps/trezor-crypto/src/chacha20poly1305/chacha_merged.c +246 -0
  123. package/sdk/deps/trezor-crypto/src/chacha20poly1305/ecrypt-machine.h +49 -0
  124. package/sdk/deps/trezor-crypto/src/chacha20poly1305/ecrypt-portable.h +275 -0
  125. package/sdk/deps/trezor-crypto/src/chacha20poly1305/poly1305-donna-32.h +219 -0
  126. package/sdk/deps/trezor-crypto/src/chacha20poly1305/poly1305-donna.c +179 -0
  127. package/sdk/deps/trezor-crypto/src/chacha20poly1305/rfc7539.c +48 -0
  128. package/sdk/deps/trezor-crypto/src/chacha20poly1305/rfc7539.h +10 -0
  129. package/sdk/deps/trezor-crypto/src/check_mem.h +30 -0
  130. package/sdk/deps/trezor-crypto/src/cmac.c +342 -0
  131. package/sdk/deps/trezor-crypto/src/curves.c +48 -0
  132. package/sdk/deps/trezor-crypto/src/ecdsa.c +1355 -0
  133. package/sdk/deps/trezor-crypto/src/ed25519-donna/README.md +183 -0
  134. package/sdk/deps/trezor-crypto/src/ed25519-donna/curve25519-donna-32bit.c +681 -0
  135. package/sdk/deps/trezor-crypto/src/ed25519-donna/curve25519-donna-helpers.c +66 -0
  136. package/sdk/deps/trezor-crypto/src/ed25519-donna/curve25519-donna-scalarmult-base.c +67 -0
  137. package/sdk/deps/trezor-crypto/src/ed25519-donna/curve25519-donna-scalarmult-base.h +8 -0
  138. package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-blake2b.c +8 -0
  139. package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-donna-32bit-tables.c +63 -0
  140. package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-donna-basepoint-table.c +261 -0
  141. package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-donna-impl-base.c +722 -0
  142. package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-hash-custom-blake2b.h +23 -0
  143. package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-hash-custom-keccak.h +23 -0
  144. package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-hash-custom-sha3.h +23 -0
  145. package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-hash-custom.h +23 -0
  146. package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-keccak.c +8 -0
  147. package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519-sha3.c +8 -0
  148. package/sdk/deps/trezor-crypto/src/ed25519-donna/ed25519.c +311 -0
  149. package/sdk/deps/trezor-crypto/src/ed25519-donna/modm-donna-32bit.c +517 -0
  150. package/sdk/deps/trezor-crypto/src/groestl.c +783 -0
  151. package/sdk/deps/trezor-crypto/src/groestl_internal.h +419 -0
  152. package/sdk/deps/trezor-crypto/src/hasher.c +186 -0
  153. package/sdk/deps/trezor-crypto/src/hmac.c +179 -0
  154. package/sdk/deps/trezor-crypto/src/memzero.c +6 -0
  155. package/sdk/deps/trezor-crypto/src/monero/base58.c +245 -0
  156. package/sdk/deps/trezor-crypto/src/monero/int-util.h +77 -0
  157. package/sdk/deps/trezor-crypto/src/monero/range_proof.c +115 -0
  158. package/sdk/deps/trezor-crypto/src/monero/serialize.c +54 -0
  159. package/sdk/deps/trezor-crypto/src/monero/xmr.c +136 -0
  160. package/sdk/deps/trezor-crypto/src/nano.c +151 -0
  161. package/sdk/deps/trezor-crypto/src/nem.c +569 -0
  162. package/sdk/deps/trezor-crypto/src/nist256p1.c +63 -0
  163. package/sdk/deps/trezor-crypto/src/nist256p1.table +1664 -0
  164. package/sdk/deps/trezor-crypto/src/options.h +43 -0
  165. package/sdk/deps/trezor-crypto/src/pbkdf2.c +177 -0
  166. package/sdk/deps/trezor-crypto/src/rand.c +51 -0
  167. package/sdk/deps/trezor-crypto/src/rc4.c +56 -0
  168. package/sdk/deps/trezor-crypto/src/ripemd160.c +343 -0
  169. package/sdk/deps/trezor-crypto/src/ripple/base58.c +76 -0
  170. package/sdk/deps/trezor-crypto/src/schnorr.c +208 -0
  171. package/sdk/deps/trezor-crypto/src/script.c +64 -0
  172. package/sdk/deps/trezor-crypto/src/scrypt.c +343 -0
  173. package/sdk/deps/trezor-crypto/src/secp256k1.c +160 -0
  174. package/sdk/deps/trezor-crypto/src/secp256k1.table +1664 -0
  175. package/sdk/deps/trezor-crypto/src/setup.py +38 -0
  176. package/sdk/deps/trezor-crypto/src/sha2.c +1314 -0
  177. package/sdk/deps/trezor-crypto/src/sha3.c +395 -0
  178. package/sdk/deps/trezor-crypto/src/shell.nix +6 -0
  179. package/sdk/deps/trezor-crypto/src/sodium/keypair.c +63 -0
  180. package/sdk/deps/trezor-crypto/src/sodium/private/ed25519_ref10.c +481 -0
  181. package/sdk/deps/trezor-crypto/src/sodium/private/ed25519_ref10_fe_25_5.c +885 -0
  182. package/sdk/deps/trezor-crypto/src/sodium/private/fe_25_5/fe.c +237 -0
  183. package/sdk/gpc/include/scp03/scp03.hpp +80 -0
  184. package/sdk/gpc/include/scp11/scp11.hpp +492 -0
  185. package/sdk/gpc/include/scp11/scp11c.hpp +58 -0
  186. package/sdk/gpc/include/tag.h +68 -0
  187. package/sdk/gpc/include/tlv.hpp +94 -0
  188. package/sdk/gpc/include/tlvparse.hpp +24 -0
  189. package/sdk/gpc/src/scp03.cpp +243 -0
  190. package/sdk/gpc/src/scp11.cpp +798 -0
  191. package/sdk/gpc/src/scp11c.cpp +136 -0
  192. package/sdk/gpc/src/tlv.cpp +159 -0
  193. package/sdk/gpc/src/tlvparse.c +174 -0
  194. package/{framework/GPChannelSDKCore.xcframework/ios-arm64/GPChannelSDKCore.framework/Headers → sdk/include}/GPChannelSDK.h +0 -0
  195. package/sdk/include/GPChannelSDKCore.h +10 -0
  196. package/sdk/include/context/BaseContext.h +56 -0
  197. package/sdk/include/device/ApduBuilder.hpp +72 -0
  198. package/sdk/include/mSIGNA/stdutils/uchar_vector.h +36 -0
  199. package/sdk/include/utility/Apdu.hpp +172 -0
  200. package/sdk/include/utility/Debug.hpp +3 -0
  201. package/sdk/include/utility/util.h +104 -0
  202. package/sdk/src/ApduBuilder.cpp +332 -0
  203. package/sdk/src/GPChannelSDK.cpp +252 -0
  204. package/sdk/src/random.c +25 -0
  205. package/sdk/src/version.c +2 -0
  206. package/sdk/tests/android/GPChannelProxy.java +55 -0
  207. package/sdk/tests/android_verify.py +121 -0
  208. package/sdk/tests/safety.cpp +603 -0
  209. package/sdk/tests/verify.py +267 -0
  210. package/android/src/main/jniLibs/arm64-v8a/libgpchannelNDK.so +0 -0
  211. package/android/src/main/jniLibs/armeabi-v7a/libgpchannelNDK.so +0 -0
  212. package/framework/GPChannelSDKCore.xcframework/Info.plist +0 -52
  213. package/framework/GPChannelSDKCore.xcframework/ios-arm64/GPChannelSDKCore.framework/GPChannelSDKCore +0 -0
  214. package/framework/GPChannelSDKCore.xcframework/ios-arm64/GPChannelSDKCore.framework/Headers/GPChannelSDKCore.h +0 -19
  215. package/framework/GPChannelSDKCore.xcframework/ios-arm64/GPChannelSDKCore.framework/Info.plist +0 -0
  216. package/framework/GPChannelSDKCore.xcframework/ios-arm64/GPChannelSDKCore.framework/Modules/module.modulemap +0 -7
  217. package/framework/GPChannelSDKCore.xcframework/ios-arm64/GPChannelSDKCore.framework/_CodeSignature/CodeResources +0 -147
  218. package/framework/GPChannelSDKCore.xcframework/ios-arm64_x86_64-simulator/GPChannelSDKCore.framework/GPChannelSDKCore +0 -0
  219. package/framework/GPChannelSDKCore.xcframework/ios-arm64_x86_64-simulator/GPChannelSDKCore.framework/Headers/GPChannelSDK.h +0 -315
  220. package/framework/GPChannelSDKCore.xcframework/ios-arm64_x86_64-simulator/GPChannelSDKCore.framework/Headers/GPChannelSDKCore.h +0 -19
  221. package/framework/GPChannelSDKCore.xcframework/ios-arm64_x86_64-simulator/GPChannelSDKCore.framework/Info.plist +0 -0
  222. package/framework/GPChannelSDKCore.xcframework/ios-arm64_x86_64-simulator/GPChannelSDKCore.framework/Modules/module.modulemap +0 -7
  223. 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
+ }