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