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_CODECSKEY) && defined(HITLS_CRYPTO_KEY_EPKI) && defined(HITLS_CRYPTO_PROVIDER)
19 #include <string.h>
20 #include "crypt_eal_implprovider.h"
21 #include "crypt_params_key.h"
22 #include "crypt_errno.h"
23 #include "bsl_types.h"
24 #include "bsl_params.h"
25 #include "bsl_err_internal.h"
26 #include "crypt_encode_decode_local.h"
27 #include "crypt_decode_key_impl.h"
28
29 typedef struct DECODER_EPki2PkiCtx {
30 CRYPT_EAL_LibCtx *libCtx;
31 const char *attrName;
32 const char *outFormat;
33 const char *outType;
34 } DECODER_EPki2PkiCtx;
35
DECODER_EPKI2PKI_NewCtx(void * provCtx)36 void *DECODER_EPKI2PKI_NewCtx(void *provCtx)
37 {
38 (void)provCtx;
39 DECODER_EPki2PkiCtx *ctx = (DECODER_EPki2PkiCtx *)BSL_SAL_Calloc(1, sizeof(DECODER_EPki2PkiCtx));
40 if (ctx == NULL) {
41 BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
42 return NULL;
43 }
44 ctx->outFormat = "ASN1";
45 ctx->outType = "PRIKEY_PKCS8_UNENCRYPT";
46 return ctx;
47 }
48
DECODER_EPKI2PKI_GetParam(void * ctx,BSL_Param * param)49 int32_t DECODER_EPKI2PKI_GetParam(void *ctx, BSL_Param *param)
50 {
51 DECODER_EPki2PkiCtx *decoderCtx = (DECODER_EPki2PkiCtx *)ctx;
52 if (decoderCtx == NULL) {
53 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
54 return CRYPT_NULL_INPUT;
55 }
56 DECODER_CommonCtx commonCtx = {
57 .outFormat = decoderCtx->outFormat,
58 .outType = decoderCtx->outType
59 };
60 return DECODER_CommonGetParam(&commonCtx, param);
61 }
62
DECODER_EPKI2PKI_SetParam(void * ctx,const BSL_Param * param)63 int32_t DECODER_EPKI2PKI_SetParam(void *ctx, const BSL_Param *param)
64 {
65 DECODER_EPki2PkiCtx *decoderCtx = (DECODER_EPki2PkiCtx *)ctx;
66 if (decoderCtx == NULL || param == NULL) {
67 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
68 return CRYPT_NULL_INPUT;
69 }
70 const BSL_Param *attrNameParam = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_DECODE_TARGET_ATTR_NAME);
71 if (attrNameParam != NULL) {
72 if (attrNameParam->valueType != BSL_PARAM_TYPE_OCTETS_PTR) {
73 BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
74 return CRYPT_INVALID_ARG;
75 }
76 decoderCtx->attrName = (const char *)attrNameParam->value;
77 }
78 const BSL_Param *libCtxParam = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_DECODE_LIB_CTX);
79 if (libCtxParam != NULL) {
80 if (libCtxParam->valueType != BSL_PARAM_TYPE_CTX_PTR) {
81 BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
82 return CRYPT_INVALID_ARG;
83 }
84 decoderCtx->libCtx = (CRYPT_EAL_LibCtx *)(uintptr_t)libCtxParam->value;
85 }
86 return CRYPT_SUCCESS;
87 }
88
DECODER_EPKI2PKI_Decode(void * ctx,const BSL_Param * inParam,BSL_Param ** outParam)89 int32_t DECODER_EPKI2PKI_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam)
90 {
91 DECODER_EPki2PkiCtx *decoderCtx = (DECODER_EPki2PkiCtx *)ctx;
92 if (decoderCtx == NULL || inParam == NULL || outParam == NULL) {
93 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
94 return CRYPT_NULL_INPUT;
95 }
96 const BSL_Param *inputParam = BSL_PARAM_FindConstParam(inParam, CRYPT_PARAM_DECODE_BUFFER_DATA);
97 if (inputParam == NULL || inputParam->value == NULL || inputParam->valueType != BSL_PARAM_TYPE_OCTETS) {
98 BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
99 return CRYPT_INVALID_ARG;
100 }
101 const BSL_Param *passParam = BSL_PARAM_FindConstParam(inParam, CRYPT_PARAM_DECODE_PASSWORD);
102 if (passParam == NULL || passParam->valueType != BSL_PARAM_TYPE_OCTETS) {
103 BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
104 return CRYPT_INVALID_ARG;
105 }
106 BSL_Buffer input = {(uint8_t *)(uintptr_t)inputParam->value, inputParam->valueLen};
107 BSL_Buffer pwdBuff = {(uint8_t *)(uintptr_t)passParam->value, passParam->valueLen};
108 BSL_Buffer decode = {NULL, 0};
109 int32_t ret = CRYPT_DECODE_Pkcs8PrvDecrypt(decoderCtx->libCtx, decoderCtx->attrName, &input,
110 &pwdBuff, NULL, &decode);
111 if (ret != CRYPT_SUCCESS) {
112 BSL_ERR_PUSH_ERROR(ret);
113 return ret;
114 }
115 return CRYPT_DECODE_ConstructBufferOutParam(outParam, decode.data, decode.dataLen);
116 }
117
DECODER_EPKI2PKI_FreeCtx(void * ctx)118 void DECODER_EPKI2PKI_FreeCtx(void *ctx)
119 {
120 if (ctx == NULL) {
121 return;
122 }
123 BSL_SAL_Free(ctx);
124 }
125
DECODER_EPKI2PKI_FreeOutData(void * ctx,BSL_Param * outParam)126 void DECODER_EPKI2PKI_FreeOutData(void *ctx, BSL_Param *outParam)
127 {
128 (void)ctx;
129 if (outParam == NULL) {
130 return;
131 }
132 BSL_Param *dataParam = BSL_PARAM_FindParam(outParam, CRYPT_PARAM_DECODE_BUFFER_DATA);
133 if (dataParam == NULL) {
134 return;
135 }
136 BSL_SAL_ClearFree(dataParam->value, dataParam->valueLen);
137 BSL_SAL_Free(outParam);
138 }
139
140 #endif /* HITLS_CRYPTO_CODECSKEY && HITLS_CRYPTO_EPKI2PKI && HITLS_CRYPTO_PROVIDER */
141