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 #ifdef HITLS_CRYPTO_ECB
18
19 #include "bsl_err_internal.h"
20 #include "bsl_sal.h"
21 #include "crypt_utils.h"
22 #include "crypt_errno.h"
23 #include "crypt_modes_ecb.h"
24 #include "modes_local.h"
25 #include "securec.h"
26
MODES_ECB_Crypt(MODES_CipherCommonCtx * ctx,const uint8_t * in,uint8_t * out,uint32_t len,bool enc)27 int32_t MODES_ECB_Crypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
28 {
29 // ctx, in, out, these pointer have been judged at the EAL layer and is not judged again here.
30 if (ctx->ciphCtx == NULL || len == 0) {
31 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
32 return CRYPT_NULL_INPUT;
33 }
34 int32_t ret;
35 uint32_t left = len;
36 const uint8_t *input = in;
37 uint8_t *output = out;
38 uint32_t blockSize = ctx->blockSize;
39
40 while (left >= blockSize) {
41 if (enc) {
42 ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, input, output, blockSize);
43 } else {
44 ret = ctx->ciphMeth->decryptBlock(ctx->ciphCtx, input, output, blockSize);
45 }
46 if (ret != CRYPT_SUCCESS) {
47 BSL_ERR_PUSH_ERROR(ret);
48 return ret;
49 }
50 input += blockSize;
51 output += blockSize;
52 left -= blockSize;
53 }
54 if (left > 0) {
55 BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
56 return CRYPT_MODE_ERR_INPUT_LEN;
57 }
58 return CRYPT_SUCCESS;
59 }
60
MODES_ECB_Encrypt(MODES_CipherCommonCtx * ctx,const uint8_t * in,uint8_t * out,uint32_t len)61 int32_t MODES_ECB_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
62 {
63 return MODES_ECB_Crypt(ctx, in, out, len, true);
64 }
65
MODES_ECB_Decrypt(MODES_CipherCommonCtx * ctx,const uint8_t * in,uint8_t * out,uint32_t len)66 int32_t MODES_ECB_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
67 {
68 return MODES_ECB_Crypt(ctx, in, out, len, false);
69 }
70
MODES_ECB_NewCtx(int32_t algId)71 MODES_CipherCtx *MODES_ECB_NewCtx(int32_t algId)
72 {
73 return MODES_CipherNewCtx(algId);
74 }
75
MODES_ECB_InitCtx(MODES_CipherCtx * modeCtx,const uint8_t * key,uint32_t keyLen,const uint8_t * iv,uint32_t ivLen,bool enc)76 int32_t MODES_ECB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
77 uint32_t ivLen, bool enc)
78 {
79 (void)iv;
80 (void)ivLen;
81 int32_t ret;
82 ret = enc ? modeCtx->commonCtx.ciphMeth->setEncryptKey(modeCtx->commonCtx.ciphCtx, key, keyLen) :
83 modeCtx->commonCtx.ciphMeth->setDecryptKey(modeCtx->commonCtx.ciphCtx, key, keyLen);
84 if (ret != CRYPT_SUCCESS) {
85 BSL_ERR_PUSH_ERROR(ret);
86 return ret;
87 }
88 modeCtx->enc = enc;
89 return ret;
90 }
91
MODES_ECB_Update(MODES_CipherCtx * modeCtx,const uint8_t * in,uint32_t inLen,uint8_t * out,uint32_t * outLen)92 int32_t MODES_ECB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
93 {
94 return MODES_CipherUpdate(modeCtx, modeCtx->enc ? MODES_ECB_Encrypt : MODES_ECB_Decrypt,
95 in, inLen, out, outLen);
96 }
97
MODES_ECB_Final(MODES_CipherCtx * modeCtx,uint8_t * out,uint32_t * outLen)98 int32_t MODES_ECB_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
99 {
100 return MODES_CipherFinal(modeCtx, modeCtx->enc ? MODES_ECB_Encrypt : MODES_ECB_Decrypt, out, outLen);
101 }
102
MODES_ECB_DeinitCtx(MODES_CipherCtx * modeCtx)103 int32_t MODES_ECB_DeinitCtx(MODES_CipherCtx *modeCtx)
104 {
105 return MODES_CipherDeInitCtx(modeCtx);
106 }
107
MODES_ECB_Ctrl(MODES_CipherCtx * modeCtx,int32_t cmd,void * val,uint32_t valLen)108 int32_t MODES_ECB_Ctrl(MODES_CipherCtx *modeCtx, int32_t cmd, void *val, uint32_t valLen)
109 {
110 int ret;
111 if (modeCtx == NULL) {
112 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
113 return CRYPT_NULL_INPUT;
114 }
115 switch (cmd) {
116 case CRYPT_CTRL_REINIT_STATUS:
117 (void)memset_s(modeCtx->data, EAL_MAX_BLOCK_LENGTH, 0, EAL_MAX_BLOCK_LENGTH);
118 modeCtx->dataLen = 0;
119 modeCtx->pad = CRYPT_PADDING_NONE;
120 return CRYPT_SUCCESS;
121 case CRYPT_CTRL_SET_PADDING:
122 if (val == NULL || valLen != sizeof(int32_t)) {
123 BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
124 return CRYPT_INVALID_ARG;
125 }
126 if (modeCtx->commonCtx.blockSize == 1) {
127 BSL_ERR_PUSH_ERROR(CRYPT_EAL_PADDING_NOT_SUPPORT);
128 return CRYPT_EAL_PADDING_NOT_SUPPORT;
129 }
130 ret = MODES_SetPaddingCheck(*(int32_t *)val);
131 if (ret != CRYPT_SUCCESS) {
132 return ret;
133 }
134 modeCtx->pad = *(int32_t *)val;
135 return CRYPT_SUCCESS;
136 case CRYPT_CTRL_GET_PADDING:
137 if (val == NULL || valLen != sizeof(int32_t)) {
138 BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
139 return CRYPT_INVALID_ARG;
140 }
141 *(int32_t *)val = modeCtx->pad;
142 return CRYPT_SUCCESS;
143 case CRYPT_CTRL_GET_BLOCKSIZE:
144 if (val == NULL || valLen != sizeof(uint32_t)) {
145 return CRYPT_INVALID_ARG;
146 }
147 *(int32_t *)val = modeCtx->commonCtx.ciphMeth->blockSize;
148 return CRYPT_SUCCESS;
149 default:
150 return MODES_CipherCtrl(modeCtx, cmd, val, valLen);
151 }
152 }
153
MODES_ECB_FreeCtx(MODES_CipherCtx * modeCtx)154 void MODES_ECB_FreeCtx(MODES_CipherCtx *modeCtx)
155 {
156 MODES_CipherFreeCtx(modeCtx);
157 }
158
MODES_ECB_InitCtxEx(MODES_CipherCtx * modeCtx,const uint8_t * key,uint32_t keyLen,const uint8_t * iv,uint32_t ivLen,void * param,bool enc)159 int32_t MODES_ECB_InitCtxEx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
160 uint32_t ivLen, void *param, bool enc)
161 {
162 (void)param;
163 if (modeCtx == NULL) {
164 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
165 return CRYPT_NULL_INPUT;
166 }
167 switch (modeCtx->algId) {
168 case CRYPT_CIPHER_SM4_ECB:
169 #ifdef HITLS_CRYPTO_SM4
170 return SM4_ECB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
171 #else
172 return CRYPT_EAL_ALG_NOT_SUPPORT;
173 #endif
174 default:
175 return MODES_ECB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
176 }
177 }
178
MODES_ECB_UpdateEx(MODES_CipherCtx * modeCtx,const uint8_t * in,uint32_t inLen,uint8_t * out,uint32_t * outLen)179 int32_t MODES_ECB_UpdateEx(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
180 {
181 if (modeCtx == NULL) {
182 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
183 return CRYPT_NULL_INPUT;
184 }
185 switch (modeCtx->algId) {
186 case CRYPT_CIPHER_AES128_ECB:
187 case CRYPT_CIPHER_AES192_ECB:
188 case CRYPT_CIPHER_AES256_ECB:
189 #ifdef HITLS_CRYPTO_AES
190 return AES_ECB_Update(modeCtx, in, inLen, out, outLen);
191 #else
192 return CRYPT_EAL_ALG_NOT_SUPPORT;
193 #endif
194 case CRYPT_CIPHER_SM4_ECB:
195 #ifdef HITLS_CRYPTO_SM4
196 return SM4_ECB_Update(modeCtx, in, inLen, out, outLen);
197 #else
198 return CRYPT_EAL_ALG_NOT_SUPPORT;
199 #endif
200 default:
201 return MODES_ECB_Update(modeCtx, in, inLen, out, outLen);
202 }
203 }
204
MODES_ECB_FinalEx(MODES_CipherCtx * modeCtx,uint8_t * out,uint32_t * outLen)205 int32_t MODES_ECB_FinalEx(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
206 {
207 if (modeCtx == NULL) {
208 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
209 return CRYPT_NULL_INPUT;
210 }
211 switch (modeCtx->algId) {
212 case CRYPT_CIPHER_AES128_ECB:
213 case CRYPT_CIPHER_AES192_ECB:
214 case CRYPT_CIPHER_AES256_ECB:
215 #ifdef HITLS_CRYPTO_AES
216 return AES_ECB_Final(modeCtx, out, outLen);
217 #else
218 return CRYPT_EAL_ALG_NOT_SUPPORT;
219 #endif
220 case CRYPT_CIPHER_SM4_ECB:
221 #ifdef HITLS_CRYPTO_SM4
222 return SM4_ECB_Final(modeCtx, out, outLen);
223 #else
224 return CRYPT_EAL_ALG_NOT_SUPPORT;
225 #endif
226 default:
227 return MODES_ECB_Final(modeCtx, out, outLen);
228 }
229 }
230
231 #endif // end HITLS_CRYPTO_ECB
232