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