1 /*
2 * This file is part of the openHiTLS project.
3 *
4 * openHiTLS is licensed under the Mulan PSL v2.
5 * You can use this software according to the terms and conditions of the Mulan PSL v2.
6 * You may obtain a copy of Mulan PSL v2 at:
7 *
8 * http://license.coscl.org.cn/MulanPSL2
9 *
10 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
11 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
12 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
13 * See the Mulan PSL v2 for more details.
14 */
15
16 // Source code for the test .so file
17
18 #include <stdio.h>
19 #include <stdint.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include "crypt_errno.h"
23 #include "crypt_eal_provider.h"
24 #include "crypt_eal_implprovider.h"
25
26 #define CRYPT_EAL_DEFAULT_ATTR "provider=test1,compare1=one,cpmpare3=three"
27 #define RESULT 1415926
28
Provider_NewCtx(void * provCtx,int32_t algid,BSL_Param * param)29 void *Provider_NewCtx(void *provCtx, int32_t algid, BSL_Param *param)
30 {
31 (void)provCtx;
32 (void)param;
33 int *ctx = malloc(sizeof(int));
34 return ctx;
35 }
36
Provider_FreeCtx(void * ctx)37 int32_t Provider_FreeCtx(void *ctx)
38 {
39 free(ctx);
40 return 0;
41 }
42
MD5_Init(void * mdCtx)43 int32_t MD5_Init(void *mdCtx)
44 {
45 mdCtx = NULL;
46 return RESULT;
47 }
48
49 const CRYPT_EAL_Func defMdMd5[] = {
50 {CRYPT_EAL_IMPLMD_NEWCTX, Provider_NewCtx},
51 {CRYPT_EAL_IMPLMD_INITCTX, MD5_Init},
52 {CRYPT_EAL_IMPLMD_UPDATE, NULL},
53 {CRYPT_EAL_IMPLMD_FINAL, NULL},
54 {CRYPT_EAL_IMPLMD_DEINITCTX, NULL},
55 {CRYPT_EAL_IMPLMD_DUPCTX, NULL},
56 {CRYPT_EAL_IMPLMD_CTRL, NULL},
57 {CRYPT_EAL_IMPLMD_FREECTX, Provider_FreeCtx},
58 CRYPT_EAL_FUNC_END,
59 };
60
61 const CRYPT_EAL_Func defKdfScrypt[] = {
62 {CRYPT_EAL_IMPLKDF_NEWCTX, Provider_NewCtx},
63 {CRYPT_EAL_IMPLKDF_SETPARAM, NULL},
64 {CRYPT_EAL_IMPLKDF_DERIVE, NULL},
65 {CRYPT_EAL_IMPLKDF_DEINITCTX, NULL},
66 {CRYPT_EAL_IMPLKDF_CTRL, NULL},
67 {CRYPT_EAL_IMPLKDF_FREECTX, Provider_FreeCtx},
68 CRYPT_EAL_FUNC_END,
69 };
70
71 const CRYPT_EAL_Func defMacHmac[] = {
72 {CRYPT_EAL_IMPLMAC_NEWCTX, Provider_NewCtx},
73 {CRYPT_EAL_IMPLMAC_INIT, NULL},
74 {CRYPT_EAL_IMPLMAC_UPDATE, NULL},
75 {CRYPT_EAL_IMPLMAC_FINAL, NULL},
76 {CRYPT_EAL_IMPLMAC_REINITCTX, NULL},
77 {CRYPT_EAL_IMPLMAC_CTRL, NULL},
78 {CRYPT_EAL_IMPLMAC_FREECTX, Provider_FreeCtx},
79 CRYPT_EAL_FUNC_END,
80 };
81
82 const CRYPT_EAL_Func defKeyMgmtDsa[] = {
83 {CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, Provider_NewCtx},
84 {CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, NULL},
85 {CRYPT_EAL_IMPLPKEYMGMT_GETPARAM, NULL},
86 {CRYPT_EAL_IMPLPKEYMGMT_GENKEY, NULL},
87 {CRYPT_EAL_IMPLPKEYMGMT_SETPRV, NULL},
88 {CRYPT_EAL_IMPLPKEYMGMT_SETPUB, NULL},
89 {CRYPT_EAL_IMPLPKEYMGMT_GETPRV, NULL},
90 {CRYPT_EAL_IMPLPKEYMGMT_GETPUB, NULL},
91 {CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, NULL},
92 {CRYPT_EAL_IMPLPKEYMGMT_CHECK, NULL},
93 {CRYPT_EAL_IMPLPKEYMGMT_COMPARE, NULL},
94 {CRYPT_EAL_IMPLPKEYMGMT_CTRL, NULL},
95 {CRYPT_EAL_IMPLPKEYMGMT_FREECTX, Provider_FreeCtx},
96 CRYPT_EAL_FUNC_END,
97 };
98
99 const CRYPT_EAL_Func defAsymCipherRsa[] = {
100 {CRYPT_EAL_IMPLPKEYCIPHER_ENCRYPT, NULL},
101 {CRYPT_EAL_IMPLPKEYCIPHER_DECRYPT, NULL},
102 CRYPT_EAL_FUNC_END
103 };
104
105 const CRYPT_EAL_Func defExchX25519[] = {
106 {CRYPT_EAL_IMPLPKEYEXCH_EXCH, NULL},
107 CRYPT_EAL_FUNC_END
108 };
109
110 const CRYPT_EAL_Func defSignDsa[] = {
111 {CRYPT_EAL_IMPLPKEYSIGN_SIGN, NULL},
112 {CRYPT_EAL_IMPLPKEYSIGN_VERIFY, NULL},
113 CRYPT_EAL_FUNC_END,
114 };
115 static const CRYPT_EAL_AlgInfo defMds[] = {
116 {CRYPT_MD_MD5, defMdMd5, CRYPT_EAL_DEFAULT_ATTR},
117 CRYPT_EAL_ALGINFO_END
118 };
119
120 static const CRYPT_EAL_AlgInfo defKdfs[] = {
121 {CRYPT_KDF_SCRYPT, defKdfScrypt, CRYPT_EAL_DEFAULT_ATTR},
122 CRYPT_EAL_ALGINFO_END
123 };
124
125 static const CRYPT_EAL_AlgInfo defKeyMgmt[] = {
126 {CRYPT_PKEY_DSA, defKeyMgmtDsa, CRYPT_EAL_DEFAULT_ATTR},
127 CRYPT_EAL_ALGINFO_END
128 };
129
130 static const CRYPT_EAL_AlgInfo defAsymCiphers[] = {
131 {CRYPT_PKEY_RSA, defAsymCipherRsa, CRYPT_EAL_DEFAULT_ATTR},
132 CRYPT_EAL_ALGINFO_END
133 };
134
135 static const CRYPT_EAL_AlgInfo defKeyExch[] = {
136 {CRYPT_PKEY_X25519, defExchX25519, CRYPT_EAL_DEFAULT_ATTR},
137 CRYPT_EAL_ALGINFO_END
138 };
139
140 static const CRYPT_EAL_AlgInfo defSigns[] = {
141 {CRYPT_PKEY_DSA, defSignDsa, CRYPT_EAL_DEFAULT_ATTR},
142 CRYPT_EAL_ALGINFO_END
143 };
144
145 static const CRYPT_EAL_AlgInfo defMacs[] = {
146 {CRYPT_MAC_HMAC_MD5, defMacHmac, CRYPT_EAL_DEFAULT_ATTR},
147 CRYPT_EAL_ALGINFO_END
148 };
149
CRYPT_EAL_DefaultProvQuery(void * provCtx,int32_t operaId,const CRYPT_EAL_AlgInfo ** algInfos)150 static int32_t CRYPT_EAL_DefaultProvQuery(void *provCtx, int32_t operaId, const CRYPT_EAL_AlgInfo **algInfos)
151 {
152 (void) provCtx;
153 int32_t ret = CRYPT_SUCCESS;
154 switch (operaId) {
155 case CRYPT_EAL_OPERAID_SYMMCIPHER:
156 break;
157 case CRYPT_EAL_OPERAID_KEYMGMT:
158 *algInfos = defKeyMgmt;
159 break;
160 case CRYPT_EAL_OPERAID_SIGN:
161 *algInfos = defSigns;
162 break;
163 case CRYPT_EAL_OPERAID_ASYMCIPHER:
164 *algInfos = defAsymCiphers;
165 break;
166 case CRYPT_EAL_OPERAID_KEYEXCH:
167 *algInfos = defKeyExch;
168 break;
169 case CRYPT_EAL_OPERAID_KEM:
170 break;
171 case CRYPT_EAL_OPERAID_HASH:
172 *algInfos = defMds;
173 break;
174 case CRYPT_EAL_OPERAID_MAC:
175 *algInfos = defMacs;
176 break;
177 case CRYPT_EAL_OPERAID_KDF:
178 *algInfos = defKdfs;
179 break;
180 case CRYPT_EAL_OPERAID_RAND:
181 break;
182 default:
183 ret = CRYPT_NOT_SUPPORT;
184 break;
185 }
186 return ret;
187 }
CRYPT_EAL_DefaultProvFree(void * provCtx)188 static void CRYPT_EAL_DefaultProvFree(void *provCtx)
189 {
190 return;
191 }
192
193 static CRYPT_EAL_Func defProvOutFuncs[] = {
194 {CRYPT_EAL_PROVCB_QUERY, CRYPT_EAL_DefaultProvQuery},
195 {CRYPT_EAL_PROVCB_FREE, CRYPT_EAL_DefaultProvFree},
196 {CRYPT_EAL_PROVCB_CTRL, NULL},
197 CRYPT_EAL_FUNC_END
198 };
199
CRYPT_EAL_ProviderInit(CRYPT_EAL_ProvMgrCtx * mgrCtx,BSL_Param * param,CRYPT_EAL_Func * capFuncs,CRYPT_EAL_Func ** outFuncs,void ** provCtx)200 int32_t CRYPT_EAL_ProviderInit(CRYPT_EAL_ProvMgrCtx *mgrCtx,
201 BSL_Param *param, CRYPT_EAL_Func *capFuncs, CRYPT_EAL_Func **outFuncs, void **provCtx)
202 {
203 CRYPT_RandSeedMethod entroy = {0};
204 CRYPT_EAL_ProvMgrCtrlCb mgrCtrl = NULL;
205 int32_t index = 0;
206 while (capFuncs[index].id != 0) {
207 switch (capFuncs[index].id) {
208 case CRYPT_EAL_CAP_GETENTROPY:
209 entroy.getEntropy = capFuncs[index].func;
210 break;
211 case CRYPT_EAL_CAP_CLEANENTROPY:
212 entroy.cleanEntropy = capFuncs[index].func;
213 break;
214 case CRYPT_EAL_CAP_GETNONCE:
215 entroy.getNonce = capFuncs[index].func;
216 break;
217 case CRYPT_EAL_CAP_CLEANNONCE:
218 entroy.cleanNonce = capFuncs[index].func;
219 break;
220 case CRYPT_EAL_CAP_MGRCTXCTRL:
221 mgrCtrl = capFuncs[index].func;
222 break;
223 default:
224 return CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL;
225 }
226 index++;
227 }
228 void *seedCtx = NULL;
229 void *libCtx = NULL;
230 if (entroy.getEntropy == NULL || entroy.cleanEntropy == NULL || entroy.getNonce == NULL ||
231 entroy.cleanNonce == NULL || mgrCtrl == NULL) {
232 return CRYPT_NULL_INPUT;
233 }
234 int32_t ret = mgrCtrl(mgrCtx, CRYPT_EAL_MGR_GETSEEDCTX, &seedCtx, 0);
235 if (ret != CRYPT_SUCCESS) {
236 return ret;
237 }
238 ret = mgrCtrl(mgrCtx, CRYPT_EAL_MGR_GETLIBCTX, &libCtx, 0);
239 if (ret != CRYPT_SUCCESS) {
240 return ret;
241 }
242 CRYPT_Data entropy = {NULL, 0};
243 CRYPT_Range entropyRange = {32, 2147483632};
244 ret = entroy.getEntropy(seedCtx, &entropy, 256, &entropyRange);
245 if (ret != CRYPT_SUCCESS) {
246 return CRYPT_DRBG_FAIL_GET_ENTROPY;
247 }
248 entroy.cleanEntropy(seedCtx, &entropy);
249 // check libCtx
250 if (param != NULL) {
251 if (param[0].value != libCtx) {
252 return CRYPT_INVALID_ARG;
253 }
254 }
255 *outFuncs = defProvOutFuncs;
256 return 0;
257 }
258