1 /*
2 * Copyright (c) 2024 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 #ifdef HKS_SUPPORT_3DES_C
23
24 #include <openssl/des.h>
25 #include <openssl/evp.h>
26
27 #include "hks_cfi.h"
28 #include "hks_log.h"
29 #include "hks_mem.h"
30 #include "hks_openssl_3des.h"
31 #include "hks_openssl_des.h"
32 #include "hks_openssl_engine.h"
33 #include "hks_template.h"
34 #include "securec.h"
35
Check3DesKeySize(const struct HksBlob * key)36 static int32_t Check3DesKeySize(const struct HksBlob *key)
37 {
38 if (key->size != HKS_KEY_BYTES(HKS_3DES_KEY_SIZE_128) && key->size != HKS_KEY_BYTES(HKS_3DES_KEY_SIZE_192)) {
39 return HKS_ERROR_INVALID_KEY_SIZE;
40 }
41
42 return HKS_SUCCESS;
43 }
44
45 #ifdef HKS_SUPPORT_3DES_GENERATE_KEY
HksOpenssl3DesGenerateKey(const struct HksKeySpec * spec,struct HksBlob * key)46 int32_t HksOpenssl3DesGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key)
47 {
48 if (spec->keyLen != HKS_3DES_KEY_SIZE_128 && spec->keyLen != HKS_3DES_KEY_SIZE_192) {
49 return HKS_ERROR_INVALID_KEY_SIZE;
50 }
51
52 const uint32_t keyByteLen = spec->keyLen / HKS_BITS_PER_BYTE;
53 uint8_t *outKey = (uint8_t *)HksMalloc(keyByteLen);
54 HKS_IF_NULL_RETURN(outKey, HKS_ERROR_MALLOC_FAIL)
55
56 DES_cblock desKey;
57 for (uint32_t i = 0; i < spec->keyLen / HKS_DES_KEY_SIZE_64; i++) {
58 if (DES_random_key(&desKey) != HKS_OPENSSL_SUCCESS) {
59 HKS_LOG_E("DES_random_key 3des key failed");
60 HKS_FREE(outKey);
61 return HKS_ERROR_CRYPTO_ENGINE_ERROR;
62 }
63 if (memcpy_s(outKey + i * HKS_DES_BLOCK_SIZE, keyByteLen - i * HKS_DES_BLOCK_SIZE, desKey,
64 HKS_DES_BLOCK_SIZE) != EOK) {
65 HKS_LOG_E("memcpy 3des key failed!");
66 HKS_FREE(outKey);
67 return HKS_ERROR_BUFFER_TOO_SMALL;
68 }
69 }
70
71 key->data = outKey;
72 key->size = keyByteLen;
73
74 return HKS_SUCCESS;
75 }
76 #endif /* HKS_SUPPORT_3DES_GENERATE_KEY */
77
Des3CryptInit(void ** cryptoCtx,const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const bool encrypt)78 static int32_t Des3CryptInit(void **cryptoCtx, const struct HksBlob *key,
79 const struct HksUsageSpec *usageSpec, const bool encrypt)
80 {
81 switch (usageSpec->padding) {
82 #if defined(HKS_SUPPORT_3DES_CBC_NOPADDING) || defined(HKS_SUPPORT_3DES_ECB_NOPADDING)
83 case HKS_PADDING_NONE:
84 return DesNoPaddingCryptInit(cryptoCtx, key, usageSpec, encrypt);
85 #endif
86 default:
87 HKS_LOG_E("Unsupport padding! mode = 0x%" LOG_PUBLIC "X", usageSpec->padding);
88 return HKS_ERROR_INVALID_PADDING;
89 }
90 }
91
Des3CryptUpdate(void * cryptoCtx,const uint8_t padding,const struct HksBlob * message,struct HksBlob * cipherText,const bool encrypt)92 static int32_t Des3CryptUpdate(void *cryptoCtx, const uint8_t padding, const struct HksBlob *message,
93 struct HksBlob *cipherText, const bool encrypt)
94 {
95 switch (padding) {
96 #if defined(HKS_SUPPORT_3DES_CBC_NOPADDING) || defined(HKS_SUPPORT_3DES_ECB_NOPADDING)
97 case HKS_PADDING_NONE:
98 return DesNoPaddingCryptUpdate(cryptoCtx, message, encrypt, cipherText);
99 #endif
100 default:
101 HKS_LOG_E("Unsupport padding! mode = 0x%" LOG_PUBLIC "X", padding);
102 return HKS_ERROR_INVALID_PADDING;
103 }
104 }
105
Des3CryptFinal(void ** cryptoCtx,const uint8_t padding,const struct HksBlob * message,struct HksBlob * cipherText,const bool encrypt)106 static int32_t Des3CryptFinal(void **cryptoCtx, const uint8_t padding, const struct HksBlob *message,
107 struct HksBlob *cipherText, const bool encrypt)
108 {
109 switch (padding) {
110 #if defined(HKS_SUPPORT_3DES_CBC_NOPADDING) || defined(HKS_SUPPORT_3DES_ECB_NOPADDING)
111 case HKS_PADDING_NONE:
112 return DesNoPaddingCryptFinal(cryptoCtx, message, encrypt, cipherText);
113 #endif
114 default:
115 HKS_LOG_E("Unsupport padding! mode = 0x%" LOG_PUBLIC "X", padding);
116 return HKS_ERROR_INVALID_PADDING;
117 }
118 }
119
HksOpenssl3DesCryptoInit(void ** cryptoCtx,const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const bool encrypt)120 int32_t HksOpenssl3DesCryptoInit(void **cryptoCtx, const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
121 const bool encrypt)
122 {
123 if (Check3DesKeySize(key) != HKS_SUCCESS || cryptoCtx == NULL || usageSpec == NULL) {
124 HKS_LOG_E("Invalid 3des keySize = 0x%" LOG_PUBLIC "X", key->size);
125 return HKS_ERROR_INVALID_ARGUMENT;
126 }
127
128 switch (usageSpec->mode) {
129 #if defined(HKS_SUPPORT_3DES_CBC_NOPADDING)
130 case HKS_MODE_CBC:
131 return Des3CryptInit(cryptoCtx, key, usageSpec, encrypt);
132 #endif
133 #if defined(HKS_SUPPORT_3DES_ECB_NOPADDING)
134 case HKS_MODE_ECB:
135 return Des3CryptInit(cryptoCtx, key, usageSpec, encrypt);
136 #endif
137 default:
138 HKS_LOG_E("Unsupport key alg! mode = 0x%" LOG_PUBLIC "X", usageSpec->mode);
139 return HKS_ERROR_INVALID_MODE;
140 }
141 }
142
HksOpenssl3DesCryptoUpdate(void * cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText,const bool encrypt)143 int32_t HksOpenssl3DesCryptoUpdate(void *cryptoCtx, const struct HksBlob *message, struct HksBlob *cipherText,
144 const bool encrypt)
145 {
146 HKS_IF_NULL_LOGE_RETURN(cryptoCtx, HKS_ERROR_INVALID_ARGUMENT, "Openssl 3DES encrypt update param is null")
147 struct HksOpensslDesCtx *desEncryptCtx = (struct HksOpensslDesCtx *)cryptoCtx;
148
149 switch (desEncryptCtx->mode) {
150 #if defined(HKS_SUPPORT_3DES_CBC_NOPADDING)
151 case HKS_MODE_CBC:
152 return Des3CryptUpdate(cryptoCtx, desEncryptCtx->padding, message, cipherText, encrypt);
153 #endif
154 #if defined(HKS_SUPPORT_3DES_ECB_NOPADDING)
155 case HKS_MODE_ECB:
156 return Des3CryptUpdate(cryptoCtx, desEncryptCtx->padding, message, cipherText, encrypt);
157 #endif
158 default:
159 HKS_LOG_E("Unsupport key alg! mode = 0x%" LOG_PUBLIC "X", desEncryptCtx->mode);
160 return HKS_ERROR_INVALID_MODE;
161 }
162 }
163
HksOpenssl3DesCryptoFinal(void ** cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText,struct HksBlob * tagAead,const bool encrypt)164 int32_t HksOpenssl3DesCryptoFinal(void **cryptoCtx, const struct HksBlob *message, struct HksBlob *cipherText,
165 struct HksBlob *tagAead, const bool encrypt)
166 {
167 (void)tagAead;
168 struct HksOpensslDesCtx *desEncryptCtx = (struct HksOpensslDesCtx *)*cryptoCtx;
169 switch (desEncryptCtx->mode) {
170 #if defined(HKS_SUPPORT_3DES_CBC_NOPADDING)
171 case HKS_MODE_CBC:
172 return Des3CryptFinal(cryptoCtx, desEncryptCtx->padding, message, cipherText, encrypt);
173 #endif
174 #if defined(HKS_SUPPORT_3DES_ECB_NOPADDING)
175 case HKS_MODE_ECB:
176 return Des3CryptFinal(cryptoCtx, desEncryptCtx->padding, message, cipherText, encrypt);
177 #endif
178 default:
179 HKS_LOG_E("Unsupport key alg! mode = 0x%" LOG_PUBLIC "X", desEncryptCtx->mode);
180 return HKS_ERROR_INVALID_MODE;
181 }
182 }
183
HksOpenssl3DesHalFreeCtx(void ** cryptCtx)184 void HksOpenssl3DesHalFreeCtx(void **cryptCtx)
185 {
186 if (cryptCtx == NULL || *cryptCtx == NULL) {
187 HKS_LOG_E("FreeCtx param context null");
188 return;
189 }
190 HKS_FREE(*cryptCtx);
191 }
192 #endif /* HKS_SUPPORT_3DES_C */
193