1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define HUKS_DISABLE_LOG_AT_FILE_TO_REDUCE_ROM_SIZE
16
17 #ifdef HKS_CONFIG_FILE
18 #include HKS_CONFIG_FILE
19 #else
20 #include "hks_config.h"
21 #endif
22
23 #include "hks_ability.h"
24 #include "hks_core_ability.h"
25
26 #include "hks_crypto_ed25519.h"
27 #include "hks_log.h"
28 #include "hks_mbedtls_aes.h"
29 #include "hks_mbedtls_bn.h"
30 #include "hks_mbedtls_common.h"
31 #include "hks_mbedtls_des.h"
32 #include "hks_mbedtls_3des.h"
33 #include "hks_mbedtls_dh.h"
34 #include "hks_mbedtls_dsa.h"
35 #include "hks_mbedtls_ecc.h"
36 #include "hks_mbedtls_ecdh.h"
37 #include "hks_mbedtls_ecdsa.h"
38 #include "hks_mbedtls_hash.h"
39 #include "hks_mbedtls_hmac.h"
40 #include "hks_mbedtls_kdf.h"
41 #include "hks_mbedtls_rsa.h"
42 #include "hks_mbedtls_x25519.h"
43
44 #ifdef _CUT_AUTHENTICATE_
45 #undef HKS_SUPPORT_HASH_C
46 #undef HKS_SUPPORT_RSA_C
47 #undef HKS_SUPPORT_ECC_C
48 #undef HKS_SUPPORT_X25519_C
49 #undef HKS_SUPPORT_ED25519_C
50 #undef HKS_SUPPORT_KDF_PBKDF2
51 #endif
52
RegisterAbilityGenerateKey(void)53 static void RegisterAbilityGenerateKey(void)
54 {
55 #if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY)
56 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_AES), (void *)HksMbedtlsAesGenerateKey);
57 #endif
58 #if defined(HKS_SUPPORT_DES_C) && defined(HKS_SUPPORT_DES_GENERATE_KEY)
59 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_DES), (void *)HksMbedtlsDesGenerateKey);
60 #endif
61 #if defined(HKS_SUPPORT_3DES_C) && defined(HKS_SUPPORT_3DES_GENERATE_KEY)
62 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_3DES), (void *)HksMbedtls3DesGenerateKey);
63 #endif
64 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
65 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_RSA), (void *)HksMbedtlsRsaGenerateKey);
66 #endif
67 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
68 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_ECC), (void *)HksMbedtlsEccGenerateKey);
69 #endif
70 #if defined(HKS_SUPPORT_X25519_C) && defined(HKS_SUPPORT_X25519_GENERATE_KEY)
71 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_X25519), (void *)HksMbedtlsX25519GenerateKey);
72 #endif
73 #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED25519_GENERATE_KEY)
74 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_ED25519), (void *)HksEd25519GenerateKey);
75 #endif
76 #if defined(HKS_SUPPORT_HMAC_C) && defined(HKS_SUPPORT_HMAC_GENERATE_KEY)
77 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_HMAC), (void *)HksMbedtlsHmacGenerateKey);
78 #endif
79 #if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GENERATE_KEY)
80 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_DSA), (void *)HksMbedtlsDsaGenerateKey);
81 #endif
82 #if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GENERATE_KEY)
83 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_DH), (void *)HksMbedtlsDhGenerateKey);
84 #endif
85 }
86
RegisterAbilityGetPublicKey(void)87 static void RegisterAbilityGetPublicKey(void)
88 {
89 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GET_PUBLIC_KEY)
90 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(HKS_ALG_RSA), (void *)HksMbedtlsGetRsaPubKey);
91 #endif
92 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GET_PUBLIC_KEY)
93 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(HKS_ALG_ECC), (void *)HksMbedtlsGetEccPubKey);
94 #endif
95 #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED2519_GET_PUBLIC_KEY)
96 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(HKS_ALG_ED25519), (void *)HksGetEd25519PubKey);
97 #endif
98 #if defined(HKS_SUPPORT_X25519_C) && defined(HKS_SUPPORT_X25519_GET_PUBLIC_KEY)
99 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(HKS_ALG_X25519), (void *)HksMbedtlsGetX25519PubKey);
100 #endif
101 #if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GET_PUBLIC_KEY)
102 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(HKS_ALG_DH), (void *)HksMbedtlsGetDhPubKey);
103 #endif
104 }
105
RegisterAbilitySign(void)106 static void RegisterAbilitySign(void)
107 {
108 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY)
109 (void)RegisterAbility(HKS_CRYPTO_ABILITY_SIGN(HKS_ALG_RSA), (void *)HksMbedtlsRsaSign);
110 #endif
111 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) && defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY)
112 (void)RegisterAbility(HKS_CRYPTO_ABILITY_SIGN(HKS_ALG_ECC), (void *)HksMbedtlsEcdsaSign);
113 #endif
114 #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED25519_SIGN_VERIFY)
115 (void)RegisterAbility(HKS_CRYPTO_ABILITY_SIGN(HKS_ALG_ED25519), (void *)HksEd25519Sign);
116 #endif
117 }
118
RegisterAbilityVerify(void)119 static void RegisterAbilityVerify(void)
120 {
121 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY)
122 (void)RegisterAbility(HKS_CRYPTO_ABILITY_VERIFY(HKS_ALG_RSA), (void *)HksMbedtlsRsaVerify);
123 #endif
124 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) && defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY)
125 (void)RegisterAbility(HKS_CRYPTO_ABILITY_VERIFY(HKS_ALG_ECC), (void *)HksMbedtlsEcdsaVerify);
126 #endif
127 #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED25519_SIGN_VERIFY)
128 (void)RegisterAbility(HKS_CRYPTO_ABILITY_VERIFY(HKS_ALG_ED25519), (void *)HksEd25519Verify);
129 #endif
130 }
131
RegisterAbilityEncrypt(void)132 static void RegisterAbilityEncrypt(void)
133 {
134 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_CRYPT)
135 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT(HKS_ALG_RSA), (void *)HksMbedtlsRsaEncrypt);
136 #endif
137 #ifdef HKS_SUPPORT_AES_C
138 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT(HKS_ALG_AES), (void *)HksMbedtlsAesEncrypt);
139 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_INIT(HKS_ALG_AES),
140 (void *)HksMbedtlsAesCryptoInit);
141 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_UPDATE(HKS_ALG_AES),
142 (void *)HksMbedtlsAesCryptoUpdate);
143 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_FINAL(HKS_ALG_AES),
144 (void *)HksMbedtlsAesCryptoFinal);
145 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_FREE_CTX(HKS_ALG_AES),
146 (void *)HksMbedtlsAesHalFreeCtx);
147 #endif
148 #ifdef HKS_SUPPORT_DES_C
149 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_INIT(HKS_ALG_DES),
150 (void *)HksMbedtlsDesCryptoInit);
151 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_UPDATE(HKS_ALG_DES),
152 (void *)HksMbedtlsDesCryptoUpdate);
153 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_FINAL(HKS_ALG_DES),
154 (void *)HksMbedtlsDesCryptoFinal);
155 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_FREE_CTX(HKS_ALG_DES),
156 (void *)HksMbedtlsDesHalFreeCtx);
157 #endif
158 #ifdef HKS_SUPPORT_3DES_C
159 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_INIT(HKS_ALG_3DES),
160 (void *)HksMbedtls3DesCryptoInit);
161 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_UPDATE(HKS_ALG_3DES),
162 (void *)HksMbedtls3DesCryptoUpdate);
163 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_FINAL(HKS_ALG_3DES),
164 (void *)HksMbedtls3DesCryptoFinal);
165 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_FREE_CTX(HKS_ALG_3DES),
166 (void *)HksMbedtls3DesHalFreeCtx);
167 #endif
168 }
169
RegisterAbilityDecrypt(void)170 static void RegisterAbilityDecrypt(void)
171 {
172 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_CRYPT)
173 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT(HKS_ALG_RSA), (void *)HksMbedtlsRsaDecrypt);
174 #endif
175 #ifdef HKS_SUPPORT_AES_C
176 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT(HKS_ALG_AES), (void *)HksMbedtlsAesDecrypt);
177 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_INIT(HKS_ALG_AES),
178 (void *)HksMbedtlsAesCryptoInit);
179 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_UPDATE(HKS_ALG_AES),
180 (void *)HksMbedtlsAesCryptoUpdate);
181 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_FINAL(HKS_ALG_AES),
182 (void *)HksMbedtlsAesCryptoFinal);
183 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_FREE_CTX(HKS_ALG_AES),
184 (void *)HksMbedtlsAesHalFreeCtx);
185 #endif
186 #ifdef HKS_SUPPORT_DES_C
187 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_INIT(HKS_ALG_DES),
188 (void *)HksMbedtlsDesCryptoInit);
189 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_UPDATE(HKS_ALG_DES),
190 (void *)HksMbedtlsDesCryptoUpdate);
191 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_FINAL(HKS_ALG_DES),
192 (void *)HksMbedtlsDesCryptoFinal);
193 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_FREE_CTX(HKS_ALG_DES),
194 (void *)HksMbedtlsDesHalFreeCtx);
195 #endif
196 #ifdef HKS_SUPPORT_3DES_C
197 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_INIT(HKS_ALG_3DES),
198 (void *)HksMbedtls3DesCryptoInit);
199 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_UPDATE(HKS_ALG_3DES),
200 (void *)HksMbedtls3DesCryptoUpdate);
201 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_FINAL(HKS_ALG_3DES),
202 (void *)HksMbedtls3DesCryptoFinal);
203 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_FREE_CTX(HKS_ALG_3DES),
204 (void *)HksMbedtls3DesHalFreeCtx);
205 #endif
206 }
207
RegisterAbilityAgree(void)208 static void RegisterAbilityAgree(void)
209 {
210 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDH_C) && defined(HKS_SUPPORT_ECDH_AGREE_KEY)
211 (void)RegisterAbility(HKS_CRYPTO_ABILITY_AGREE_KEY(HKS_ALG_ECDH), (void *)HksMbedtlsEcdh);
212 #endif
213 #if defined(HKS_SUPPORT_X25519_C) && defined(HKS_SUPPORT_X25519_AGREE_KEY)
214 (void)RegisterAbility(HKS_CRYPTO_ABILITY_AGREE_KEY(HKS_ALG_X25519), (void *)HksMbedtlsX25519KeyAgreement);
215 #endif
216 #ifdef HKS_SUPPORT_ED25519_TO_X25519
217 (void)RegisterAbility(HKS_CRYPTO_ABILITY_AGREE_KEY(HKS_ALG_ED25519), (void *)HksMbedtlsEd25519KeyAgreement);
218 #endif
219 #if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_AGREE_KEY)
220 (void)RegisterAbility(HKS_CRYPTO_ABILITY_AGREE_KEY(HKS_ALG_DH), (void *)HksMbedtlsDhAgreeKey);
221 #endif
222 }
223
RegisterAbilityDerive(void)224 static void RegisterAbilityDerive(void)
225 {
226 #ifdef HKS_SUPPORT_KDF_HKDF
227 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DERIVE_KEY(HKS_ALG_HKDF), (void *)HksMbedtlsDeriveKey);
228 #endif
229 #ifdef HKS_SUPPORT_KDF_PBKDF2
230 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DERIVE_KEY(HKS_ALG_PBKDF2), (void *)HksMbedtlsDeriveKey);
231 #endif
232 }
233
RegisterAbilityHash(void)234 static void RegisterAbilityHash(void)
235 {
236 #ifdef HKS_SUPPORT_HASH_C
237 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HASH, (void *)HksMbedtlsHash);
238 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HASH_INIT, (void *)HksMbedtlsHashInit);
239 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HASH_UPDATE, (void *)HksMbedtlsHashUpdate);
240 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HASH_FINAL, (void *)HksMbedtlsHashFinal);
241 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HASH_FREE_CTX, (void *)HksMbedtlsHashFreeCtx);
242 #endif
243 }
244
RegisterAbilityHmac(void)245 static void RegisterAbilityHmac(void)
246 {
247 #ifdef HKS_SUPPORT_HMAC_C
248 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HMAC, (void *)HksMbedtlsHmac);
249 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HMAC_INIT, (void *)HksMbedtlsHmacInit);
250 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HMAC_UPDATE, (void *)HksMbedtlsHmacUpdate);
251 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HMAC_FINAL, (void *)HksMbedtlsHmacFinal);
252 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HMAC_FREE_CTX, (void *)HksMbedtlsHmacHalFreeCtx);
253 #endif
254 }
255
RegisterAbilityFillRandom(void)256 static void RegisterAbilityFillRandom(void)
257 {
258 (void)RegisterAbility(HKS_CRYPTO_ABILITY_FILL_RANDOM, (void *)HksMbedtlsFillRandom);
259 }
260
RegisterAbilityBnExpMod(void)261 static void RegisterAbilityBnExpMod(void)
262 {
263 #ifdef HKS_SUPPORT_BN_C
264 (void)RegisterAbility(HKS_CRYPTO_ABILITY_BN_EXP_MOD, (void *)HksMbedtlsBnExpMod);
265 #endif
266 }
267
HksCryptoAbilityInitBase(void)268 int32_t HksCryptoAbilityInitBase(void)
269 {
270 RegisterAbilityGenerateKey();
271 RegisterAbilityGetPublicKey();
272 RegisterAbilitySign();
273 RegisterAbilityVerify();
274 RegisterAbilityEncrypt();
275 RegisterAbilityDecrypt();
276 RegisterAbilityAgree();
277 RegisterAbilityDerive();
278 RegisterAbilityHmac();
279 RegisterAbilityHash();
280 RegisterAbilityFillRandom();
281 RegisterAbilityBnExpMod();
282 return HKS_SUCCESS;
283 }