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 #include "hitls_build.h"
17
18 #if defined(HITLS_CRYPTO_CODECS) && defined(HITLS_CRYPTO_PROVIDER)
19 #include "securec.h"
20 #include "bsl_sal.h"
21 #include "bsl_list.h"
22 #include "bsl_err_internal.h"
23 #include "crypt_errno.h"
24 #include "crypt_eal_provider.h"
25 #include "crypt_eal_implprovider.h"
26 #include "crypt_provider.h"
27 #include "crypt_eal_pkey.h"
28 #include "crypt_eal_codecs.h"
29 #include "bsl_types.h"
30 #include "crypt_types.h"
31 #include "crypt_utils.h"
32 #include "decode_local.h"
33
CRYPT_DECODE_ParseDecoderAttr(const char * attrName,DECODER_AttrInfo * info)34 int32_t CRYPT_DECODE_ParseDecoderAttr(const char *attrName, DECODER_AttrInfo *info)
35 {
36 char *rest = NULL;
37 info->inFormat = NULL;
38 info->inType = NULL;
39 info->outFormat = NULL;
40 info->outType = NULL;
41 info->attrName = (char *)BSL_SAL_Dump(attrName, (uint32_t)strlen(attrName) + 1);
42 if (info->attrName == NULL) {
43 BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
44 return CRYPT_MEM_ALLOC_FAIL;
45 }
46 char *token = strtok_s(info->attrName, ",", &rest);
47 while (token != NULL) {
48 while (*token == ' ') {
49 token++;
50 }
51
52 if (strstr(token, "inFormat=") == token) {
53 info->inFormat = token + strlen("inFormat=");
54 } else if (strstr(token, "inType=") == token) {
55 info->inType = token + strlen("inType=");
56 } else if (strstr(token, "outFormat=") == token) {
57 info->outFormat = token + strlen("outFormat=");
58 } else if (strstr(token, "outType=") == token) {
59 info->outType = token + strlen("outType=");
60 }
61
62 token = strtok_s(NULL, ",", &rest);
63 }
64
65 return CRYPT_SUCCESS;
66 }
67
SetDecoderMethod(CRYPT_DECODER_Ctx * ctx,const CRYPT_EAL_Func * funcs)68 static int32_t SetDecoderMethod(CRYPT_DECODER_Ctx *ctx, const CRYPT_EAL_Func *funcs)
69 {
70 int32_t index = 0;
71 CRYPT_DECODER_Method *method = BSL_SAL_Calloc(1, sizeof(CRYPT_DECODER_Method));
72 if (method == NULL) {
73 BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
74 return CRYPT_MEM_ALLOC_FAIL;
75 }
76 while (funcs[index].func != NULL) {
77 switch (funcs[index].id) {
78 case CRYPT_DECODER_IMPL_NEWCTX:
79 method->newCtx = (CRYPT_DECODER_IMPL_NewCtx)funcs[index].func;
80 break;
81 case CRYPT_DECODER_IMPL_SETPARAM:
82 method->setParam = (CRYPT_DECODER_IMPL_SetParam)funcs[index].func;
83 break;
84 case CRYPT_DECODER_IMPL_GETPARAM:
85 method->getParam = (CRYPT_DECODER_IMPL_GetParam)funcs[index].func;
86 break;
87 case CRYPT_DECODER_IMPL_DECODE:
88 method->decode = (CRYPT_DECODER_IMPL_Decode)funcs[index].func;
89 break;
90 case CRYPT_DECODER_IMPL_FREEOUTDATA:
91 method->freeOutData = (CRYPT_DECODER_IMPL_FreeOutData)funcs[index].func;
92 break;
93 case CRYPT_DECODER_IMPL_FREECTX:
94 method->freeCtx = (CRYPT_DECODER_IMPL_FreeCtx)funcs[index].func;
95 break;
96 default:
97 BSL_SAL_Free(method);
98 BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL);
99 return CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL;
100 }
101 index++;
102 }
103 ctx->method = method;
104 return CRYPT_SUCCESS;
105 }
106
CRYPT_DECODE_NewDecoderCtxByMethod(const CRYPT_EAL_Func * funcs,CRYPT_EAL_ProvMgrCtx * mgrCtx,const char * attrName)107 CRYPT_DECODER_Ctx *CRYPT_DECODE_NewDecoderCtxByMethod(const CRYPT_EAL_Func *funcs, CRYPT_EAL_ProvMgrCtx *mgrCtx,
108 const char *attrName)
109 {
110 void *provCtx = NULL;
111 DECODER_AttrInfo attrInfo = {0};
112 CRYPT_DECODER_Ctx *ctx = BSL_SAL_Calloc(1, sizeof(CRYPT_DECODER_Ctx));
113 if (ctx == NULL) {
114 BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
115 return NULL;
116 }
117 int32_t ret = CRYPT_EAL_ProviderCtrl(mgrCtx, CRYPT_PROVIDER_GET_USER_CTX, &provCtx, sizeof(provCtx));
118 if (ret != CRYPT_SUCCESS) {
119 goto ERR;
120 }
121 ret = SetDecoderMethod(ctx, funcs);
122 if (ret != CRYPT_SUCCESS) {
123 goto ERR;
124 }
125 if (ctx->method->newCtx == NULL || ctx->method->setParam == NULL) {
126 BSL_ERR_PUSH_ERROR(CRYPT_NOT_SUPPORT);
127 goto ERR;
128 }
129 ctx->decoderCtx = ctx->method->newCtx(provCtx);
130 if (ctx->decoderCtx == NULL) {
131 BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
132 goto ERR;
133 }
134 BSL_Param param[2] = {{CRYPT_PARAM_DECODE_PROVIDER_CTX, BSL_PARAM_TYPE_CTX_PTR, mgrCtx, 0, 0},
135 BSL_PARAM_END};
136 ret = ctx->method->setParam(ctx->decoderCtx, param);
137 if (ret != CRYPT_SUCCESS) {
138 BSL_ERR_PUSH_ERROR(ret);
139 goto ERR;
140 }
141 if (attrName != NULL) {
142 ret = CRYPT_DECODE_ParseDecoderAttr(attrName, &attrInfo);
143 if (ret != CRYPT_SUCCESS) {
144 goto ERR;
145 }
146 }
147 ctx->providerMgrCtx = mgrCtx;
148 ctx->inFormat = attrInfo.inFormat;
149 ctx->inType = attrInfo.inType;
150 ctx->outFormat = attrInfo.outFormat;
151 ctx->outType = attrInfo.outType;
152 ctx->attrName = attrName != NULL ? attrInfo.attrName : NULL;
153 ctx->decoderState = CRYPT_DECODER_STATE_UNTRIED;
154 return ctx;
155 ERR:
156 CRYPT_DECODE_Free(ctx);
157 return NULL;
158 }
159
CRYPT_DECODE_ProviderNewCtx(CRYPT_EAL_LibCtx * libCtx,int32_t keyType,const char * attrName)160 CRYPT_DECODER_Ctx *CRYPT_DECODE_ProviderNewCtx(CRYPT_EAL_LibCtx *libCtx, int32_t keyType, const char *attrName)
161 {
162 const CRYPT_EAL_Func *funcsDecoder = NULL;
163 CRYPT_EAL_ProvMgrCtx *mgrCtx = NULL;
164 int32_t ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_DECODER, keyType, attrName,
165 &funcsDecoder, &mgrCtx);
166 if (ret != CRYPT_SUCCESS) {
167 BSL_ERR_PUSH_ERROR(ret);
168 return NULL;
169 }
170 if (mgrCtx == NULL) {
171 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
172 return NULL;
173 }
174 return CRYPT_DECODE_NewDecoderCtxByMethod(funcsDecoder, mgrCtx, attrName);
175 }
176
177 /* Free decoder context */
CRYPT_DECODE_Free(CRYPT_DECODER_Ctx * ctx)178 void CRYPT_DECODE_Free(CRYPT_DECODER_Ctx *ctx)
179 {
180 if (ctx == NULL) {
181 return;
182 }
183
184 if (ctx->method != NULL && ctx->method->freeCtx != NULL) {
185 ctx->method->freeCtx(ctx->decoderCtx);
186 }
187 BSL_SAL_Free(ctx->method);
188 BSL_SAL_Free(ctx->attrName);
189 BSL_SAL_Free(ctx);
190 }
191
192 /* Set decoder parameters */
CRYPT_DECODE_SetParam(CRYPT_DECODER_Ctx * ctx,const BSL_Param * param)193 int32_t CRYPT_DECODE_SetParam(CRYPT_DECODER_Ctx *ctx, const BSL_Param *param)
194 {
195 if (ctx == NULL || param == NULL) {
196 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
197 return CRYPT_NULL_INPUT;
198 }
199
200 if (ctx->method == NULL || ctx->method->setParam == NULL) {
201 BSL_ERR_PUSH_ERROR(CRYPT_NOT_SUPPORT);
202 return CRYPT_NOT_SUPPORT;
203 }
204
205 return ctx->method->setParam(ctx->decoderCtx, param);
206 }
207
208 /* Get decoder parameters */
CRYPT_DECODE_GetParam(CRYPT_DECODER_Ctx * ctx,BSL_Param * param)209 int32_t CRYPT_DECODE_GetParam(CRYPT_DECODER_Ctx *ctx, BSL_Param *param)
210 {
211 if (ctx == NULL || param == NULL) {
212 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
213 return CRYPT_NULL_INPUT;
214 }
215
216 if (ctx->method == NULL || ctx->method->getParam == NULL) {
217 BSL_ERR_PUSH_ERROR(CRYPT_NOT_SUPPORT);
218 return CRYPT_NOT_SUPPORT;
219 }
220
221 return ctx->method->getParam(ctx->decoderCtx, param);
222 }
223
224 /* Execute decode operation */
CRYPT_DECODE_Decode(CRYPT_DECODER_Ctx * ctx,const BSL_Param * inParam,BSL_Param ** outParam)225 int32_t CRYPT_DECODE_Decode(CRYPT_DECODER_Ctx *ctx, const BSL_Param *inParam, BSL_Param **outParam)
226 {
227 if (ctx == NULL || inParam == NULL || outParam == NULL) {
228 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
229 return CRYPT_NULL_INPUT;
230 }
231
232 if (ctx->method == NULL || ctx->method->decode == NULL) {
233 BSL_ERR_PUSH_ERROR(CRYPT_NOT_SUPPORT);
234 return CRYPT_NOT_SUPPORT;
235 }
236
237 int32_t ret = ctx->method->decode(ctx->decoderCtx, inParam, outParam);
238 if (ret != CRYPT_SUCCESS) {
239 BSL_ERR_PUSH_ERROR(ret);
240 }
241
242 return ret;
243 }
244
CRYPT_DECODE_FreeOutData(CRYPT_DECODER_Ctx * ctx,BSL_Param * outData)245 void CRYPT_DECODE_FreeOutData(CRYPT_DECODER_Ctx *ctx, BSL_Param *outData)
246 {
247 if (ctx == NULL || outData == NULL) {
248 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
249 return;
250 }
251 if (ctx->method == NULL || ctx->method->freeOutData == NULL) {
252 BSL_ERR_PUSH_ERROR(CRYPT_NOT_SUPPORT);
253 return;
254 }
255
256 ctx->method->freeOutData(ctx->decoderCtx, outData);
257 }
258
259 #endif /* HITLS_CRYPTO_CODECS && HITLS_CRYPTO_PROVIDER */
260