Branch data Line data Source code
1 : : /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
2 : : * Copyright(c) 2015-2022 Intel Corporation
3 : : */
4 : :
5 : : #define OPENSSL_API_COMPAT 0x10100000L
6 : :
7 : : #ifdef RTE_QAT_OPENSSL
8 : : #include <openssl/sha.h> /* Needed to calculate pre-compute values */
9 : : #include <openssl/aes.h> /* Needed to calculate pre-compute values */
10 : : #include <openssl/md5.h> /* Needed to calculate pre-compute values */
11 : : #include <openssl/evp.h> /* Needed for bpi runt block processing */
12 : : #endif
13 : :
14 : : #ifndef RTE_QAT_OPENSSL
15 : : #ifndef RTE_ARCH_ARM
16 : : #include <intel-ipsec-mb.h>
17 : : #endif
18 : : #endif
19 : :
20 : : #include <rte_memcpy.h>
21 : : #include <rte_common.h>
22 : : #include <rte_spinlock.h>
23 : : #include <rte_byteorder.h>
24 : : #include <rte_log.h>
25 : : #include <rte_malloc.h>
26 : : #include <rte_crypto_sym.h>
27 : : #include <rte_security_driver.h>
28 : : #include <rte_ether.h>
29 : :
30 : : #include "qat_logs.h"
31 : : #include "qat_sym_session.h"
32 : : #include "qat_sym.h"
33 : :
34 : : #ifdef RTE_QAT_OPENSSL
35 : : #if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
36 : : #include <openssl/provider.h>
37 : :
38 : : static OSSL_PROVIDER * legacy_lib;
39 : : static OSSL_PROVIDER *default_lib;
40 : :
41 : : /* Some cryptographic algorithms such as MD and DES are now considered legacy
42 : : * and not enabled by default in OpenSSL 3.0. Load up lagacy provider as MD5
43 : : * DES are needed in QAT pre-computes and secure session creation.
44 : : */
45 : 0 : static int ossl_legacy_provider_load(void)
46 : : {
47 : : /* Load Multiple providers into the default (NULL) library context */
48 : 0 : legacy_lib = OSSL_PROVIDER_load(NULL, "legacy");
49 [ # # ]: 0 : if (legacy_lib == NULL)
50 : : return -EINVAL;
51 : :
52 : 0 : default_lib = OSSL_PROVIDER_load(NULL, "default");
53 [ # # ]: 0 : if (default_lib == NULL) {
54 : 0 : OSSL_PROVIDER_unload(legacy_lib);
55 : 0 : return -EINVAL;
56 : : }
57 : :
58 : : return 0;
59 : : }
60 : :
61 : 0 : static void ossl_legacy_provider_unload(void)
62 : : {
63 : 0 : OSSL_PROVIDER_unload(legacy_lib);
64 : 0 : OSSL_PROVIDER_unload(default_lib);
65 : 0 : }
66 : : #endif
67 : : #endif
68 : :
69 : : #define ETH_CRC32_POLYNOMIAL 0x04c11db7
70 : : #define ETH_CRC32_INIT_VAL 0xffffffff
71 : : #define ETH_CRC32_XOR_OUT 0xffffffff
72 : : #define ETH_CRC32_POLYNOMIAL_BE RTE_BE32(ETH_CRC32_POLYNOMIAL)
73 : : #define ETH_CRC32_INIT_VAL_BE RTE_BE32(ETH_CRC32_INIT_VAL)
74 : : #define ETH_CRC32_XOR_OUT_BE RTE_BE32(ETH_CRC32_XOR_OUT)
75 : :
76 : : /* SHA1 - 20 bytes - Initialiser state can be found in FIPS stds 180-2 */
77 : : static const uint8_t sha1InitialState[] = {
78 : : 0x67, 0x45, 0x23, 0x01, 0xef, 0xcd, 0xab, 0x89, 0x98, 0xba,
79 : : 0xdc, 0xfe, 0x10, 0x32, 0x54, 0x76, 0xc3, 0xd2, 0xe1, 0xf0};
80 : :
81 : : /* SHA 224 - 32 bytes - Initialiser state can be found in FIPS stds 180-2 */
82 : : static const uint8_t sha224InitialState[] = {
83 : : 0xc1, 0x05, 0x9e, 0xd8, 0x36, 0x7c, 0xd5, 0x07, 0x30, 0x70, 0xdd,
84 : : 0x17, 0xf7, 0x0e, 0x59, 0x39, 0xff, 0xc0, 0x0b, 0x31, 0x68, 0x58,
85 : : 0x15, 0x11, 0x64, 0xf9, 0x8f, 0xa7, 0xbe, 0xfa, 0x4f, 0xa4};
86 : :
87 : : /* SHA 256 - 32 bytes - Initialiser state can be found in FIPS stds 180-2 */
88 : : static const uint8_t sha256InitialState[] = {
89 : : 0x6a, 0x09, 0xe6, 0x67, 0xbb, 0x67, 0xae, 0x85, 0x3c, 0x6e, 0xf3,
90 : : 0x72, 0xa5, 0x4f, 0xf5, 0x3a, 0x51, 0x0e, 0x52, 0x7f, 0x9b, 0x05,
91 : : 0x68, 0x8c, 0x1f, 0x83, 0xd9, 0xab, 0x5b, 0xe0, 0xcd, 0x19};
92 : :
93 : : /* SHA 384 - 64 bytes - Initialiser state can be found in FIPS stds 180-2 */
94 : : static const uint8_t sha384InitialState[] = {
95 : : 0xcb, 0xbb, 0x9d, 0x5d, 0xc1, 0x05, 0x9e, 0xd8, 0x62, 0x9a, 0x29,
96 : : 0x2a, 0x36, 0x7c, 0xd5, 0x07, 0x91, 0x59, 0x01, 0x5a, 0x30, 0x70,
97 : : 0xdd, 0x17, 0x15, 0x2f, 0xec, 0xd8, 0xf7, 0x0e, 0x59, 0x39, 0x67,
98 : : 0x33, 0x26, 0x67, 0xff, 0xc0, 0x0b, 0x31, 0x8e, 0xb4, 0x4a, 0x87,
99 : : 0x68, 0x58, 0x15, 0x11, 0xdb, 0x0c, 0x2e, 0x0d, 0x64, 0xf9, 0x8f,
100 : : 0xa7, 0x47, 0xb5, 0x48, 0x1d, 0xbe, 0xfa, 0x4f, 0xa4};
101 : :
102 : : /* SHA 512 - 64 bytes - Initialiser state can be found in FIPS stds 180-2 */
103 : : static const uint8_t sha512InitialState[] = {
104 : : 0x6a, 0x09, 0xe6, 0x67, 0xf3, 0xbc, 0xc9, 0x08, 0xbb, 0x67, 0xae,
105 : : 0x85, 0x84, 0xca, 0xa7, 0x3b, 0x3c, 0x6e, 0xf3, 0x72, 0xfe, 0x94,
106 : : 0xf8, 0x2b, 0xa5, 0x4f, 0xf5, 0x3a, 0x5f, 0x1d, 0x36, 0xf1, 0x51,
107 : : 0x0e, 0x52, 0x7f, 0xad, 0xe6, 0x82, 0xd1, 0x9b, 0x05, 0x68, 0x8c,
108 : : 0x2b, 0x3e, 0x6c, 0x1f, 0x1f, 0x83, 0xd9, 0xab, 0xfb, 0x41, 0xbd,
109 : : 0x6b, 0x5b, 0xe0, 0xcd, 0x19, 0x13, 0x7e, 0x21, 0x79};
110 : :
111 : : static uint8_t sm3InitialState[] = {
112 : : 0x73, 0x80, 0x16, 0x6f, 0x49, 0x14, 0xb2, 0xb9,
113 : : 0x17, 0x24, 0x42, 0xd7, 0xda, 0x8a, 0x06, 0x00,
114 : : 0xa9, 0x6f, 0x30, 0xbc, 0x16, 0x31, 0x38, 0xaa,
115 : : 0xe3, 0x8d, 0xee, 0x4d, 0xb0, 0xfb, 0x0e, 0x4e
116 : : };
117 : :
118 : : static int
119 : : qat_sym_cd_cipher_set(struct qat_sym_session *cd,
120 : : const uint8_t *enckey,
121 : : uint32_t enckeylen);
122 : :
123 : : static int
124 : : qat_sym_cd_crc_set(struct qat_sym_session *cdesc,
125 : : enum qat_device_gen qat_dev_gen);
126 : :
127 : : static int
128 : : qat_sym_cd_auth_set(struct qat_sym_session *cdesc,
129 : : const uint8_t *authkey,
130 : : uint32_t authkeylen,
131 : : uint32_t aad_length,
132 : : uint32_t digestsize,
133 : : unsigned int operation,
134 : : enum qat_device_gen qat_dev_gen);
135 : :
136 : : static void
137 : : qat_sym_session_init_common_hdr(struct qat_sym_session *session);
138 : :
139 : : static void
140 : : qat_sym_session_init_gen_lce_hdr(struct qat_sym_session *session);
141 : :
142 : : /* Req/cd init functions */
143 : :
144 : : static void
145 : : qat_sym_session_finalize(struct qat_sym_session *session)
146 : : {
147 : 0 : qat_sym_session_init_common_hdr(session);
148 : : }
149 : :
150 : : #ifdef RTE_QAT_OPENSSL
151 : : /** Frees a context previously created
152 : : * Depends on openssl libcrypto
153 : : */
154 : : static void
155 : : bpi_cipher_ctx_free(void *bpi_ctx)
156 : : {
157 : : if (bpi_ctx != NULL)
158 : 0 : EVP_CIPHER_CTX_free((EVP_CIPHER_CTX *)bpi_ctx);
159 : 0 : }
160 : :
161 : : /** Creates a context in either AES or DES in ECB mode
162 : : * Depends on openssl libcrypto
163 : : */
164 : : static int
165 : 0 : bpi_cipher_ctx_init(enum rte_crypto_cipher_algorithm cryptodev_algo,
166 : : enum rte_crypto_cipher_operation direction __rte_unused,
167 : : const uint8_t *key, uint16_t key_length, void **ctx)
168 : : {
169 : : const EVP_CIPHER *algo = NULL;
170 : : int ret;
171 : 0 : *ctx = EVP_CIPHER_CTX_new();
172 : :
173 [ # # ]: 0 : if (*ctx == NULL) {
174 : : ret = -ENOMEM;
175 : 0 : goto ctx_init_err;
176 : : }
177 : :
178 [ # # ]: 0 : if (cryptodev_algo == RTE_CRYPTO_CIPHER_DES_DOCSISBPI)
179 : 0 : algo = EVP_des_ecb();
180 : : else
181 [ # # ]: 0 : if (key_length == ICP_QAT_HW_AES_128_KEY_SZ)
182 : 0 : algo = EVP_aes_128_ecb();
183 : : else
184 : 0 : algo = EVP_aes_256_ecb();
185 : :
186 : : /* IV will be ECB encrypted whether direction is encrypt or decrypt*/
187 [ # # ]: 0 : if (EVP_EncryptInit_ex(*ctx, algo, NULL, key, 0) != 1) {
188 : : ret = -EINVAL;
189 : 0 : goto ctx_init_err;
190 : : }
191 : :
192 : : return 0;
193 : :
194 : 0 : ctx_init_err:
195 [ # # ]: 0 : if (*ctx != NULL) {
196 : 0 : EVP_CIPHER_CTX_free(*ctx);
197 : 0 : *ctx = NULL;
198 : : }
199 : : return ret;
200 : : }
201 : : #endif
202 : :
203 : : #ifndef RTE_QAT_OPENSSL
204 : : /** Creates a context in either AES or DES in ECB mode
205 : : */
206 : : static int
207 : : ipsec_mb_ctx_init(const uint8_t *key, uint16_t key_length,
208 : : enum rte_crypto_cipher_algorithm cryptodev_algo,
209 : : uint64_t *expkey, uint32_t *dust, IMB_MGR **m)
210 : : {
211 : : int ret;
212 : :
213 : : *m = alloc_mb_mgr(0);
214 : : if (*m == NULL)
215 : : return -ENOMEM;
216 : :
217 : : init_mb_mgr_auto(*m, NULL);
218 : :
219 : : if (cryptodev_algo == RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
220 : : if (key_length == ICP_QAT_HW_AES_128_KEY_SZ)
221 : : IMB_AES_KEYEXP_128(*m, key, expkey, dust);
222 : : else if (key_length == ICP_QAT_HW_AES_256_KEY_SZ)
223 : : IMB_AES_KEYEXP_256(*m, key, expkey, dust);
224 : : else {
225 : : ret = -EFAULT;
226 : : goto error_out;
227 : : }
228 : : } else if (cryptodev_algo == RTE_CRYPTO_CIPHER_DES_DOCSISBPI) {
229 : : if (key_length == ICP_QAT_HW_DES_KEY_SZ)
230 : : IMB_DES_KEYSCHED(*m, (uint64_t *)expkey, key);
231 : : else {
232 : : ret = -EFAULT;
233 : : goto error_out;
234 : : }
235 : : }
236 : : return 0;
237 : :
238 : : error_out:
239 : : if (*m) {
240 : : free_mb_mgr(*m);
241 : : *m = NULL;
242 : : }
243 : : return ret;
244 : : }
245 : : #endif
246 : :
247 : : static int
248 : : qat_is_cipher_alg_supported(enum rte_crypto_cipher_algorithm algo,
249 : : struct qat_cryptodev_private *internals)
250 : : {
251 : : int i = 0;
252 : : const struct rte_cryptodev_capabilities *capability;
253 : :
254 [ # # ]: 0 : while ((capability = &(internals->qat_dev_capabilities[i++]))->op !=
255 : : RTE_CRYPTO_OP_TYPE_UNDEFINED) {
256 [ # # ]: 0 : if (capability->op != RTE_CRYPTO_OP_TYPE_SYMMETRIC)
257 : 0 : continue;
258 : :
259 [ # # ]: 0 : if (capability->sym.xform_type != RTE_CRYPTO_SYM_XFORM_CIPHER)
260 : 0 : continue;
261 : :
262 [ # # ]: 0 : if (capability->sym.cipher.algo == algo)
263 : : return 1;
264 : : }
265 : : return 0;
266 : : }
267 : :
268 : : static int
269 : : qat_is_auth_alg_supported(enum rte_crypto_auth_algorithm algo,
270 : : struct qat_cryptodev_private *internals)
271 : : {
272 : : int i = 0;
273 : : const struct rte_cryptodev_capabilities *capability;
274 : :
275 [ # # ]: 0 : while ((capability = &(internals->qat_dev_capabilities[i++]))->op !=
276 : : RTE_CRYPTO_OP_TYPE_UNDEFINED) {
277 [ # # ]: 0 : if (capability->op != RTE_CRYPTO_OP_TYPE_SYMMETRIC)
278 : 0 : continue;
279 : :
280 [ # # ]: 0 : if (capability->sym.xform_type != RTE_CRYPTO_SYM_XFORM_AUTH)
281 : 0 : continue;
282 : :
283 [ # # ]: 0 : if (capability->sym.auth.algo == algo)
284 : : return 1;
285 : : }
286 : : return 0;
287 : : }
288 : :
289 : : void
290 : 0 : qat_sym_session_clear(struct rte_cryptodev *dev __rte_unused,
291 : : struct rte_cryptodev_sym_session *sess)
292 : : {
293 : : struct qat_sym_session *s = CRYPTODEV_GET_SYM_SESS_PRIV(sess);
294 : :
295 : : #ifdef RTE_QAT_OPENSSL
296 [ # # ]: 0 : if (s->bpi_ctx)
297 : : bpi_cipher_ctx_free(s->bpi_ctx);
298 : : #else
299 : : if (s->mb_mgr)
300 : : free_mb_mgr(s->mb_mgr);
301 : : #endif
302 : 0 : }
303 : :
304 : : static int
305 : 0 : qat_get_cmd_id(const struct rte_crypto_sym_xform *xform)
306 : : {
307 : : /* Cipher Only */
308 [ # # # # ]: 0 : if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER && xform->next == NULL)
309 : : return ICP_QAT_FW_LA_CMD_CIPHER;
310 : :
311 : : /* Authentication Only */
312 [ # # # # ]: 0 : if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH && xform->next == NULL)
313 : : return ICP_QAT_FW_LA_CMD_AUTH;
314 : :
315 : : /* AEAD */
316 [ # # ]: 0 : if (xform->type == RTE_CRYPTO_SYM_XFORM_AEAD) {
317 : : /* AES-GCM and AES-CCM works with different direction
318 : : * GCM first encrypts and generate hash where AES-CCM
319 : : * first generate hash and encrypts. Similar relation
320 : : * applies to decryption.
321 : : */
322 [ # # ]: 0 : if (xform->aead.op == RTE_CRYPTO_AEAD_OP_ENCRYPT)
323 [ # # ]: 0 : if (xform->aead.algo == RTE_CRYPTO_AEAD_AES_GCM)
324 : : return ICP_QAT_FW_LA_CMD_CIPHER_HASH;
325 : : else
326 : 0 : return ICP_QAT_FW_LA_CMD_HASH_CIPHER;
327 : : else
328 [ # # ]: 0 : if (xform->aead.algo == RTE_CRYPTO_AEAD_AES_GCM)
329 : : return ICP_QAT_FW_LA_CMD_HASH_CIPHER;
330 : : else
331 : 0 : return ICP_QAT_FW_LA_CMD_CIPHER_HASH;
332 : : }
333 : :
334 [ # # ]: 0 : if (xform->next == NULL)
335 : : return -1;
336 : :
337 : : /* Cipher then Authenticate */
338 [ # # ]: 0 : if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER &&
339 [ # # ]: 0 : xform->next->type == RTE_CRYPTO_SYM_XFORM_AUTH)
340 : : return ICP_QAT_FW_LA_CMD_CIPHER_HASH;
341 : :
342 : : /* Authenticate then Cipher */
343 [ # # ]: 0 : if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH &&
344 [ # # ]: 0 : xform->next->type == RTE_CRYPTO_SYM_XFORM_CIPHER)
345 : 0 : return ICP_QAT_FW_LA_CMD_HASH_CIPHER;
346 : :
347 : : return -1;
348 : : }
349 : :
350 : : static struct rte_crypto_auth_xform *
351 : : qat_get_auth_xform(struct rte_crypto_sym_xform *xform)
352 : : {
353 : : do {
354 [ # # ]: 0 : if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH)
355 : 0 : return &xform->auth;
356 : :
357 : 0 : xform = xform->next;
358 [ # # ]: 0 : } while (xform);
359 : :
360 : : return NULL;
361 : : }
362 : :
363 : : static struct rte_crypto_cipher_xform *
364 : : qat_get_cipher_xform(struct rte_crypto_sym_xform *xform)
365 : : {
366 : : do {
367 [ # # ]: 0 : if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER)
368 : 0 : return &xform->cipher;
369 : :
370 : 0 : xform = xform->next;
371 [ # # ]: 0 : } while (xform);
372 : :
373 : : return NULL;
374 : : }
375 : :
376 : : int
377 : 0 : qat_sym_session_configure_cipher(struct rte_cryptodev *dev,
378 : : struct rte_crypto_sym_xform *xform,
379 : : struct qat_sym_session *session)
380 : : {
381 : 0 : struct qat_cryptodev_private *internals = dev->data->dev_private;
382 : : struct rte_crypto_cipher_xform *cipher_xform = NULL;
383 : 0 : enum qat_device_gen qat_dev_gen =
384 : 0 : internals->qat_dev->qat_dev_gen;
385 : : int ret, is_wireless = 0;
386 : : struct icp_qat_fw_la_bulk_req *req_tmpl = &session->fw_req;
387 : : struct icp_qat_fw_comn_req_hdr *header = &req_tmpl->comn_hdr;
388 : :
389 : : /* Get cipher xform from crypto xform chain */
390 : : cipher_xform = qat_get_cipher_xform(xform);
391 : :
392 : 0 : session->cipher_iv.offset = cipher_xform->iv.offset;
393 : 0 : session->cipher_iv.length = cipher_xform->iv.length;
394 : :
395 [ # # # # : 0 : switch (cipher_xform->algo) {
# # # # #
# # # # #
# # # ]
396 : 0 : case RTE_CRYPTO_CIPHER_AES_CBC:
397 [ # # ]: 0 : if (qat_sym_validate_aes_key(cipher_xform->key.length,
398 : : &session->qat_cipher_alg) != 0) {
399 : 0 : QAT_LOG(ERR, "Invalid AES cipher key size");
400 : : ret = -EINVAL;
401 : 0 : goto error_out;
402 : : }
403 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CBC_MODE;
404 : 0 : break;
405 : 0 : case RTE_CRYPTO_CIPHER_AES_CTR:
406 [ # # ]: 0 : if (qat_sym_validate_aes_key(cipher_xform->key.length,
407 : : &session->qat_cipher_alg) != 0) {
408 : 0 : QAT_LOG(ERR, "Invalid AES cipher key size");
409 : : ret = -EINVAL;
410 : 0 : goto error_out;
411 : : }
412 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CTR_MODE;
413 : 0 : if (qat_dev_gen == QAT_GEN4 || qat_dev_gen == QAT_GEN5 ||
414 [ # # ]: 0 : qat_dev_gen == QAT_VQAT)
415 : 0 : session->is_ucs = 1;
416 : : break;
417 : 0 : case RTE_CRYPTO_CIPHER_SNOW3G_UEA2:
418 [ # # ]: 0 : if (qat_sym_validate_snow3g_key(cipher_xform->key.length,
419 : : &session->qat_cipher_alg) != 0) {
420 : 0 : QAT_LOG(ERR, "Invalid SNOW 3G cipher key size");
421 : : ret = -EINVAL;
422 : 0 : goto error_out;
423 : : }
424 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_ECB_MODE;
425 [ # # ]: 0 : if (internals->qat_dev->options.has_wireless_slice)
426 : : is_wireless = 1;
427 : : break;
428 : 0 : case RTE_CRYPTO_CIPHER_NULL:
429 : 0 : session->qat_cipher_alg = ICP_QAT_HW_CIPHER_ALGO_NULL;
430 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CTR_MODE;
431 : 0 : break;
432 : 0 : case RTE_CRYPTO_CIPHER_KASUMI_F8:
433 [ # # ]: 0 : if (qat_sym_validate_kasumi_key(cipher_xform->key.length,
434 : : &session->qat_cipher_alg) != 0) {
435 : 0 : QAT_LOG(ERR, "Invalid KASUMI cipher key size");
436 : : ret = -EINVAL;
437 : 0 : goto error_out;
438 : : }
439 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_F8_MODE;
440 : 0 : break;
441 : 0 : case RTE_CRYPTO_CIPHER_3DES_CBC:
442 [ # # ]: 0 : if (qat_sym_validate_3des_key(cipher_xform->key.length,
443 : : &session->qat_cipher_alg) != 0) {
444 : 0 : QAT_LOG(ERR, "Invalid 3DES cipher key size");
445 : : ret = -EINVAL;
446 : 0 : goto error_out;
447 : : }
448 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CBC_MODE;
449 : 0 : break;
450 : 0 : case RTE_CRYPTO_CIPHER_DES_CBC:
451 [ # # ]: 0 : if (qat_sym_validate_des_key(cipher_xform->key.length,
452 : : &session->qat_cipher_alg) != 0) {
453 : 0 : QAT_LOG(ERR, "Invalid DES cipher key size");
454 : : ret = -EINVAL;
455 : 0 : goto error_out;
456 : : }
457 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CBC_MODE;
458 : 0 : break;
459 : 0 : case RTE_CRYPTO_CIPHER_3DES_CTR:
460 [ # # ]: 0 : if (qat_sym_validate_3des_key(cipher_xform->key.length,
461 : : &session->qat_cipher_alg) != 0) {
462 : 0 : QAT_LOG(ERR, "Invalid 3DES cipher key size");
463 : : ret = -EINVAL;
464 : 0 : goto error_out;
465 : : }
466 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CTR_MODE;
467 : 0 : break;
468 : 0 : case RTE_CRYPTO_CIPHER_DES_DOCSISBPI:
469 : : #ifdef RTE_QAT_OPENSSL
470 : 0 : ret = bpi_cipher_ctx_init(
471 : : cipher_xform->algo,
472 : : cipher_xform->op,
473 : : cipher_xform->key.data,
474 : 0 : cipher_xform->key.length,
475 : : &session->bpi_ctx);
476 : : #else
477 : : session->docsis_key_len = cipher_xform->key.length;
478 : : ret = ipsec_mb_ctx_init(
479 : : cipher_xform->key.data,
480 : : cipher_xform->key.length,
481 : : cipher_xform->algo,
482 : : session->expkey,
483 : : session->dust,
484 : : &session->mb_mgr);
485 : : #endif
486 [ # # ]: 0 : if (ret != 0) {
487 : 0 : QAT_LOG(ERR, "failed to create DES BPI ctx");
488 : 0 : goto error_out;
489 : : }
490 [ # # ]: 0 : if (qat_sym_validate_des_key(cipher_xform->key.length,
491 : : &session->qat_cipher_alg) != 0) {
492 : 0 : QAT_LOG(ERR, "Invalid DES cipher key size");
493 : : ret = -EINVAL;
494 : 0 : goto error_out;
495 : : }
496 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CBC_MODE;
497 : 0 : break;
498 : 0 : case RTE_CRYPTO_CIPHER_AES_DOCSISBPI:
499 : : #ifdef RTE_QAT_OPENSSL
500 : 0 : ret = bpi_cipher_ctx_init(
501 : : cipher_xform->algo,
502 : : cipher_xform->op,
503 : : cipher_xform->key.data,
504 : 0 : cipher_xform->key.length,
505 : : &session->bpi_ctx);
506 : : #else
507 : : session->docsis_key_len = cipher_xform->key.length;
508 : : ret = ipsec_mb_ctx_init(
509 : : cipher_xform->key.data,
510 : : cipher_xform->key.length,
511 : : cipher_xform->algo,
512 : : session->expkey,
513 : : session->dust,
514 : : &session->mb_mgr);
515 : : #endif
516 [ # # ]: 0 : if (ret != 0) {
517 : 0 : QAT_LOG(ERR, "failed to create AES BPI ctx");
518 : 0 : goto error_out;
519 : : }
520 [ # # ]: 0 : if (qat_sym_validate_aes_docsisbpi_key(cipher_xform->key.length,
521 : : &session->qat_cipher_alg) != 0) {
522 : 0 : QAT_LOG(ERR, "Invalid AES DOCSISBPI key size");
523 : : ret = -EINVAL;
524 : 0 : goto error_out;
525 : : }
526 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CBC_MODE;
527 : 0 : break;
528 : : case RTE_CRYPTO_CIPHER_ZUC_EEA3:
529 [ # # ]: 0 : if (!qat_is_cipher_alg_supported(
530 : : cipher_xform->algo, internals)) {
531 : 0 : QAT_LOG(ERR, "%s not supported on this device",
532 : : rte_cryptodev_get_cipher_algo_string(
533 : : cipher_xform->algo));
534 : : ret = -ENOTSUP;
535 : 0 : goto error_out;
536 : : }
537 [ # # ]: 0 : if (qat_sym_validate_zuc_key(cipher_xform->key.length,
538 : : &session->qat_cipher_alg) != 0) {
539 : 0 : QAT_LOG(ERR, "Invalid ZUC cipher key size");
540 : : ret = -EINVAL;
541 : 0 : goto error_out;
542 : : }
543 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_ECB_MODE;
544 [ # # ]: 0 : if (internals->qat_dev->options.has_wireless_slice)
545 : : is_wireless = 1;
546 : : break;
547 : 0 : case RTE_CRYPTO_CIPHER_AES_XTS:
548 [ # # ]: 0 : if ((cipher_xform->key.length/2) == ICP_QAT_HW_AES_192_KEY_SZ) {
549 : 0 : QAT_LOG(ERR, "AES-XTS-192 not supported");
550 : : ret = -EINVAL;
551 : 0 : goto error_out;
552 : : }
553 [ # # ]: 0 : if (qat_sym_validate_aes_key((cipher_xform->key.length/2),
554 : : &session->qat_cipher_alg) != 0) {
555 : 0 : QAT_LOG(ERR, "Invalid AES-XTS cipher key size");
556 : : ret = -EINVAL;
557 : 0 : goto error_out;
558 : : }
559 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_XTS_MODE;
560 : 0 : break;
561 : 0 : case RTE_CRYPTO_CIPHER_SM4_ECB:
562 : 0 : session->qat_cipher_alg = ICP_QAT_HW_CIPHER_ALGO_SM4;
563 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_ECB_MODE;
564 : 0 : break;
565 : 0 : case RTE_CRYPTO_CIPHER_SM4_CBC:
566 : 0 : session->qat_cipher_alg = ICP_QAT_HW_CIPHER_ALGO_SM4;
567 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CBC_MODE;
568 : 0 : break;
569 : 0 : case RTE_CRYPTO_CIPHER_SM4_CTR:
570 : 0 : session->qat_cipher_alg = ICP_QAT_HW_CIPHER_ALGO_SM4;
571 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CTR_MODE;
572 : 0 : break;
573 : 0 : case RTE_CRYPTO_CIPHER_3DES_ECB:
574 : : case RTE_CRYPTO_CIPHER_AES_ECB:
575 : : case RTE_CRYPTO_CIPHER_AES_F8:
576 : : case RTE_CRYPTO_CIPHER_ARC4:
577 : 0 : QAT_LOG(ERR, "Crypto QAT PMD: Unsupported Cipher alg %u",
578 : : cipher_xform->algo);
579 : : ret = -ENOTSUP;
580 : 0 : goto error_out;
581 : 0 : default:
582 : 0 : QAT_LOG(ERR, "Crypto: Undefined Cipher specified %u",
583 : : cipher_xform->algo);
584 : : ret = -EINVAL;
585 : 0 : goto error_out;
586 : : }
587 : :
588 [ # # ]: 0 : if (cipher_xform->op == RTE_CRYPTO_CIPHER_OP_ENCRYPT)
589 : 0 : session->qat_dir = ICP_QAT_HW_CIPHER_ENCRYPT;
590 : : else
591 : 0 : session->qat_dir = ICP_QAT_HW_CIPHER_DECRYPT;
592 : :
593 [ # # ]: 0 : if (qat_sym_cd_cipher_set(session,
594 : : cipher_xform->key.data,
595 : 0 : cipher_xform->key.length)) {
596 : : ret = -EINVAL;
597 : 0 : goto error_out;
598 : : }
599 : :
600 [ # # ]: 0 : if (is_wireless) {
601 : : /* Set the Use Extended Protocol Flags bit in LW 1 */
602 : 0 : ICP_QAT_FW_USE_EXTENDED_PROTOCOL_FLAGS_SET(
603 : : header->ext_flags,
604 : : QAT_LA_USE_EXTENDED_PROTOCOL_FLAGS);
605 : : /* Force usage of Wireless Cipher slice */
606 : 0 : ICP_QAT_FW_USE_WCP_SLICE_SET(header->ext_flags,
607 : : QAT_LA_USE_WCP_SLICE);
608 : 0 : session->is_wireless = 1;
609 : : }
610 : :
611 : : return 0;
612 : :
613 : 0 : error_out:
614 : : #ifdef RTE_QAT_OPENSSL
615 [ # # ]: 0 : if (session->bpi_ctx) {
616 : : bpi_cipher_ctx_free(session->bpi_ctx);
617 : 0 : session->bpi_ctx = NULL;
618 : : }
619 : : #else
620 : : if (session->mb_mgr) {
621 : : free_mb_mgr(session->mb_mgr);
622 : : session->mb_mgr = NULL;
623 : : }
624 : :
625 : : #endif
626 : : return ret;
627 : : }
628 : :
629 : : int
630 : 0 : qat_sym_session_configure(struct rte_cryptodev *dev,
631 : : struct rte_crypto_sym_xform *xform,
632 : : struct rte_cryptodev_sym_session *sess)
633 : : {
634 : : int ret;
635 : :
636 : : #ifdef RTE_QAT_OPENSSL
637 : : #if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
638 : 0 : ossl_legacy_provider_load();
639 : : #endif
640 : : #endif
641 : 0 : ret = qat_sym_session_set_parameters(dev, xform,
642 : 0 : CRYPTODEV_GET_SYM_SESS_PRIV(sess),
643 : : CRYPTODEV_GET_SYM_SESS_PRIV_IOVA(sess));
644 [ # # ]: 0 : if (ret != 0) {
645 : 0 : QAT_LOG(ERR,
646 : : "Crypto QAT PMD: failed to configure session parameters");
647 : :
648 : 0 : return ret;
649 : : }
650 : :
651 : : #ifdef RTE_QAT_OPENSSL
652 : : # if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
653 : 0 : ossl_legacy_provider_unload();
654 : : # endif
655 : : # endif
656 : 0 : return 0;
657 : : }
658 : :
659 : : int
660 : 0 : qat_sym_session_set_parameters(struct rte_cryptodev *dev,
661 : : struct rte_crypto_sym_xform *xform, void *session_private,
662 : : rte_iova_t session_paddr)
663 : : {
664 : : struct qat_sym_session *session = session_private;
665 : 0 : struct qat_cryptodev_private *internals = dev->data->dev_private;
666 : 0 : enum qat_device_gen qat_dev_gen = internals->qat_dev->qat_dev_gen;
667 : : int ret;
668 : : int qat_cmd_id;
669 : :
670 : : /* Verify the session physical address is known */
671 [ # # ]: 0 : if (session_paddr == 0 || session_paddr == RTE_BAD_IOVA) {
672 : 0 : QAT_LOG(ERR,
673 : : "Session physical address unknown. Bad memory pool.");
674 : 0 : return -EINVAL;
675 : : }
676 : :
677 : : memset(session, 0, sizeof(*session));
678 : : /* Set context descriptor physical address */
679 : 0 : session->cd_paddr = session_paddr +
680 : : offsetof(struct qat_sym_session, cd);
681 : 0 : session->prefix_paddr = session_paddr +
682 : : offsetof(struct qat_sym_session, prefix_state);
683 : :
684 : 0 : session->dev_id = internals->dev_id;
685 : : session->qat_proto_flag = QAT_CRYPTO_PROTO_FLAG_NONE;
686 : : session->is_ucs = 0;
687 : :
688 : : /* Get requested QAT command id */
689 : 0 : qat_cmd_id = qat_get_cmd_id(xform);
690 [ # # ]: 0 : if (qat_cmd_id < 0 || qat_cmd_id >= ICP_QAT_FW_LA_CMD_DELIMITER) {
691 : 0 : QAT_LOG(ERR, "Unsupported xform chain requested");
692 : 0 : return -ENOTSUP;
693 : : }
694 : 0 : session->qat_cmd = (enum icp_qat_fw_la_cmd_id)qat_cmd_id;
695 [ # # # # : 0 : switch (session->qat_cmd) {
# # ]
696 : 0 : case ICP_QAT_FW_LA_CMD_CIPHER:
697 : 0 : ret = qat_sym_session_configure_cipher(dev, xform, session);
698 [ # # ]: 0 : if (ret < 0)
699 : : return ret;
700 : : break;
701 : 0 : case ICP_QAT_FW_LA_CMD_AUTH:
702 : 0 : ret = qat_sym_session_configure_auth(dev, xform, session);
703 [ # # ]: 0 : if (ret < 0)
704 : : return ret;
705 : 0 : session->is_single_pass_gmac =
706 : 0 : qat_dev_gen == QAT_GEN3 &&
707 [ # # # # ]: 0 : xform->auth.algo == RTE_CRYPTO_AUTH_AES_GMAC &&
708 [ # # ]: 0 : xform->auth.iv.length == QAT_AES_GCM_SPC_IV_SIZE;
709 : 0 : break;
710 : 0 : case ICP_QAT_FW_LA_CMD_CIPHER_HASH:
711 [ # # ]: 0 : if (xform->type == RTE_CRYPTO_SYM_XFORM_AEAD) {
712 : 0 : ret = qat_sym_session_configure_aead(dev, xform,
713 : : session);
714 [ # # ]: 0 : if (ret < 0)
715 : : return ret;
716 : : } else {
717 : 0 : ret = qat_sym_session_configure_cipher(dev,
718 : : xform, session);
719 [ # # ]: 0 : if (ret < 0)
720 : : return ret;
721 : 0 : ret = qat_sym_session_configure_auth(dev,
722 : : xform, session);
723 [ # # ]: 0 : if (ret < 0)
724 : : return ret;
725 : : }
726 : : break;
727 : 0 : case ICP_QAT_FW_LA_CMD_HASH_CIPHER:
728 [ # # ]: 0 : if (xform->type == RTE_CRYPTO_SYM_XFORM_AEAD) {
729 : 0 : ret = qat_sym_session_configure_aead(dev, xform,
730 : : session);
731 [ # # ]: 0 : if (ret < 0)
732 : : return ret;
733 : : } else {
734 : 0 : ret = qat_sym_session_configure_auth(dev,
735 : : xform, session);
736 [ # # ]: 0 : if (ret < 0)
737 : : return ret;
738 : 0 : ret = qat_sym_session_configure_cipher(dev,
739 : : xform, session);
740 [ # # ]: 0 : if (ret < 0)
741 : : return ret;
742 : : }
743 : : break;
744 : 0 : case ICP_QAT_FW_LA_CMD_TRNG_GET_RANDOM:
745 : : case ICP_QAT_FW_LA_CMD_TRNG_TEST:
746 : : case ICP_QAT_FW_LA_CMD_SSL3_KEY_DERIVE:
747 : : case ICP_QAT_FW_LA_CMD_TLS_V1_1_KEY_DERIVE:
748 : : case ICP_QAT_FW_LA_CMD_TLS_V1_2_KEY_DERIVE:
749 : : case ICP_QAT_FW_LA_CMD_MGF1:
750 : : case ICP_QAT_FW_LA_CMD_AUTH_PRE_COMP:
751 : : case ICP_QAT_FW_LA_CMD_CIPHER_PRE_COMP:
752 : : case ICP_QAT_FW_LA_CMD_CIPHER_CRC:
753 : : case ICP_QAT_FW_LA_CMD_DELIMITER:
754 : 0 : QAT_LOG(ERR, "Unsupported Service %u",
755 : : session->qat_cmd);
756 : 0 : return -ENOTSUP;
757 : 0 : default:
758 : 0 : QAT_LOG(ERR, "Unsupported Service %u",
759 : : session->qat_cmd);
760 : 0 : return -ENOTSUP;
761 : : }
762 : :
763 [ # # ]: 0 : if (qat_dev_gen == QAT_GEN_LCE) {
764 : : qat_sym_session_init_gen_lce_hdr(session);
765 : 0 : return 0;
766 : : }
767 : :
768 : : qat_sym_session_finalize(session);
769 : :
770 : 0 : return qat_sym_gen_dev_ops[qat_dev_gen].set_session((void *)dev,
771 : : (void *)session);
772 : : }
773 : :
774 : : int
775 : 0 : qat_cipher_crc_cap_msg_sess_prepare(struct qat_sym_session *session,
776 : : rte_iova_t session_paddr,
777 : : const uint8_t *cipherkey,
778 : : uint32_t cipherkeylen,
779 : : enum qat_device_gen qat_dev_gen)
780 : : {
781 : : int ret;
782 : :
783 : : /* Set content descriptor physical address */
784 : 0 : session->cd_paddr = session_paddr +
785 : : offsetof(struct qat_sym_session, cd);
786 : :
787 : : /* Set up some pre-requisite variables */
788 : 0 : session->qat_proto_flag = QAT_CRYPTO_PROTO_FLAG_NONE;
789 : 0 : session->is_ucs = 0;
790 : 0 : session->qat_cmd = ICP_QAT_FW_LA_CMD_CIPHER_CRC;
791 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CBC_MODE;
792 : 0 : session->qat_cipher_alg = ICP_QAT_HW_CIPHER_ALGO_AES128;
793 : 0 : session->qat_dir = ICP_QAT_HW_CIPHER_ENCRYPT;
794 : 0 : session->is_auth = 1;
795 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_NULL;
796 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
797 : 0 : session->auth_op = ICP_QAT_HW_AUTH_GENERATE;
798 : 0 : session->digest_length = RTE_ETHER_CRC_LEN;
799 : :
800 : 0 : ret = qat_sym_cd_cipher_set(session, cipherkey, cipherkeylen);
801 [ # # ]: 0 : if (ret < 0)
802 : : return -EINVAL;
803 : :
804 : 0 : ret = qat_sym_cd_crc_set(session, qat_dev_gen);
805 [ # # ]: 0 : if (ret < 0)
806 : : return -EINVAL;
807 : :
808 : : qat_sym_session_finalize(session);
809 : :
810 : 0 : return 0;
811 : : }
812 : :
813 : : static int
814 : : qat_sym_session_handle_single_pass(struct qat_sym_session *session,
815 : : const struct rte_crypto_aead_xform *aead_xform)
816 : : {
817 : 0 : session->is_single_pass = 1;
818 : 0 : session->is_auth = 1;
819 : 0 : session->qat_cmd = ICP_QAT_FW_LA_CMD_CIPHER;
820 : : /* Chacha-Poly is special case that use QAT CTR mode */
821 [ # # ]: 0 : if (aead_xform->algo == RTE_CRYPTO_AEAD_AES_GCM)
822 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_AEAD_MODE;
823 : : else
824 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CTR_MODE;
825 : :
826 : 0 : session->cipher_iv.offset = aead_xform->iv.offset;
827 : 0 : session->cipher_iv.length = aead_xform->iv.length;
828 : 0 : session->aad_len = aead_xform->aad_length;
829 : 0 : session->digest_length = aead_xform->digest_length;
830 : :
831 [ # # ]: 0 : if (aead_xform->op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
832 : 0 : session->qat_dir = ICP_QAT_HW_CIPHER_ENCRYPT;
833 : 0 : session->auth_op = ICP_QAT_HW_AUTH_GENERATE;
834 : : } else {
835 : 0 : session->qat_dir = ICP_QAT_HW_CIPHER_DECRYPT;
836 : 0 : session->auth_op = ICP_QAT_HW_AUTH_VERIFY;
837 : : }
838 : :
839 : : return 0;
840 : : }
841 : :
842 : : int
843 : 0 : qat_sym_session_configure_auth(struct rte_cryptodev *dev,
844 : : struct rte_crypto_sym_xform *xform,
845 : : struct qat_sym_session *session)
846 : : {
847 : : struct rte_crypto_auth_xform *auth_xform = qat_get_auth_xform(xform);
848 : 0 : struct qat_cryptodev_private *internals = dev->data->dev_private;
849 : 0 : const uint8_t *key_data = auth_xform->key.data;
850 : 0 : uint16_t key_length = auth_xform->key.length;
851 : 0 : enum qat_device_gen qat_dev_gen =
852 : 0 : internals->qat_dev->qat_dev_gen;
853 : : struct icp_qat_fw_la_bulk_req *req_tmpl = &session->fw_req;
854 : : struct icp_qat_fw_comn_req_hdr *header = &req_tmpl->comn_hdr;
855 : : struct icp_qat_fw_cipher_auth_cd_ctrl_hdr *cd_ctrl =
856 : : (struct icp_qat_fw_cipher_auth_cd_ctrl_hdr *)
857 : : session->fw_req.cd_ctrl.content_desc_ctrl_lw;
858 : : uint8_t hash_flag = 0;
859 : : int is_wireless = 0;
860 : :
861 : 0 : session->aes_cmac = 0;
862 : 0 : session->auth_key_length = auth_xform->key.length;
863 : 0 : session->auth_iv.offset = auth_xform->iv.offset;
864 : 0 : session->auth_iv.length = auth_xform->iv.length;
865 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE1;
866 : 0 : session->is_auth = 1;
867 : 0 : session->digest_length = auth_xform->digest_length;
868 : :
869 [ # # # # : 0 : switch (auth_xform->algo) {
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
870 : 0 : case RTE_CRYPTO_AUTH_SM3:
871 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SM3;
872 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
873 : 0 : break;
874 : 0 : case RTE_CRYPTO_AUTH_SM3_HMAC:
875 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SM3;
876 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE2;
877 : 0 : break;
878 : 0 : case RTE_CRYPTO_AUTH_SHA1:
879 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA1;
880 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
881 : 0 : break;
882 : 0 : case RTE_CRYPTO_AUTH_SHA224:
883 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA224;
884 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
885 : 0 : break;
886 : 0 : case RTE_CRYPTO_AUTH_SHA256:
887 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA256;
888 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
889 : 0 : break;
890 : 0 : case RTE_CRYPTO_AUTH_SHA384:
891 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA384;
892 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
893 : 0 : break;
894 : 0 : case RTE_CRYPTO_AUTH_SHA512:
895 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA512;
896 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
897 : 0 : break;
898 : 0 : case RTE_CRYPTO_AUTH_SHA3_224:
899 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA3_224;
900 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
901 : 0 : break;
902 : 0 : case RTE_CRYPTO_AUTH_SHA3_256:
903 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA3_256;
904 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
905 : 0 : break;
906 : 0 : case RTE_CRYPTO_AUTH_SHA3_384:
907 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA3_384;
908 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
909 : 0 : break;
910 : 0 : case RTE_CRYPTO_AUTH_SHA3_512:
911 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA3_512;
912 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
913 : 0 : break;
914 : 0 : case RTE_CRYPTO_AUTH_SHA1_HMAC:
915 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA1;
916 : 0 : break;
917 : 0 : case RTE_CRYPTO_AUTH_SHA224_HMAC:
918 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA224;
919 : 0 : break;
920 : 0 : case RTE_CRYPTO_AUTH_SHA256_HMAC:
921 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA256;
922 : 0 : break;
923 : 0 : case RTE_CRYPTO_AUTH_SHA384_HMAC:
924 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA384;
925 : 0 : break;
926 : 0 : case RTE_CRYPTO_AUTH_SHA512_HMAC:
927 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SHA512;
928 : 0 : break;
929 : 0 : case RTE_CRYPTO_AUTH_AES_XCBC_MAC:
930 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_AES_XCBC_MAC;
931 : 0 : break;
932 : 0 : case RTE_CRYPTO_AUTH_AES_CMAC:
933 : 0 : session->aes_cmac = 1;
934 [ # # ]: 0 : if (!internals->qat_dev->options.has_wireless_slice) {
935 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_AES_XCBC_MAC;
936 : 0 : break;
937 : : }
938 : : is_wireless = 1;
939 : 0 : session->is_wireless = 1;
940 [ # # ]: 0 : switch (key_length) {
941 : 0 : case ICP_QAT_HW_AES_128_KEY_SZ:
942 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_AES_128_CMAC;
943 : : break;
944 : 0 : default:
945 : 0 : QAT_LOG(ERR, "Invalid key length: %d", key_length);
946 : 0 : return -ENOTSUP;
947 : : }
948 : 0 : break;
949 : 0 : case RTE_CRYPTO_AUTH_AES_GMAC:
950 [ # # ]: 0 : if (qat_sym_validate_aes_key(auth_xform->key.length,
951 : : &session->qat_cipher_alg) != 0) {
952 : 0 : QAT_LOG(ERR, "Invalid AES key size");
953 : 0 : return -EINVAL;
954 : : }
955 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CTR_MODE;
956 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_GALOIS_128;
957 [ # # ]: 0 : if (session->auth_iv.length == 0)
958 : 0 : session->auth_iv.length = AES_GCM_J0_LEN;
959 : : else
960 : 0 : session->is_iv12B = 1;
961 : 0 : if (qat_dev_gen == QAT_GEN4 || qat_dev_gen == QAT_GEN5 ||
962 [ # # ]: 0 : qat_dev_gen == QAT_VQAT) {
963 : 0 : session->is_cnt_zero = 1;
964 : 0 : session->is_ucs = 1;
965 : : }
966 : : break;
967 : 0 : case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
968 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_SNOW_3G_UIA2;
969 [ # # ]: 0 : if (internals->qat_dev->options.has_wireless_slice) {
970 : : is_wireless = 1;
971 : 0 : session->is_wireless = 1;
972 : : hash_flag = 1 << ICP_QAT_FW_AUTH_HDR_FLAG_SNOW3G_UIA2_BITPOS;
973 : : }
974 : : break;
975 : 0 : case RTE_CRYPTO_AUTH_MD5_HMAC:
976 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_MD5;
977 : 0 : break;
978 : 0 : case RTE_CRYPTO_AUTH_NULL:
979 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_NULL;
980 : 0 : break;
981 : 0 : case RTE_CRYPTO_AUTH_KASUMI_F9:
982 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_KASUMI_F9;
983 : 0 : break;
984 : : case RTE_CRYPTO_AUTH_ZUC_EIA3:
985 [ # # ]: 0 : if (!qat_is_auth_alg_supported(auth_xform->algo, internals)) {
986 : 0 : QAT_LOG(ERR, "%s not supported on this device",
987 : : rte_cryptodev_get_auth_algo_string(auth_xform->algo));
988 : 0 : return -ENOTSUP;
989 : : }
990 [ # # ]: 0 : if (key_length == ICP_QAT_HW_ZUC_3G_EEA3_KEY_SZ) {
991 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_ZUC_3G_128_EIA3;
992 : : } else {
993 : 0 : QAT_LOG(ERR, "Invalid key length: %d", key_length);
994 : 0 : return -ENOTSUP;
995 : : }
996 [ # # ]: 0 : if (internals->qat_dev->options.has_wireless_slice) {
997 : : is_wireless = 1;
998 : 0 : session->is_wireless = 1;
999 : : hash_flag = 1 << ICP_QAT_FW_AUTH_HDR_FLAG_ZUC_EIA3_BITPOS;
1000 : : } else
1001 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
1002 : : break;
1003 : 0 : case RTE_CRYPTO_AUTH_MD5:
1004 : : case RTE_CRYPTO_AUTH_AES_CBC_MAC:
1005 : 0 : QAT_LOG(ERR, "Crypto: Unsupported hash alg %u",
1006 : : auth_xform->algo);
1007 : 0 : return -ENOTSUP;
1008 : 0 : default:
1009 : 0 : QAT_LOG(ERR, "Crypto: Undefined Hash algo %u specified",
1010 : : auth_xform->algo);
1011 : 0 : return -EINVAL;
1012 : : }
1013 : :
1014 [ # # ]: 0 : if (auth_xform->algo == RTE_CRYPTO_AUTH_AES_GMAC) {
1015 : 0 : session->is_gmac = 1;
1016 [ # # ]: 0 : if (auth_xform->op == RTE_CRYPTO_AUTH_OP_GENERATE) {
1017 : 0 : session->qat_cmd = ICP_QAT_FW_LA_CMD_CIPHER_HASH;
1018 : 0 : session->qat_dir = ICP_QAT_HW_CIPHER_ENCRYPT;
1019 : : /*
1020 : : * It needs to create cipher desc content first,
1021 : : * then authentication
1022 : : */
1023 [ # # ]: 0 : if (qat_sym_cd_cipher_set(session,
1024 : : auth_xform->key.data,
1025 : 0 : auth_xform->key.length))
1026 : : return -EINVAL;
1027 : :
1028 [ # # ]: 0 : if (qat_sym_cd_auth_set(session,
1029 : : key_data,
1030 : : key_length,
1031 : : 0,
1032 : 0 : auth_xform->digest_length,
1033 : 0 : auth_xform->op,
1034 : : qat_dev_gen))
1035 : : return -EINVAL;
1036 : : } else {
1037 : 0 : session->qat_cmd = ICP_QAT_FW_LA_CMD_HASH_CIPHER;
1038 : 0 : session->qat_dir = ICP_QAT_HW_CIPHER_DECRYPT;
1039 : : /*
1040 : : * It needs to create authentication desc content first,
1041 : : * then cipher
1042 : : */
1043 : :
1044 [ # # ]: 0 : if (qat_sym_cd_auth_set(session,
1045 : : key_data,
1046 : : key_length,
1047 : : 0,
1048 : 0 : auth_xform->digest_length,
1049 : : auth_xform->op,
1050 : : qat_dev_gen))
1051 : : return -EINVAL;
1052 : :
1053 [ # # ]: 0 : if (qat_sym_cd_cipher_set(session,
1054 : : auth_xform->key.data,
1055 : 0 : auth_xform->key.length))
1056 : : return -EINVAL;
1057 : : }
1058 : : } else {
1059 [ # # ]: 0 : if (qat_sym_cd_auth_set(session,
1060 : : key_data,
1061 : : key_length,
1062 : : 0,
1063 : 0 : auth_xform->digest_length,
1064 : 0 : auth_xform->op,
1065 : : qat_dev_gen))
1066 : : return -EINVAL;
1067 : : }
1068 : :
1069 [ # # ]: 0 : if (is_wireless) {
1070 [ # # ]: 0 : if (!session->aes_cmac) {
1071 : : /* Set the Use Extended Protocol Flags bit in LW 1 */
1072 : 0 : ICP_QAT_FW_USE_EXTENDED_PROTOCOL_FLAGS_SET(
1073 : : header->ext_flags,
1074 : : QAT_LA_USE_EXTENDED_PROTOCOL_FLAGS);
1075 : :
1076 : : /* Set Hash Flags in LW 28 */
1077 : 0 : cd_ctrl->hash_flags |= hash_flag;
1078 : : }
1079 : : /* Force usage of Wireless Auth slice */
1080 : 0 : ICP_QAT_FW_USE_WAT_SLICE_SET(header->ext_flags,
1081 : : QAT_LA_USE_WAT_SLICE);
1082 : : }
1083 : :
1084 : : return 0;
1085 : : }
1086 : :
1087 : : int
1088 : 0 : qat_sym_session_configure_aead(struct rte_cryptodev *dev,
1089 : : struct rte_crypto_sym_xform *xform,
1090 : : struct qat_sym_session *session)
1091 : : {
1092 : : struct rte_crypto_aead_xform *aead_xform = &xform->aead;
1093 : : enum rte_crypto_auth_operation crypto_operation;
1094 : 0 : struct qat_cryptodev_private *internals =
1095 : 0 : dev->data->dev_private;
1096 : 0 : enum qat_device_gen qat_dev_gen =
1097 : 0 : internals->qat_dev->qat_dev_gen;
1098 [ # # ]: 0 : if (qat_dev_gen == QAT_GEN_LCE) {
1099 : : struct icp_qat_fw_la_bulk_req *req_tmpl = &session->fw_req;
1100 : : struct lce_key_buff_desc *key_buff = &req_tmpl->key_buff;
1101 : :
1102 : 0 : key_buff->keybuff = session->key_paddr;
1103 : : }
1104 : :
1105 : : /*
1106 : : * Store AEAD IV parameters as cipher IV,
1107 : : * to avoid unnecessary memory usage
1108 : : */
1109 : 0 : session->cipher_iv.offset = xform->aead.iv.offset;
1110 : 0 : session->cipher_iv.length = xform->aead.iv.length;
1111 : :
1112 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE1;
1113 : 0 : session->is_auth = 1;
1114 : 0 : session->digest_length = aead_xform->digest_length;
1115 : :
1116 : 0 : session->is_single_pass = 0;
1117 [ # # # # ]: 0 : switch (aead_xform->algo) {
1118 : 0 : case RTE_CRYPTO_AEAD_AES_GCM:
1119 [ # # ]: 0 : if (qat_sym_validate_aes_key(aead_xform->key.length,
1120 : : &session->qat_cipher_alg) != 0) {
1121 : 0 : QAT_LOG(ERR, "Invalid AES key size");
1122 : 0 : return -EINVAL;
1123 : : }
1124 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CTR_MODE;
1125 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_GALOIS_128;
1126 : :
1127 : 0 : if (qat_dev_gen == QAT_GEN4 || qat_dev_gen == QAT_GEN5 ||
1128 [ # # ]: 0 : qat_dev_gen == QAT_VQAT)
1129 : 0 : session->is_ucs = 1;
1130 [ # # ]: 0 : if (session->cipher_iv.length == 0) {
1131 : 0 : session->cipher_iv.length = AES_GCM_J0_LEN;
1132 : 0 : break;
1133 : : }
1134 : 0 : session->is_iv12B = 1;
1135 [ # # ]: 0 : if (qat_dev_gen < QAT_GEN3)
1136 : : break;
1137 : : qat_sym_session_handle_single_pass(session,
1138 : : aead_xform);
1139 : : break;
1140 : 0 : case RTE_CRYPTO_AEAD_AES_CCM:
1141 [ # # ]: 0 : if (qat_sym_validate_aes_key(aead_xform->key.length,
1142 : : &session->qat_cipher_alg) != 0) {
1143 : 0 : QAT_LOG(ERR, "Invalid AES key size");
1144 : 0 : return -EINVAL;
1145 : : }
1146 : 0 : session->qat_mode = ICP_QAT_HW_CIPHER_CTR_MODE;
1147 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_AES_CBC_MAC;
1148 : 0 : if (qat_dev_gen == QAT_GEN4 || qat_dev_gen == QAT_GEN5 ||
1149 [ # # ]: 0 : qat_dev_gen == QAT_VQAT)
1150 : 0 : session->is_ucs = 1;
1151 : : break;
1152 : 0 : case RTE_CRYPTO_AEAD_CHACHA20_POLY1305:
1153 [ # # ]: 0 : if (aead_xform->key.length != ICP_QAT_HW_CHACHAPOLY_KEY_SZ)
1154 : : return -EINVAL;
1155 : 0 : if (qat_dev_gen == QAT_GEN4 || qat_dev_gen == QAT_GEN5 ||
1156 [ # # ]: 0 : qat_dev_gen == QAT_VQAT)
1157 : 0 : session->is_ucs = 1;
1158 [ # # ]: 0 : session->qat_cipher_alg =
1159 : : ICP_QAT_HW_CIPHER_ALGO_CHACHA20_POLY1305;
1160 : : qat_sym_session_handle_single_pass(session,
1161 : : aead_xform);
1162 : : break;
1163 : 0 : default:
1164 : 0 : QAT_LOG(ERR, "Crypto: Undefined AEAD specified %u",
1165 : : aead_xform->algo);
1166 : 0 : return -EINVAL;
1167 : : }
1168 : :
1169 [ # # ]: 0 : if (session->is_single_pass) {
1170 [ # # ]: 0 : if (qat_dev_gen != QAT_GEN_LCE) {
1171 [ # # ]: 0 : if (qat_sym_cd_cipher_set(session,
1172 : 0 : aead_xform->key.data, aead_xform->key.length))
1173 : 0 : return -EINVAL;
1174 : : } else {
1175 : 0 : session->auth_key_length = aead_xform->key.length;
1176 : 0 : memcpy(session->key_array, aead_xform->key.data, aead_xform->key.length);
1177 : : }
1178 : 0 : } else if ((aead_xform->op == RTE_CRYPTO_AEAD_OP_ENCRYPT &&
1179 [ # # ]: 0 : aead_xform->algo == RTE_CRYPTO_AEAD_AES_GCM) ||
1180 : : (aead_xform->op == RTE_CRYPTO_AEAD_OP_DECRYPT &&
1181 : : aead_xform->algo == RTE_CRYPTO_AEAD_AES_CCM)) {
1182 : 0 : session->qat_dir = ICP_QAT_HW_CIPHER_ENCRYPT;
1183 : : /*
1184 : : * It needs to create cipher desc content first,
1185 : : * then authentication
1186 : : */
1187 : 0 : crypto_operation = aead_xform->algo == RTE_CRYPTO_AEAD_AES_GCM ?
1188 : 0 : RTE_CRYPTO_AUTH_OP_GENERATE : RTE_CRYPTO_AUTH_OP_VERIFY;
1189 : :
1190 [ # # ]: 0 : if (qat_sym_cd_cipher_set(session,
1191 : : aead_xform->key.data,
1192 : 0 : aead_xform->key.length))
1193 : : return -EINVAL;
1194 : :
1195 [ # # ]: 0 : if (qat_sym_cd_auth_set(session,
1196 : : aead_xform->key.data,
1197 : 0 : aead_xform->key.length,
1198 : 0 : aead_xform->aad_length,
1199 : 0 : aead_xform->digest_length,
1200 : : crypto_operation,
1201 : : qat_dev_gen))
1202 : 0 : return -EINVAL;
1203 : : } else {
1204 : 0 : session->qat_dir = ICP_QAT_HW_CIPHER_DECRYPT;
1205 : : /*
1206 : : * It needs to create authentication desc content first,
1207 : : * then cipher
1208 : : */
1209 : :
1210 : 0 : crypto_operation = aead_xform->algo == RTE_CRYPTO_AEAD_AES_GCM ?
1211 : 0 : RTE_CRYPTO_AUTH_OP_VERIFY : RTE_CRYPTO_AUTH_OP_GENERATE;
1212 : :
1213 [ # # ]: 0 : if (qat_sym_cd_auth_set(session,
1214 : : aead_xform->key.data,
1215 : 0 : aead_xform->key.length,
1216 : 0 : aead_xform->aad_length,
1217 : 0 : aead_xform->digest_length,
1218 : : crypto_operation,
1219 : : qat_dev_gen))
1220 : : return -EINVAL;
1221 : :
1222 [ # # ]: 0 : if (qat_sym_cd_cipher_set(session,
1223 : : aead_xform->key.data,
1224 : 0 : aead_xform->key.length))
1225 : 0 : return -EINVAL;
1226 : : }
1227 : :
1228 : : return 0;
1229 : : }
1230 : :
1231 : 0 : unsigned int qat_sym_session_get_private_size(
1232 : : struct rte_cryptodev *dev __rte_unused)
1233 : : {
1234 : 0 : return RTE_ALIGN_CEIL(sizeof(struct qat_sym_session), 8);
1235 : : }
1236 : :
1237 : : /* returns block size in bytes per cipher algo */
1238 : 0 : int qat_cipher_get_block_size(enum icp_qat_hw_cipher_algo qat_cipher_alg)
1239 : : {
1240 [ # # # ]: 0 : switch (qat_cipher_alg) {
1241 : : case ICP_QAT_HW_CIPHER_ALGO_DES:
1242 : : return ICP_QAT_HW_DES_BLK_SZ;
1243 : : case ICP_QAT_HW_CIPHER_ALGO_3DES:
1244 : : return ICP_QAT_HW_3DES_BLK_SZ;
1245 : 0 : case ICP_QAT_HW_CIPHER_ALGO_AES128:
1246 : : case ICP_QAT_HW_CIPHER_ALGO_AES192:
1247 : : case ICP_QAT_HW_CIPHER_ALGO_AES256:
1248 : 0 : return ICP_QAT_HW_AES_BLK_SZ;
1249 : 0 : default:
1250 : 0 : QAT_LOG(ERR, "invalid block cipher alg %u", qat_cipher_alg);
1251 : 0 : return -EFAULT;
1252 : : };
1253 : : return -EFAULT;
1254 : : }
1255 : :
1256 : : /*
1257 : : * Returns size in bytes per hash algo for state1 size field in cd_ctrl
1258 : : * This is digest size rounded up to nearest quadword
1259 : : */
1260 : 0 : static int qat_hash_get_state1_size(enum icp_qat_hw_auth_algo qat_hash_alg)
1261 : : {
1262 [ # # # # : 0 : switch (qat_hash_alg) {
# # # # #
# # # # #
# # # # #
# # # #
# ]
1263 : : case ICP_QAT_HW_AUTH_ALGO_SHA1:
1264 : : return QAT_HW_ROUND_UP(ICP_QAT_HW_SHA1_STATE1_SZ,
1265 : : QAT_HW_DEFAULT_ALIGNMENT);
1266 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA224:
1267 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_SHA224_STATE1_SZ,
1268 : : QAT_HW_DEFAULT_ALIGNMENT);
1269 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA256:
1270 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_SHA256_STATE1_SZ,
1271 : : QAT_HW_DEFAULT_ALIGNMENT);
1272 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA384:
1273 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_SHA384_STATE1_SZ,
1274 : : QAT_HW_DEFAULT_ALIGNMENT);
1275 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA512:
1276 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_SHA512_STATE1_SZ,
1277 : : QAT_HW_DEFAULT_ALIGNMENT);
1278 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA3_224:
1279 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_SHA3_224_STATE1_SZ,
1280 : : QAT_HW_DEFAULT_ALIGNMENT);
1281 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA3_256:
1282 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_SHA3_256_STATE1_SZ,
1283 : : QAT_HW_DEFAULT_ALIGNMENT);
1284 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA3_384:
1285 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_SHA3_384_STATE1_SZ,
1286 : : QAT_HW_DEFAULT_ALIGNMENT);
1287 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA3_512:
1288 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_SHA3_512_STATE1_SZ,
1289 : : QAT_HW_DEFAULT_ALIGNMENT);
1290 : 0 : case ICP_QAT_HW_AUTH_ALGO_AES_XCBC_MAC:
1291 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_AES_XCBC_MAC_STATE1_SZ,
1292 : : QAT_HW_DEFAULT_ALIGNMENT);
1293 : 0 : case ICP_QAT_HW_AUTH_ALGO_GALOIS_128:
1294 : : case ICP_QAT_HW_AUTH_ALGO_GALOIS_64:
1295 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_GALOIS_128_STATE1_SZ,
1296 : : QAT_HW_DEFAULT_ALIGNMENT);
1297 : 0 : case ICP_QAT_HW_AUTH_ALGO_ZUC_3G_128_EIA3:
1298 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_ZUC_3G_EIA3_STATE1_SZ,
1299 : : QAT_HW_DEFAULT_ALIGNMENT);
1300 : 0 : case ICP_QAT_HW_AUTH_ALGO_ZUC_256_MAC_32:
1301 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_ZUC_256_MAC_32_STATE1_SZ,
1302 : : QAT_HW_DEFAULT_ALIGNMENT);
1303 : 0 : case ICP_QAT_HW_AUTH_ALGO_ZUC_256_MAC_64:
1304 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_ZUC_256_MAC_64_STATE1_SZ,
1305 : : QAT_HW_DEFAULT_ALIGNMENT);
1306 : 0 : case ICP_QAT_HW_AUTH_ALGO_ZUC_256_MAC_128:
1307 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_ZUC_256_MAC_128_STATE1_SZ,
1308 : : QAT_HW_DEFAULT_ALIGNMENT);
1309 : 0 : case ICP_QAT_HW_AUTH_ALGO_SNOW_3G_UIA2:
1310 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_SNOW_3G_UIA2_STATE1_SZ,
1311 : : QAT_HW_DEFAULT_ALIGNMENT);
1312 : 0 : case ICP_QAT_HW_AUTH_ALGO_MD5:
1313 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_MD5_STATE1_SZ,
1314 : : QAT_HW_DEFAULT_ALIGNMENT);
1315 : 0 : case ICP_QAT_HW_AUTH_ALGO_KASUMI_F9:
1316 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_KASUMI_F9_STATE1_SZ,
1317 : : QAT_HW_DEFAULT_ALIGNMENT);
1318 : 0 : case ICP_QAT_HW_AUTH_ALGO_AES_CBC_MAC:
1319 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_AES_CBC_MAC_STATE1_SZ,
1320 : : QAT_HW_DEFAULT_ALIGNMENT);
1321 : 0 : case ICP_QAT_HW_AUTH_ALGO_SM3:
1322 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_SM3_STATE1_SZ,
1323 : : QAT_HW_DEFAULT_ALIGNMENT);
1324 : 0 : case ICP_QAT_HW_AUTH_ALGO_NULL:
1325 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_NULL_STATE1_SZ,
1326 : : QAT_HW_DEFAULT_ALIGNMENT);
1327 : 0 : case ICP_QAT_HW_AUTH_ALGO_AES_128_CMAC:
1328 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_AES_CMAC_STATE1_SZ,
1329 : : QAT_HW_DEFAULT_ALIGNMENT);
1330 : 0 : case ICP_QAT_HW_AUTH_ALGO_DELIMITER:
1331 : : /* return maximum state1 size in this case */
1332 : 0 : return QAT_HW_ROUND_UP(ICP_QAT_HW_SHA512_STATE1_SZ,
1333 : : QAT_HW_DEFAULT_ALIGNMENT);
1334 : 0 : default:
1335 : 0 : QAT_LOG(ERR, "invalid hash alg %u", qat_hash_alg);
1336 : 0 : return -EFAULT;
1337 : : };
1338 : : return -EFAULT;
1339 : : }
1340 : :
1341 : : /* returns digest size in bytes per hash algo */
1342 : 0 : static int qat_hash_get_digest_size(enum icp_qat_hw_auth_algo qat_hash_alg)
1343 : : {
1344 [ # # # # : 0 : switch (qat_hash_alg) {
# # # # #
# # # # ]
1345 : : case ICP_QAT_HW_AUTH_ALGO_SHA1:
1346 : : return ICP_QAT_HW_SHA1_STATE1_SZ;
1347 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA224:
1348 : 0 : return ICP_QAT_HW_SHA224_STATE1_SZ;
1349 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA256:
1350 : 0 : return ICP_QAT_HW_SHA256_STATE1_SZ;
1351 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA384:
1352 : 0 : return ICP_QAT_HW_SHA384_STATE1_SZ;
1353 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA512:
1354 : 0 : return ICP_QAT_HW_SHA512_STATE1_SZ;
1355 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA3_224:
1356 : 0 : return ICP_QAT_HW_SHA3_224_STATE1_SZ;
1357 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA3_256:
1358 : 0 : return ICP_QAT_HW_SHA3_256_STATE1_SZ;
1359 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA3_384:
1360 : 0 : return ICP_QAT_HW_SHA3_384_STATE1_SZ;
1361 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA3_512:
1362 : 0 : return ICP_QAT_HW_SHA3_512_STATE1_SZ;
1363 : 0 : case ICP_QAT_HW_AUTH_ALGO_MD5:
1364 : 0 : return ICP_QAT_HW_MD5_STATE1_SZ;
1365 : 0 : case ICP_QAT_HW_AUTH_ALGO_AES_XCBC_MAC:
1366 : : case ICP_QAT_HW_AUTH_ALGO_AES_128_CMAC:
1367 : 0 : return ICP_QAT_HW_AES_XCBC_MAC_STATE1_SZ;
1368 : 0 : case ICP_QAT_HW_AUTH_ALGO_DELIMITER:
1369 : : /* return maximum digest size in this case */
1370 : 0 : return ICP_QAT_HW_SHA512_STATE1_SZ;
1371 : 0 : default:
1372 : 0 : QAT_LOG(ERR, "invalid hash alg %u", qat_hash_alg);
1373 : 0 : return -EFAULT;
1374 : : };
1375 : : return -EFAULT;
1376 : : }
1377 : :
1378 : : /* returns block size in byes per hash algo */
1379 : 0 : static int qat_hash_get_block_size(enum icp_qat_hw_auth_algo qat_hash_alg)
1380 : : {
1381 [ # # # # : 0 : switch (qat_hash_alg) {
# # # ]
1382 : : case ICP_QAT_HW_AUTH_ALGO_SHA1:
1383 : : case ICP_QAT_HW_AUTH_ALGO_SHA224:
1384 : : case ICP_QAT_HW_AUTH_ALGO_SHA256:
1385 : : return QAT_SHA_CBLOCK;
1386 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA384:
1387 : : case ICP_QAT_HW_AUTH_ALGO_SHA512:
1388 : 0 : return QAT_SHA512_CBLOCK;
1389 : 0 : case ICP_QAT_HW_AUTH_ALGO_GALOIS_128:
1390 : 0 : return 16;
1391 : 0 : case ICP_QAT_HW_AUTH_ALGO_AES_XCBC_MAC:
1392 : 0 : return ICP_QAT_HW_AES_BLK_SZ;
1393 : : case ICP_QAT_HW_AUTH_ALGO_MD5:
1394 : : return QAT_MD5_CBLOCK;
1395 : 0 : case ICP_QAT_HW_AUTH_ALGO_ZUC_256_MAC_32:
1396 : : case ICP_QAT_HW_AUTH_ALGO_ZUC_256_MAC_64:
1397 : : case ICP_QAT_HW_AUTH_ALGO_ZUC_256_MAC_128:
1398 : 0 : return ICP_QAT_HW_ZUC_256_BLK_SZ;
1399 : 0 : case ICP_QAT_HW_AUTH_ALGO_DELIMITER:
1400 : : /* return maximum block size in this case */
1401 : 0 : return QAT_SHA512_CBLOCK;
1402 : : case ICP_QAT_HW_AUTH_ALGO_SM3:
1403 : : return QAT_SM3_BLOCK_SIZE;
1404 : 0 : default:
1405 : 0 : QAT_LOG(ERR, "invalid hash alg %u", qat_hash_alg);
1406 : 0 : return -EFAULT;
1407 : : };
1408 : : return -EFAULT;
1409 : : }
1410 : :
1411 : : #define HMAC_IPAD_VALUE 0x36
1412 : : #define HMAC_OPAD_VALUE 0x5c
1413 : : #define HASH_XCBC_PRECOMP_KEY_NUM 3
1414 : :
1415 : : #ifdef RTE_QAT_OPENSSL
1416 : 0 : static int partial_hash_sha1(uint8_t *data_in, uint8_t *data_out)
1417 : : {
1418 : : SHA_CTX ctx;
1419 : :
1420 [ # # ]: 0 : if (!SHA1_Init(&ctx))
1421 : : return -EFAULT;
1422 : 0 : SHA1_Transform(&ctx, data_in);
1423 : : rte_memcpy(data_out, &ctx, SHA_DIGEST_LENGTH);
1424 : : return 0;
1425 : : }
1426 : :
1427 : 0 : static int partial_hash_sha224(uint8_t *data_in, uint8_t *data_out)
1428 : : {
1429 : : SHA256_CTX ctx;
1430 : :
1431 [ # # ]: 0 : if (!SHA224_Init(&ctx))
1432 : : return -EFAULT;
1433 : 0 : SHA256_Transform(&ctx, data_in);
1434 : : rte_memcpy(data_out, &ctx, SHA256_DIGEST_LENGTH);
1435 : : return 0;
1436 : : }
1437 : :
1438 : 0 : static int partial_hash_sha256(uint8_t *data_in, uint8_t *data_out)
1439 : : {
1440 : : SHA256_CTX ctx;
1441 : :
1442 [ # # ]: 0 : if (!SHA256_Init(&ctx))
1443 : : return -EFAULT;
1444 : 0 : SHA256_Transform(&ctx, data_in);
1445 : : rte_memcpy(data_out, &ctx, SHA256_DIGEST_LENGTH);
1446 : : return 0;
1447 : : }
1448 : :
1449 : 0 : static int partial_hash_sha384(uint8_t *data_in, uint8_t *data_out)
1450 : : {
1451 : : SHA512_CTX ctx;
1452 : :
1453 [ # # ]: 0 : if (!SHA384_Init(&ctx))
1454 : : return -EFAULT;
1455 : 0 : SHA512_Transform(&ctx, data_in);
1456 : : rte_memcpy(data_out, &ctx, SHA512_DIGEST_LENGTH);
1457 : : return 0;
1458 : : }
1459 : :
1460 : 0 : static int partial_hash_sha512(uint8_t *data_in, uint8_t *data_out)
1461 : : {
1462 : : SHA512_CTX ctx;
1463 : :
1464 [ # # ]: 0 : if (!SHA512_Init(&ctx))
1465 : : return -EFAULT;
1466 : 0 : SHA512_Transform(&ctx, data_in);
1467 : : rte_memcpy(data_out, &ctx, SHA512_DIGEST_LENGTH);
1468 : : return 0;
1469 : : }
1470 : :
1471 : 0 : static int partial_hash_md5(uint8_t *data_in, uint8_t *data_out)
1472 : : {
1473 : : MD5_CTX ctx;
1474 : :
1475 [ # # ]: 0 : if (!MD5_Init(&ctx))
1476 : : return -EFAULT;
1477 : 0 : MD5_Transform(&ctx, data_in);
1478 : : rte_memcpy(data_out, &ctx, MD5_DIGEST_LENGTH);
1479 : :
1480 : : return 0;
1481 : : }
1482 : :
1483 : 0 : static void aes_cmac_key_derive(uint8_t *base, uint8_t *derived)
1484 : : {
1485 : : int i;
1486 : :
1487 : 0 : derived[0] = base[0] << 1;
1488 [ # # ]: 0 : for (i = 1; i < ICP_QAT_HW_AES_BLK_SZ ; i++) {
1489 : 0 : derived[i] = base[i] << 1;
1490 : 0 : derived[i - 1] |= base[i] >> 7;
1491 : : }
1492 : :
1493 [ # # ]: 0 : if (base[0] & 0x80)
1494 : 0 : derived[ICP_QAT_HW_AES_BLK_SZ - 1] ^= QAT_AES_CMAC_CONST_RB;
1495 : 0 : }
1496 : :
1497 : : static int
1498 : 0 : partial_hash_compute(enum icp_qat_hw_auth_algo hash_alg,
1499 : : uint8_t *data_in, uint8_t *data_out)
1500 : 0 : {
1501 : : int digest_size;
1502 : 0 : uint8_t digest[qat_hash_get_digest_size(
1503 : : ICP_QAT_HW_AUTH_ALGO_DELIMITER)];
1504 : : uint32_t *hash_state_out_be32;
1505 : : uint64_t *hash_state_out_be64;
1506 : : int i;
1507 : :
1508 : : /* Initialize to avoid gcc warning */
1509 : : memset(digest, 0, sizeof(digest));
1510 : :
1511 : 0 : digest_size = qat_hash_get_digest_size(hash_alg);
1512 [ # # ]: 0 : if (digest_size <= 0)
1513 : : return -EFAULT;
1514 : :
1515 : : hash_state_out_be32 = (uint32_t *)data_out;
1516 : : hash_state_out_be64 = (uint64_t *)data_out;
1517 : :
1518 [ # # # # : 0 : switch (hash_alg) {
# # # ]
1519 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA1:
1520 [ # # ]: 0 : if (partial_hash_sha1(data_in, digest))
1521 : : return -EFAULT;
1522 [ # # ]: 0 : for (i = 0; i < digest_size >> 2; i++, hash_state_out_be32++)
1523 : 0 : *hash_state_out_be32 =
1524 [ # # ]: 0 : rte_bswap32(*(((uint32_t *)digest)+i));
1525 : : break;
1526 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA224:
1527 [ # # ]: 0 : if (partial_hash_sha224(data_in, digest))
1528 : : return -EFAULT;
1529 [ # # ]: 0 : for (i = 0; i < digest_size >> 2; i++, hash_state_out_be32++)
1530 : 0 : *hash_state_out_be32 =
1531 [ # # ]: 0 : rte_bswap32(*(((uint32_t *)digest)+i));
1532 : : break;
1533 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA256:
1534 [ # # ]: 0 : if (partial_hash_sha256(data_in, digest))
1535 : : return -EFAULT;
1536 [ # # ]: 0 : for (i = 0; i < digest_size >> 2; i++, hash_state_out_be32++)
1537 : 0 : *hash_state_out_be32 =
1538 [ # # ]: 0 : rte_bswap32(*(((uint32_t *)digest)+i));
1539 : : break;
1540 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA384:
1541 [ # # ]: 0 : if (partial_hash_sha384(data_in, digest))
1542 : : return -EFAULT;
1543 [ # # ]: 0 : for (i = 0; i < digest_size >> 3; i++, hash_state_out_be64++)
1544 : 0 : *hash_state_out_be64 =
1545 [ # # ]: 0 : rte_bswap64(*(((uint64_t *)digest)+i));
1546 : : break;
1547 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA512:
1548 [ # # ]: 0 : if (partial_hash_sha512(data_in, digest))
1549 : : return -EFAULT;
1550 [ # # ]: 0 : for (i = 0; i < digest_size >> 3; i++, hash_state_out_be64++)
1551 : 0 : *hash_state_out_be64 =
1552 [ # # ]: 0 : rte_bswap64(*(((uint64_t *)digest)+i));
1553 : : break;
1554 : 0 : case ICP_QAT_HW_AUTH_ALGO_MD5:
1555 [ # # ]: 0 : if (partial_hash_md5(data_in, data_out))
1556 : 0 : return -EFAULT;
1557 : : break;
1558 : 0 : default:
1559 : 0 : QAT_LOG(ERR, "invalid hash alg %u", hash_alg);
1560 : 0 : return -EFAULT;
1561 : : }
1562 : :
1563 : : return 0;
1564 : : }
1565 : :
1566 : : static const uint8_t AES_CMAC_SEED[ICP_QAT_HW_AES_128_KEY_SZ];
1567 : :
1568 : 0 : static int qat_sym_do_precomputes(enum icp_qat_hw_auth_algo hash_alg,
1569 : : const uint8_t *auth_key,
1570 : : uint16_t auth_keylen,
1571 : : uint8_t *p_state_buf,
1572 : : uint16_t *p_state_len,
1573 : : uint8_t aes_cmac)
1574 : 0 : {
1575 : : int block_size;
1576 : 0 : uint8_t ipad[qat_hash_get_block_size(ICP_QAT_HW_AUTH_ALGO_DELIMITER)];
1577 : 0 : uint8_t opad[qat_hash_get_block_size(ICP_QAT_HW_AUTH_ALGO_DELIMITER)];
1578 : : int i;
1579 : :
1580 [ # # ]: 0 : if (hash_alg == ICP_QAT_HW_AUTH_ALGO_AES_XCBC_MAC) {
1581 : :
1582 : : /* CMAC */
1583 [ # # ]: 0 : if (aes_cmac) {
1584 : : AES_KEY enc_key;
1585 : : uint8_t *in = NULL;
1586 : : uint8_t k0[ICP_QAT_HW_AES_128_KEY_SZ];
1587 : : uint8_t *k1, *k2;
1588 : :
1589 : : auth_keylen = ICP_QAT_HW_AES_128_KEY_SZ;
1590 : :
1591 : 0 : in = rte_zmalloc("AES CMAC K1",
1592 : : ICP_QAT_HW_AES_128_KEY_SZ, 16);
1593 : :
1594 [ # # ]: 0 : if (in == NULL) {
1595 : 0 : QAT_LOG(ERR, "Failed to alloc memory");
1596 : 0 : return -ENOMEM;
1597 : : }
1598 : :
1599 : : rte_memcpy(in, AES_CMAC_SEED,
1600 : : ICP_QAT_HW_AES_128_KEY_SZ);
1601 : : rte_memcpy(p_state_buf, auth_key, auth_keylen);
1602 : :
1603 [ # # ]: 0 : if (AES_set_encrypt_key(auth_key, auth_keylen << 3,
1604 : : &enc_key) != 0) {
1605 : 0 : rte_free_sensitive(in);
1606 : 0 : return -EFAULT;
1607 : : }
1608 : :
1609 : 0 : AES_encrypt(in, k0, &enc_key);
1610 : :
1611 : 0 : k1 = p_state_buf + ICP_QAT_HW_AES_XCBC_MAC_STATE1_SZ;
1612 : 0 : k2 = k1 + ICP_QAT_HW_AES_XCBC_MAC_STATE1_SZ;
1613 : :
1614 : 0 : aes_cmac_key_derive(k0, k1);
1615 : 0 : aes_cmac_key_derive(k1, k2);
1616 : :
1617 : 0 : rte_memzero_explicit(k0, ICP_QAT_HW_AES_128_KEY_SZ);
1618 : 0 : *p_state_len = ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ;
1619 : 0 : rte_free_sensitive(in);
1620 : 0 : goto out;
1621 : : } else {
1622 : : static uint8_t qat_aes_xcbc_key_seed[
1623 : : ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ] = {
1624 : : 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
1625 : : 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
1626 : : 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
1627 : : 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
1628 : : 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
1629 : : 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
1630 : : };
1631 : :
1632 : : uint8_t *in = NULL;
1633 : : uint8_t *out = p_state_buf;
1634 : : int x;
1635 : : AES_KEY enc_key;
1636 : :
1637 : 0 : in = rte_zmalloc("working mem for key",
1638 : : ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ, 16);
1639 [ # # ]: 0 : if (in == NULL) {
1640 : 0 : QAT_LOG(ERR, "Failed to alloc memory");
1641 : 0 : return -ENOMEM;
1642 : : }
1643 : :
1644 : : rte_memcpy(in, qat_aes_xcbc_key_seed,
1645 : : ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ);
1646 [ # # ]: 0 : for (x = 0; x < HASH_XCBC_PRECOMP_KEY_NUM; x++) {
1647 [ # # ]: 0 : if (AES_set_encrypt_key(auth_key,
1648 : : auth_keylen << 3,
1649 : : &enc_key) != 0) {
1650 : 0 : rte_free_sensitive(in -
1651 : 0 : (x * ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ));
1652 : 0 : rte_memzero_explicit(out -
1653 : : (x * ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ),
1654 : : ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ);
1655 : 0 : return -EFAULT;
1656 : : }
1657 : 0 : AES_encrypt(in, out, &enc_key);
1658 : 0 : in += ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ;
1659 : 0 : out += ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ;
1660 : : }
1661 : 0 : *p_state_len = ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ;
1662 : 0 : rte_free_sensitive(in - x*ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ);
1663 : 0 : goto out;
1664 : : }
1665 : :
1666 [ # # ]: 0 : } else if ((hash_alg == ICP_QAT_HW_AUTH_ALGO_GALOIS_128) ||
1667 : : (hash_alg == ICP_QAT_HW_AUTH_ALGO_GALOIS_64)) {
1668 : : uint8_t *in = NULL;
1669 : : uint8_t *out = p_state_buf;
1670 : : AES_KEY enc_key;
1671 : :
1672 : : memset(p_state_buf, 0, ICP_QAT_HW_GALOIS_H_SZ +
1673 : : ICP_QAT_HW_GALOIS_LEN_A_SZ +
1674 : : ICP_QAT_HW_GALOIS_E_CTR0_SZ);
1675 : 0 : in = rte_zmalloc("working mem for key",
1676 : : ICP_QAT_HW_GALOIS_H_SZ, 16);
1677 [ # # ]: 0 : if (in == NULL) {
1678 : 0 : QAT_LOG(ERR, "Failed to alloc memory");
1679 : 0 : return -ENOMEM;
1680 : : }
1681 : :
1682 : 0 : rte_memzero_explicit(in, ICP_QAT_HW_GALOIS_H_SZ);
1683 [ # # ]: 0 : if (AES_set_encrypt_key(auth_key, auth_keylen << 3,
1684 : : &enc_key) != 0) {
1685 : : return -EFAULT;
1686 : : }
1687 : 0 : AES_encrypt(in, out, &enc_key);
1688 : 0 : *p_state_len = ICP_QAT_HW_GALOIS_H_SZ +
1689 : : ICP_QAT_HW_GALOIS_LEN_A_SZ +
1690 : : ICP_QAT_HW_GALOIS_E_CTR0_SZ;
1691 : 0 : rte_free_sensitive(in);
1692 : 0 : return 0;
1693 : : }
1694 : :
1695 : 0 : block_size = qat_hash_get_block_size(hash_alg);
1696 [ # # ]: 0 : if (block_size < 0)
1697 : : return block_size;
1698 : : /* init ipad and opad from key and xor with fixed values */
1699 [ # # ]: 0 : memset(ipad, 0, block_size);
1700 : : memset(opad, 0, block_size);
1701 : :
1702 [ # # ]: 0 : if (auth_keylen > (unsigned int)block_size) {
1703 : 0 : QAT_LOG(ERR, "invalid keylen %u", auth_keylen);
1704 : 0 : return -EFAULT;
1705 : : }
1706 : :
1707 [ # # ]: 0 : RTE_VERIFY(auth_keylen <= sizeof(ipad));
1708 : : RTE_VERIFY(auth_keylen <= sizeof(opad));
1709 : :
1710 : : rte_memcpy(ipad, auth_key, auth_keylen);
1711 : : rte_memcpy(opad, auth_key, auth_keylen);
1712 : :
1713 [ # # ]: 0 : for (i = 0; i < block_size; i++) {
1714 : 0 : uint8_t *ipad_ptr = ipad + i;
1715 : 0 : uint8_t *opad_ptr = opad + i;
1716 : 0 : *ipad_ptr ^= HMAC_IPAD_VALUE;
1717 : 0 : *opad_ptr ^= HMAC_OPAD_VALUE;
1718 : : }
1719 : :
1720 : : /* do partial hash of ipad and copy to state1 */
1721 [ # # ]: 0 : if (partial_hash_compute(hash_alg, ipad, p_state_buf)) {
1722 : 0 : rte_memzero_explicit(ipad, block_size);
1723 : 0 : rte_memzero_explicit(opad, block_size);
1724 : 0 : QAT_LOG(ERR, "ipad precompute failed");
1725 : 0 : return -EFAULT;
1726 : : }
1727 : :
1728 : : /*
1729 : : * State len is a multiple of 8, so may be larger than the digest.
1730 : : * Put the partial hash of opad state_len bytes after state1
1731 : : */
1732 : 0 : *p_state_len = qat_hash_get_state1_size(hash_alg);
1733 [ # # ]: 0 : if (partial_hash_compute(hash_alg, opad, p_state_buf + *p_state_len)) {
1734 : 0 : rte_memzero_explicit(ipad, block_size);
1735 : 0 : rte_memzero_explicit(opad, block_size);
1736 : 0 : QAT_LOG(ERR, "opad precompute failed");
1737 : 0 : return -EFAULT;
1738 : : }
1739 : :
1740 : : /* don't leave data lying around */
1741 : 0 : rte_memzero_explicit(ipad, block_size);
1742 : 0 : rte_memzero_explicit(opad, block_size);
1743 : : out:
1744 : : return 0;
1745 : : }
1746 : :
1747 : : #else
1748 : :
1749 : : static int aes_ipsecmb_job(uint8_t *in, uint8_t *out, IMB_MGR *m,
1750 : : const uint8_t *key, uint16_t auth_keylen)
1751 : : {
1752 : : int err;
1753 : : struct IMB_JOB *job;
1754 : : DECLARE_ALIGNED(uint32_t expkey[4*15], 16);
1755 : : DECLARE_ALIGNED(uint32_t dust[4*15], 16);
1756 : :
1757 : : if (auth_keylen == ICP_QAT_HW_AES_128_KEY_SZ)
1758 : : IMB_AES_KEYEXP_128(m, key, expkey, dust);
1759 : : else if (auth_keylen == ICP_QAT_HW_AES_192_KEY_SZ)
1760 : : IMB_AES_KEYEXP_192(m, key, expkey, dust);
1761 : : else if (auth_keylen == ICP_QAT_HW_AES_256_KEY_SZ)
1762 : : IMB_AES_KEYEXP_256(m, key, expkey, dust);
1763 : : else
1764 : : return -EFAULT;
1765 : :
1766 : : job = IMB_GET_NEXT_JOB(m);
1767 : :
1768 : : job->src = in;
1769 : : job->dst = out;
1770 : : job->enc_keys = expkey;
1771 : : job->key_len_in_bytes = auth_keylen;
1772 : : job->msg_len_to_cipher_in_bytes = 16;
1773 : : job->iv_len_in_bytes = 0;
1774 : : job->cipher_direction = IMB_DIR_ENCRYPT;
1775 : : job->cipher_mode = IMB_CIPHER_ECB;
1776 : : job->hash_alg = IMB_AUTH_NULL;
1777 : :
1778 : : while (IMB_FLUSH_JOB(m) != NULL)
1779 : : ;
1780 : :
1781 : : job = IMB_SUBMIT_JOB(m);
1782 : : if (job) {
1783 : : if (job->status == IMB_STATUS_COMPLETED)
1784 : : return 0;
1785 : : }
1786 : :
1787 : : err = imb_get_errno(m);
1788 : : if (err)
1789 : : QAT_LOG(ERR, "Error: %s!", imb_get_strerror(err));
1790 : :
1791 : : return -EFAULT;
1792 : : }
1793 : :
1794 : : static int
1795 : : partial_hash_compute_ipsec_mb(enum icp_qat_hw_auth_algo hash_alg,
1796 : : uint8_t *data_in, uint8_t *data_out, IMB_MGR *m)
1797 : : {
1798 : : int digest_size;
1799 : : uint8_t digest[qat_hash_get_digest_size(
1800 : : ICP_QAT_HW_AUTH_ALGO_DELIMITER)];
1801 : : uint32_t *hash_state_out_be32;
1802 : : uint64_t *hash_state_out_be64;
1803 : : int i;
1804 : :
1805 : : /* Initialize to avoid gcc warning */
1806 : : memset(digest, 0, sizeof(digest));
1807 : :
1808 : : digest_size = qat_hash_get_digest_size(hash_alg);
1809 : : if (digest_size <= 0)
1810 : : return -EFAULT;
1811 : :
1812 : : hash_state_out_be32 = (uint32_t *)data_out;
1813 : : hash_state_out_be64 = (uint64_t *)data_out;
1814 : :
1815 : : switch (hash_alg) {
1816 : : case ICP_QAT_HW_AUTH_ALGO_SHA1:
1817 : : IMB_SHA1_ONE_BLOCK(m, data_in, digest);
1818 : : for (i = 0; i < digest_size >> 2; i++, hash_state_out_be32++)
1819 : : *hash_state_out_be32 =
1820 : : rte_bswap32(*(((uint32_t *)digest)+i));
1821 : : break;
1822 : : case ICP_QAT_HW_AUTH_ALGO_SHA224:
1823 : : IMB_SHA224_ONE_BLOCK(m, data_in, digest);
1824 : : for (i = 0; i < digest_size >> 2; i++, hash_state_out_be32++)
1825 : : *hash_state_out_be32 =
1826 : : rte_bswap32(*(((uint32_t *)digest)+i));
1827 : : break;
1828 : : case ICP_QAT_HW_AUTH_ALGO_SHA256:
1829 : : IMB_SHA256_ONE_BLOCK(m, data_in, digest);
1830 : : for (i = 0; i < digest_size >> 2; i++, hash_state_out_be32++)
1831 : : *hash_state_out_be32 =
1832 : : rte_bswap32(*(((uint32_t *)digest)+i));
1833 : : break;
1834 : : case ICP_QAT_HW_AUTH_ALGO_SHA384:
1835 : : IMB_SHA384_ONE_BLOCK(m, data_in, digest);
1836 : : for (i = 0; i < digest_size >> 3; i++, hash_state_out_be64++)
1837 : : *hash_state_out_be64 =
1838 : : rte_bswap64(*(((uint64_t *)digest)+i));
1839 : : break;
1840 : : case ICP_QAT_HW_AUTH_ALGO_SHA512:
1841 : : IMB_SHA512_ONE_BLOCK(m, data_in, digest);
1842 : : for (i = 0; i < digest_size >> 3; i++, hash_state_out_be64++)
1843 : : *hash_state_out_be64 =
1844 : : rte_bswap64(*(((uint64_t *)digest)+i));
1845 : : break;
1846 : : case ICP_QAT_HW_AUTH_ALGO_MD5:
1847 : : IMB_MD5_ONE_BLOCK(m, data_in, data_out);
1848 : : break;
1849 : : default:
1850 : : QAT_LOG(ERR, "invalid hash alg %u", hash_alg);
1851 : : return -EFAULT;
1852 : : }
1853 : :
1854 : : return 0;
1855 : : }
1856 : :
1857 : : static int qat_sym_do_precomputes_ipsec_mb(enum icp_qat_hw_auth_algo hash_alg,
1858 : : const uint8_t *auth_key,
1859 : : uint16_t auth_keylen,
1860 : : uint8_t *p_state_buf,
1861 : : uint16_t *p_state_len,
1862 : : uint8_t aes_cmac)
1863 : : {
1864 : : int block_size = 0;
1865 : : uint8_t ipad[qat_hash_get_block_size(ICP_QAT_HW_AUTH_ALGO_DELIMITER)];
1866 : : uint8_t opad[qat_hash_get_block_size(ICP_QAT_HW_AUTH_ALGO_DELIMITER)];
1867 : : int i, ret = 0;
1868 : : uint8_t in[ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ];
1869 : :
1870 : : IMB_MGR *m;
1871 : : m = alloc_mb_mgr(0);
1872 : : if (m == NULL)
1873 : : return -ENOMEM;
1874 : :
1875 : : init_mb_mgr_auto(m, NULL);
1876 : : memset(in, 0, ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ);
1877 : : if (hash_alg == ICP_QAT_HW_AUTH_ALGO_AES_XCBC_MAC) {
1878 : :
1879 : : /* CMAC */
1880 : : if (aes_cmac) {
1881 : : uint8_t *k1, *k2;
1882 : : auth_keylen = ICP_QAT_HW_AES_128_KEY_SZ;
1883 : : rte_memcpy(p_state_buf, auth_key, auth_keylen);
1884 : :
1885 : : DECLARE_ALIGNED(uint32_t expkey[4*15], 16);
1886 : : DECLARE_ALIGNED(uint32_t dust[4*15], 16);
1887 : : IMB_AES_KEYEXP_128(m, p_state_buf, expkey, dust);
1888 : : k1 = p_state_buf + ICP_QAT_HW_AES_XCBC_MAC_STATE1_SZ;
1889 : : k2 = k1 + ICP_QAT_HW_AES_XCBC_MAC_STATE1_SZ;
1890 : :
1891 : : IMB_AES_CMAC_SUBKEY_GEN_128(m, expkey, k1, k2);
1892 : : *p_state_len = ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ;
1893 : : goto out;
1894 : : }
1895 : :
1896 : : static uint8_t qat_aes_xcbc_key_seed[
1897 : : ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ] = {
1898 : : 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
1899 : : 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
1900 : : 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
1901 : : 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
1902 : : 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
1903 : : 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
1904 : : };
1905 : :
1906 : : uint8_t *input = in;
1907 : : uint8_t *out = p_state_buf;
1908 : : rte_memcpy(input, qat_aes_xcbc_key_seed,
1909 : : ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ);
1910 : : for (i = 0; i < HASH_XCBC_PRECOMP_KEY_NUM; i++) {
1911 : : if (aes_ipsecmb_job(input, out, m, auth_key, auth_keylen)) {
1912 : : memset(input -
1913 : : (i * ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ),
1914 : : 0, ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ);
1915 : : ret = -EFAULT;
1916 : : goto out;
1917 : : }
1918 : :
1919 : : input += ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ;
1920 : : out += ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ;
1921 : : }
1922 : : *p_state_len = ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ;
1923 : : goto out;
1924 : :
1925 : : } else if ((hash_alg == ICP_QAT_HW_AUTH_ALGO_GALOIS_128) ||
1926 : : (hash_alg == ICP_QAT_HW_AUTH_ALGO_GALOIS_64)) {
1927 : : uint8_t *out = p_state_buf;
1928 : :
1929 : : memset(p_state_buf, 0, ICP_QAT_HW_GALOIS_H_SZ +
1930 : : ICP_QAT_HW_GALOIS_LEN_A_SZ +
1931 : : ICP_QAT_HW_GALOIS_E_CTR0_SZ);
1932 : : if (aes_ipsecmb_job(in, out, m, auth_key, auth_keylen)) {
1933 : : ret = -EFAULT;
1934 : : goto out;
1935 : : }
1936 : :
1937 : : *p_state_len = ICP_QAT_HW_GALOIS_H_SZ +
1938 : : ICP_QAT_HW_GALOIS_LEN_A_SZ +
1939 : : ICP_QAT_HW_GALOIS_E_CTR0_SZ;
1940 : : goto out;
1941 : : }
1942 : :
1943 : : block_size = qat_hash_get_block_size(hash_alg);
1944 : : if (block_size < 0) {
1945 : : free_mb_mgr(m);
1946 : : return block_size;
1947 : : }
1948 : :
1949 : : if (auth_keylen > (unsigned int)block_size) {
1950 : : QAT_LOG(ERR, "invalid keylen %u", auth_keylen);
1951 : : ret = -EFAULT;
1952 : : goto out;
1953 : : }
1954 : : /* init ipad and opad from key and xor with fixed values */
1955 : : memset(ipad, 0, block_size);
1956 : : memset(opad, 0, block_size);
1957 : : RTE_VERIFY(auth_keylen <= sizeof(ipad));
1958 : : RTE_VERIFY(auth_keylen <= sizeof(opad));
1959 : : rte_memcpy(ipad, auth_key, auth_keylen);
1960 : : rte_memcpy(opad, auth_key, auth_keylen);
1961 : :
1962 : : for (i = 0; i < block_size; i++) {
1963 : : uint8_t *ipad_ptr = ipad + i;
1964 : : uint8_t *opad_ptr = opad + i;
1965 : : *ipad_ptr ^= HMAC_IPAD_VALUE;
1966 : : *opad_ptr ^= HMAC_OPAD_VALUE;
1967 : : }
1968 : :
1969 : : /* do partial hash of ipad and copy to state1 */
1970 : : if (partial_hash_compute_ipsec_mb(hash_alg, ipad, p_state_buf, m)) {
1971 : : QAT_LOG(ERR, "ipad precompute failed");
1972 : : ret = -EFAULT;
1973 : : goto out;
1974 : : }
1975 : :
1976 : : /*
1977 : : * State len is a multiple of 8, so may be larger than the digest.
1978 : : * Put the partial hash of opad state_len bytes after state1
1979 : : */
1980 : : *p_state_len = qat_hash_get_state1_size(hash_alg);
1981 : : if (partial_hash_compute_ipsec_mb(hash_alg, opad,
1982 : : p_state_buf + *p_state_len, m)) {
1983 : : QAT_LOG(ERR, "opad precompute failed");
1984 : : ret = -EFAULT;
1985 : : goto out;
1986 : : }
1987 : :
1988 : : out:
1989 : : /* don't leave data lying around */
1990 : : rte_memzero_explicit(ipad, block_size);
1991 : : rte_memzero_explicit(opad, block_size);
1992 : : free_mb_mgr(m);
1993 : : return ret;
1994 : : }
1995 : : #endif
1996 : :
1997 : : static void
1998 : 0 : qat_sym_session_init_common_hdr(struct qat_sym_session *session)
1999 : : {
2000 : : struct icp_qat_fw_la_bulk_req *req_tmpl = &session->fw_req;
2001 : : struct icp_qat_fw_comn_req_hdr *header = &req_tmpl->comn_hdr;
2002 : 0 : enum qat_sym_proto_flag proto_flags = session->qat_proto_flag;
2003 : 0 : uint32_t slice_flags = session->slice_types;
2004 : :
2005 : 0 : header->hdr_flags =
2006 : : ICP_QAT_FW_COMN_HDR_FLAGS_BUILD(ICP_QAT_FW_COMN_REQ_FLAG_SET);
2007 : 0 : header->service_type = ICP_QAT_FW_COMN_REQ_CPM_FW_LA;
2008 : 0 : header->service_cmd_id = session->qat_cmd;
2009 : 0 : header->comn_req_flags =
2010 : : ICP_QAT_FW_COMN_FLAGS_BUILD(QAT_COMN_CD_FLD_TYPE_64BIT_ADR,
2011 : : QAT_COMN_PTR_TYPE_FLAT);
2012 : 0 : ICP_QAT_FW_LA_PARTIAL_SET(header->serv_specif_flags,
2013 : : ICP_QAT_FW_LA_PARTIAL_NONE);
2014 : 0 : ICP_QAT_FW_LA_CIPH_IV_FLD_FLAG_SET(header->serv_specif_flags,
2015 : : ICP_QAT_FW_CIPH_IV_16BYTE_DATA);
2016 : :
2017 [ # # # # : 0 : switch (proto_flags) {
# # ]
2018 : 0 : case QAT_CRYPTO_PROTO_FLAG_NONE:
2019 : 0 : ICP_QAT_FW_LA_PROTO_SET(header->serv_specif_flags,
2020 : : ICP_QAT_FW_LA_NO_PROTO);
2021 : 0 : break;
2022 : 0 : case QAT_CRYPTO_PROTO_FLAG_CCM:
2023 : 0 : ICP_QAT_FW_LA_PROTO_SET(header->serv_specif_flags,
2024 : : ICP_QAT_FW_LA_CCM_PROTO);
2025 : 0 : break;
2026 : 0 : case QAT_CRYPTO_PROTO_FLAG_GCM:
2027 : 0 : ICP_QAT_FW_LA_PROTO_SET(header->serv_specif_flags,
2028 : : ICP_QAT_FW_LA_GCM_PROTO);
2029 : 0 : break;
2030 : 0 : case QAT_CRYPTO_PROTO_FLAG_SNOW3G:
2031 : 0 : ICP_QAT_FW_LA_PROTO_SET(header->serv_specif_flags,
2032 : : ICP_QAT_FW_LA_SNOW_3G_PROTO);
2033 : 0 : break;
2034 : 0 : case QAT_CRYPTO_PROTO_FLAG_ZUC:
2035 : 0 : ICP_QAT_FW_LA_ZUC_3G_PROTO_FLAG_SET(header->serv_specif_flags,
2036 : : ICP_QAT_FW_LA_ZUC_3G_PROTO);
2037 : 0 : break;
2038 : : }
2039 : :
2040 : : /* More than one of the following flags can be set at once */
2041 [ # # ]: 0 : if (QAT_SESSION_IS_SLICE_SET(slice_flags, QAT_CRYPTO_SLICE_SPC)) {
2042 : 0 : ICP_QAT_FW_LA_SINGLE_PASS_PROTO_FLAG_SET(
2043 : : header->serv_specif_flags,
2044 : : ICP_QAT_FW_LA_SINGLE_PASS_PROTO);
2045 : : }
2046 [ # # ]: 0 : if (QAT_SESSION_IS_SLICE_SET(slice_flags, QAT_CRYPTO_SLICE_UCS)) {
2047 : 0 : ICP_QAT_FW_LA_SLICE_TYPE_SET(
2048 : : header->serv_specif_flags,
2049 : : ICP_QAT_FW_LA_USE_UCS_SLICE_TYPE);
2050 : : }
2051 : :
2052 [ # # ]: 0 : if (session->is_auth) {
2053 [ # # ]: 0 : if (session->auth_op == ICP_QAT_HW_AUTH_VERIFY) {
2054 : 0 : ICP_QAT_FW_LA_RET_AUTH_SET(header->serv_specif_flags,
2055 : : ICP_QAT_FW_LA_NO_RET_AUTH_RES);
2056 : 0 : ICP_QAT_FW_LA_CMP_AUTH_SET(header->serv_specif_flags,
2057 : : ICP_QAT_FW_LA_CMP_AUTH_RES);
2058 [ # # ]: 0 : } else if (session->auth_op == ICP_QAT_HW_AUTH_GENERATE) {
2059 : 0 : ICP_QAT_FW_LA_RET_AUTH_SET(header->serv_specif_flags,
2060 : : ICP_QAT_FW_LA_RET_AUTH_RES);
2061 : 0 : ICP_QAT_FW_LA_CMP_AUTH_SET(header->serv_specif_flags,
2062 : : ICP_QAT_FW_LA_NO_CMP_AUTH_RES);
2063 : : }
2064 : : } else {
2065 : 0 : ICP_QAT_FW_LA_RET_AUTH_SET(header->serv_specif_flags,
2066 : : ICP_QAT_FW_LA_NO_RET_AUTH_RES);
2067 : 0 : ICP_QAT_FW_LA_CMP_AUTH_SET(header->serv_specif_flags,
2068 : : ICP_QAT_FW_LA_NO_CMP_AUTH_RES);
2069 : : }
2070 : :
2071 [ # # ]: 0 : if (session->is_iv12B) {
2072 : 0 : ICP_QAT_FW_LA_GCM_IV_LEN_FLAG_SET(
2073 : : header->serv_specif_flags,
2074 : : ICP_QAT_FW_LA_GCM_IV_LEN_12_OCTETS);
2075 : : }
2076 : :
2077 : 0 : ICP_QAT_FW_LA_UPDATE_STATE_SET(header->serv_specif_flags,
2078 : : ICP_QAT_FW_LA_NO_UPDATE_STATE);
2079 : 0 : ICP_QAT_FW_LA_DIGEST_IN_BUFFER_SET(header->serv_specif_flags,
2080 : : ICP_QAT_FW_LA_NO_DIGEST_IN_BUFFER);
2081 : 0 : }
2082 : :
2083 : : static void
2084 : : qat_sym_session_init_gen_lce_hdr(struct qat_sym_session *session)
2085 : : {
2086 : : struct icp_qat_fw_la_bulk_req *req_tmpl = &session->fw_req;
2087 : : struct icp_qat_fw_comn_req_hdr *header = &req_tmpl->comn_hdr;
2088 : :
2089 : : /*
2090 : : * GEN_LCE specifies separate command id for AEAD operations but Cryptodev
2091 : : * API processes AEAD operations as Single pass Crypto operations.
2092 : : * Hence even for GEN_LCE, Session Algo Command ID is CIPHER.
2093 : : * Note, however Session Algo Mode is AEAD.
2094 : : */
2095 : 0 : header->service_cmd_id = ICP_QAT_FW_LA_CMD_AEAD;
2096 : 0 : header->service_type = ICP_QAT_FW_COMN_REQ_CPM_FW_LA;
2097 : 0 : header->hdr_flags = ICP_QAT_FW_COMN_HDR_FLAGS_BUILD_GEN_LCE(ICP_QAT_FW_COMN_REQ_FLAG_SET,
2098 : : ICP_QAT_FW_COMN_GEN_LCE_DESC_LAYOUT);
2099 : 0 : header->comn_req_flags = ICP_QAT_FW_COMN_FLAGS_BUILD_GEN_LCE(QAT_COMN_PTR_TYPE_SGL,
2100 : : QAT_COMN_KEY_BUFFER_USED);
2101 : :
2102 : 0 : ICP_QAT_FW_SYM_AEAD_ALGO_SET(header->serv_specif_flags, QAT_LA_CRYPTO_AEAD_AES_GCM_GEN_LCE);
2103 : 0 : ICP_QAT_FW_SYM_IV_SIZE_SET(header->serv_specif_flags, ICP_QAT_FW_LA_GCM_IV_LEN_12_OCTETS);
2104 : : ICP_QAT_FW_SYM_IV_IN_DESC_FLAG_SET(header->serv_specif_flags,
2105 : : ICP_QAT_FW_SYM_IV_IN_DESC_VALID);
2106 : :
2107 [ # # ]: 0 : if (session->qat_dir == ICP_QAT_HW_CIPHER_DECRYPT) {
2108 : 0 : ICP_QAT_FW_SYM_DIR_FLAG_SET(header->serv_specif_flags, ICP_QAT_HW_CIPHER_DECRYPT);
2109 : : } else {
2110 : 0 : ICP_QAT_FW_SYM_DIR_FLAG_SET(header->serv_specif_flags, ICP_QAT_HW_CIPHER_ENCRYPT);
2111 : : }
2112 : : }
2113 : :
2114 : 0 : int qat_sym_cd_cipher_set(struct qat_sym_session *cdesc,
2115 : : const uint8_t *cipherkey,
2116 : : uint32_t cipherkeylen)
2117 : : {
2118 : : struct icp_qat_hw_cipher_algo_blk *cipher;
2119 : : struct icp_qat_hw_cipher_algo_blk20 *cipher20;
2120 : : struct icp_qat_fw_la_bulk_req *req_tmpl = &cdesc->fw_req;
2121 : : struct icp_qat_fw_comn_req_hdr_cd_pars *cd_pars = &req_tmpl->cd_pars;
2122 : : struct icp_qat_fw_comn_req_hdr *header = &req_tmpl->comn_hdr;
2123 : : void *ptr = &req_tmpl->cd_ctrl;
2124 : : struct icp_qat_fw_cipher_cd_ctrl_hdr *cipher_cd_ctrl = ptr;
2125 : : struct icp_qat_fw_auth_cd_ctrl_hdr *hash_cd_ctrl = ptr;
2126 : : enum icp_qat_hw_cipher_convert key_convert;
2127 : : struct icp_qat_fw_la_cipher_20_req_params *req_ucs =
2128 : : (struct icp_qat_fw_la_cipher_20_req_params *)
2129 : : &cdesc->fw_req.serv_specif_rqpars;
2130 : : struct icp_qat_fw_la_cipher_req_params *req_cipher =
2131 : : (struct icp_qat_fw_la_cipher_req_params *)
2132 : : &cdesc->fw_req.serv_specif_rqpars;
2133 : : uint32_t total_key_size;
2134 : : uint16_t cipher_offset, cd_size;
2135 : : uint32_t wordIndex = 0;
2136 : : uint32_t *temp_key = NULL;
2137 : :
2138 [ # # ]: 0 : if (cdesc->qat_cmd == ICP_QAT_FW_LA_CMD_CIPHER) {
2139 : 0 : cd_pars->u.s.content_desc_addr = cdesc->cd_paddr;
2140 : : ICP_QAT_FW_COMN_CURR_ID_SET(cipher_cd_ctrl,
2141 : : ICP_QAT_FW_SLICE_CIPHER);
2142 : 0 : ICP_QAT_FW_COMN_NEXT_ID_SET(cipher_cd_ctrl,
2143 : : ICP_QAT_FW_SLICE_DRAM_WR);
2144 : 0 : ICP_QAT_FW_LA_RET_AUTH_SET(header->serv_specif_flags,
2145 : : ICP_QAT_FW_LA_NO_RET_AUTH_RES);
2146 : 0 : ICP_QAT_FW_LA_CMP_AUTH_SET(header->serv_specif_flags,
2147 : : ICP_QAT_FW_LA_NO_CMP_AUTH_RES);
2148 : 0 : cdesc->cd_cur_ptr = (uint8_t *)&cdesc->cd;
2149 [ # # ]: 0 : } else if (cdesc->qat_cmd == ICP_QAT_FW_LA_CMD_CIPHER_HASH) {
2150 : 0 : cd_pars->u.s.content_desc_addr = cdesc->cd_paddr;
2151 : : ICP_QAT_FW_COMN_CURR_ID_SET(cipher_cd_ctrl,
2152 : : ICP_QAT_FW_SLICE_CIPHER);
2153 : 0 : ICP_QAT_FW_COMN_NEXT_ID_SET(cipher_cd_ctrl,
2154 : : ICP_QAT_FW_SLICE_AUTH);
2155 : : ICP_QAT_FW_COMN_CURR_ID_SET(hash_cd_ctrl,
2156 : : ICP_QAT_FW_SLICE_AUTH);
2157 : 0 : ICP_QAT_FW_COMN_NEXT_ID_SET(hash_cd_ctrl,
2158 : : ICP_QAT_FW_SLICE_DRAM_WR);
2159 : 0 : cdesc->cd_cur_ptr = (uint8_t *)&cdesc->cd;
2160 [ # # ]: 0 : } else if (cdesc->qat_cmd == ICP_QAT_FW_LA_CMD_CIPHER_CRC) {
2161 : 0 : cd_pars->u.s.content_desc_addr = cdesc->cd_paddr;
2162 : 0 : cdesc->cd_cur_ptr = (uint8_t *)&cdesc->cd;
2163 [ # # ]: 0 : } else if (cdesc->qat_cmd != ICP_QAT_FW_LA_CMD_HASH_CIPHER) {
2164 : 0 : QAT_LOG(ERR, "Invalid param, must be a cipher command.");
2165 : 0 : return -EFAULT;
2166 : : }
2167 : :
2168 [ # # ]: 0 : if (cdesc->qat_mode == ICP_QAT_HW_CIPHER_CTR_MODE) {
2169 : : /*
2170 : : * CTR Streaming ciphers are a special case. Decrypt = encrypt
2171 : : * Overriding default values previously set.
2172 : : * Chacha20-Poly1305 is special case, CTR but single-pass
2173 : : * so both direction need to be used.
2174 : : */
2175 : 0 : cdesc->qat_dir = ICP_QAT_HW_CIPHER_ENCRYPT;
2176 [ # # ]: 0 : if (cdesc->qat_cipher_alg ==
2177 : 0 : ICP_QAT_HW_CIPHER_ALGO_CHACHA20_POLY1305 &&
2178 [ # # ]: 0 : cdesc->auth_op == ICP_QAT_HW_AUTH_VERIFY) {
2179 : 0 : cdesc->qat_dir = ICP_QAT_HW_CIPHER_DECRYPT;
2180 : : }
2181 : : key_convert = ICP_QAT_HW_CIPHER_NO_CONVERT;
2182 : 0 : } else if (cdesc->qat_cipher_alg == ICP_QAT_HW_CIPHER_ALGO_SNOW_3G_UEA2
2183 : : || cdesc->qat_cipher_alg ==
2184 : : ICP_QAT_HW_CIPHER_ALGO_ZUC_3G_128_EEA3
2185 [ # # ]: 0 : || cdesc->qat_cipher_alg == ICP_QAT_HW_CIPHER_ALGO_ZUC_256) {
2186 : : key_convert = ICP_QAT_HW_CIPHER_KEY_CONVERT;
2187 : 0 : cdesc->qat_dir = ICP_QAT_HW_CIPHER_ENCRYPT;
2188 [ # # ]: 0 : } else if (cdesc->qat_dir == ICP_QAT_HW_CIPHER_ENCRYPT)
2189 : : key_convert = ICP_QAT_HW_CIPHER_NO_CONVERT;
2190 [ # # ]: 0 : else if (cdesc->qat_mode == ICP_QAT_HW_CIPHER_AEAD_MODE)
2191 : : key_convert = ICP_QAT_HW_CIPHER_NO_CONVERT;
2192 : : else
2193 : : key_convert = ICP_QAT_HW_CIPHER_KEY_CONVERT;
2194 : :
2195 [ # # ]: 0 : if (cdesc->qat_cipher_alg == ICP_QAT_HW_CIPHER_ALGO_SNOW_3G_UEA2) {
2196 : : total_key_size = ICP_QAT_HW_SNOW_3G_UEA2_KEY_SZ +
2197 : : ICP_QAT_HW_SNOW_3G_UEA2_IV_SZ;
2198 : 0 : cipher_cd_ctrl->cipher_state_sz =
2199 : : ICP_QAT_HW_SNOW_3G_UEA2_IV_SZ >> 3;
2200 : 0 : cdesc->qat_proto_flag = QAT_CRYPTO_PROTO_FLAG_SNOW3G;
2201 : :
2202 : : } else if (cdesc->qat_cipher_alg == ICP_QAT_HW_CIPHER_ALGO_KASUMI) {
2203 : : total_key_size = ICP_QAT_HW_KASUMI_F8_KEY_SZ;
2204 : 0 : cipher_cd_ctrl->cipher_state_sz = ICP_QAT_HW_KASUMI_BLK_SZ >> 3;
2205 : 0 : cipher_cd_ctrl->cipher_padding_sz =
2206 : : (2 * ICP_QAT_HW_KASUMI_BLK_SZ) >> 3;
2207 : : } else if (cdesc->qat_cipher_alg == ICP_QAT_HW_CIPHER_ALGO_3DES) {
2208 : : total_key_size = ICP_QAT_HW_3DES_KEY_SZ;
2209 : 0 : cipher_cd_ctrl->cipher_state_sz = ICP_QAT_HW_3DES_BLK_SZ >> 3;
2210 : : } else if (cdesc->qat_cipher_alg == ICP_QAT_HW_CIPHER_ALGO_DES) {
2211 : : total_key_size = ICP_QAT_HW_DES_KEY_SZ;
2212 : 0 : cipher_cd_ctrl->cipher_state_sz = ICP_QAT_HW_DES_BLK_SZ >> 3;
2213 : : } else if (cdesc->qat_cipher_alg ==
2214 : : ICP_QAT_HW_CIPHER_ALGO_ZUC_3G_128_EEA3) {
2215 : : total_key_size = ICP_QAT_HW_ZUC_3G_EEA3_KEY_SZ +
2216 : : ICP_QAT_HW_ZUC_3G_EEA3_IV_SZ;
2217 : 0 : cipher_cd_ctrl->cipher_state_sz =
2218 : : ICP_QAT_HW_ZUC_3G_EEA3_IV_SZ >> 3;
2219 : 0 : cdesc->qat_proto_flag = QAT_CRYPTO_PROTO_FLAG_ZUC;
2220 : : } else if (cdesc->qat_cipher_alg ==
2221 : : ICP_QAT_HW_CIPHER_ALGO_ZUC_256) {
2222 [ # # ]: 0 : if (cdesc->cipher_iv.length != ICP_QAT_HW_ZUC_256_IV_SZ) {
2223 : 0 : QAT_LOG(ERR, "Invalid IV length for ZUC256");
2224 : 0 : return -EINVAL;
2225 : : }
2226 : : total_key_size = ICP_QAT_HW_ZUC_256_KEY_SZ +
2227 : : ICP_QAT_HW_ZUC_256_IV_SZ;
2228 : 0 : cipher_cd_ctrl->cipher_state_sz =
2229 : : ICP_QAT_HW_ZUC_256_IV_SZ >> 3;
2230 : 0 : cdesc->qat_proto_flag = QAT_CRYPTO_PROTO_FLAG_ZUC;
2231 : : } else {
2232 : : total_key_size = cipherkeylen;
2233 : 0 : cipher_cd_ctrl->cipher_state_sz = ICP_QAT_HW_AES_BLK_SZ >> 3;
2234 : : }
2235 : 0 : cipher_offset = cdesc->cd_cur_ptr-((uint8_t *)&cdesc->cd);
2236 : 0 : cipher_cd_ctrl->cipher_cfg_offset = cipher_offset >> 3;
2237 : :
2238 : : cipher = (struct icp_qat_hw_cipher_algo_blk *)cdesc->cd_cur_ptr;
2239 : : cipher20 = (struct icp_qat_hw_cipher_algo_blk20 *)cdesc->cd_cur_ptr;
2240 : 0 : cipher->cipher_config.val =
2241 : 0 : ICP_QAT_HW_CIPHER_CONFIG_BUILD(cdesc->qat_mode,
2242 : : cdesc->qat_cipher_alg, key_convert,
2243 : : cdesc->qat_dir);
2244 : :
2245 [ # # ]: 0 : if (cdesc->qat_cipher_alg == ICP_QAT_HW_CIPHER_ALGO_KASUMI) {
2246 : 0 : temp_key = (uint32_t *)(cdesc->cd_cur_ptr +
2247 : : sizeof(struct icp_qat_hw_cipher_config)
2248 : 0 : + cipherkeylen);
2249 : 0 : memcpy(cipher->key, cipherkey, cipherkeylen);
2250 : : memcpy(temp_key, cipherkey, cipherkeylen);
2251 : :
2252 : : /* XOR Key with KASUMI F8 key modifier at 4 bytes level */
2253 [ # # ]: 0 : for (wordIndex = 0; wordIndex < (cipherkeylen >> 2);
2254 : 0 : wordIndex++)
2255 : 0 : temp_key[wordIndex] ^= KASUMI_F8_KEY_MODIFIER_4_BYTES;
2256 : :
2257 : 0 : cdesc->cd_cur_ptr += sizeof(struct icp_qat_hw_cipher_config) +
2258 : 0 : cipherkeylen + cipherkeylen;
2259 [ # # ]: 0 : } else if (cdesc->is_ucs) {
2260 : : const uint8_t *final_key = cipherkey;
2261 : :
2262 : 0 : cdesc->slice_types |= QAT_CRYPTO_SLICE_UCS;
2263 : 0 : total_key_size = RTE_ALIGN_CEIL(cipherkeylen,
2264 : : ICP_QAT_HW_AES_128_KEY_SZ);
2265 : 0 : cipher20->cipher_config.reserved[0] = 0;
2266 : 0 : cipher20->cipher_config.reserved[1] = 0;
2267 : 0 : cipher20->cipher_config.reserved[2] = 0;
2268 : :
2269 [ # # ]: 0 : rte_memcpy(cipher20->key, final_key, cipherkeylen);
2270 : 0 : cdesc->cd_cur_ptr +=
2271 : 0 : sizeof(struct icp_qat_hw_ucs_cipher_config) +
2272 : : cipherkeylen;
2273 : : } else {
2274 : 0 : memcpy(cipher->key, cipherkey, cipherkeylen);
2275 : 0 : cdesc->cd_cur_ptr += sizeof(struct icp_qat_hw_cipher_config) +
2276 : : cipherkeylen;
2277 : : }
2278 : :
2279 [ # # ]: 0 : if (cdesc->is_single_pass) {
2280 : 0 : QAT_FIELD_SET(cipher->cipher_config.val,
2281 : : cdesc->digest_length,
2282 : : QAT_CIPHER_AEAD_HASH_CMP_LEN_BITPOS,
2283 : : QAT_CIPHER_AEAD_HASH_CMP_LEN_MASK);
2284 : : /* UCS and SPC 1.8/2.0 share configuration of 2nd config word */
2285 : 0 : cdesc->cd.cipher.cipher_config.reserved =
2286 : 0 : ICP_QAT_HW_CIPHER_CONFIG_BUILD_UPPER(
2287 : : cdesc->aad_len);
2288 : 0 : cdesc->slice_types |= QAT_CRYPTO_SLICE_SPC;
2289 : : }
2290 : :
2291 [ # # ]: 0 : if (total_key_size > cipherkeylen) {
2292 : 0 : uint32_t padding_size = total_key_size-cipherkeylen;
2293 [ # # ]: 0 : if ((cdesc->qat_cipher_alg == ICP_QAT_HW_CIPHER_ALGO_3DES)
2294 [ # # ]: 0 : && (cipherkeylen == QAT_3DES_KEY_SZ_OPT2)) {
2295 : : /* K3 not provided so use K1 = K3*/
2296 : 0 : memcpy(cdesc->cd_cur_ptr, cipherkey, padding_size);
2297 [ # # ]: 0 : } else if ((cdesc->qat_cipher_alg == ICP_QAT_HW_CIPHER_ALGO_3DES)
2298 [ # # ]: 0 : && (cipherkeylen == QAT_3DES_KEY_SZ_OPT3)) {
2299 : : /* K2 and K3 not provided so use K1 = K2 = K3*/
2300 : 0 : memcpy(cdesc->cd_cur_ptr, cipherkey,
2301 : : cipherkeylen);
2302 : 0 : memcpy(cdesc->cd_cur_ptr+cipherkeylen,
2303 : : cipherkey, cipherkeylen);
2304 : : } else
2305 : 0 : memset(cdesc->cd_cur_ptr, 0, padding_size);
2306 : :
2307 : 0 : cdesc->cd_cur_ptr += padding_size;
2308 : : }
2309 [ # # ]: 0 : if (cdesc->is_ucs) {
2310 : : /*
2311 : : * These values match in terms of position auth
2312 : : * slice request fields
2313 : : */
2314 : 0 : req_ucs->spc_auth_res_sz = cdesc->digest_length;
2315 [ # # ]: 0 : if (!cdesc->is_gmac) {
2316 : 0 : req_ucs->spc_aad_sz = cdesc->aad_len;
2317 : 0 : req_ucs->spc_aad_offset = 0;
2318 : : }
2319 [ # # ]: 0 : } else if (cdesc->is_single_pass) {
2320 : 0 : req_cipher->spc_aad_sz = cdesc->aad_len;
2321 : 0 : req_cipher->spc_auth_res_sz = cdesc->digest_length;
2322 : : }
2323 : 0 : cd_size = cdesc->cd_cur_ptr-(uint8_t *)&cdesc->cd;
2324 : 0 : cd_pars->u.s.content_desc_params_sz = RTE_ALIGN_CEIL(cd_size, 8) >> 3;
2325 : 0 : cipher_cd_ctrl->cipher_key_sz = total_key_size >> 3;
2326 : :
2327 : 0 : return 0;
2328 : : }
2329 : :
2330 : 0 : static int qat_sym_cd_auth_set(struct qat_sym_session *cdesc,
2331 : : const uint8_t *authkey,
2332 : : uint32_t authkeylen,
2333 : : uint32_t aad_length,
2334 : : uint32_t digestsize,
2335 : : unsigned int operation,
2336 : : enum qat_device_gen qat_dev_gen)
2337 : : {
2338 : : struct icp_qat_hw_auth_setup *hash, *hash_2 = NULL;
2339 : : struct icp_qat_hw_cipher_algo_blk *cipherconfig;
2340 : : struct icp_qat_fw_la_bulk_req *req_tmpl = &cdesc->fw_req;
2341 : : struct icp_qat_fw_comn_req_hdr_cd_pars *cd_pars = &req_tmpl->cd_pars;
2342 : : void *ptr = &req_tmpl->cd_ctrl;
2343 : : struct icp_qat_fw_cipher_cd_ctrl_hdr *cipher_cd_ctrl = ptr;
2344 : : struct icp_qat_fw_auth_cd_ctrl_hdr *hash_cd_ctrl = ptr;
2345 : : struct icp_qat_fw_la_auth_req_params *auth_param =
2346 : : (struct icp_qat_fw_la_auth_req_params *)
2347 : : ((char *)&req_tmpl->serv_specif_rqpars +
2348 : : ICP_QAT_FW_HASH_REQUEST_PARAMETERS_OFFSET);
2349 : 0 : uint16_t state1_size = 0, state2_size = 0, cd_extra_size = 0;
2350 : : uint16_t hash_offset, cd_size;
2351 : : uint32_t *aad_len = NULL;
2352 : : uint32_t wordIndex = 0;
2353 : : uint32_t *pTempKey;
2354 : : uint8_t *prefix = NULL;
2355 : : int ret = 0;
2356 : :
2357 [ # # ]: 0 : if (cdesc->qat_cmd == ICP_QAT_FW_LA_CMD_AUTH) {
2358 : : ICP_QAT_FW_COMN_CURR_ID_SET(hash_cd_ctrl,
2359 : : ICP_QAT_FW_SLICE_AUTH);
2360 : 0 : ICP_QAT_FW_COMN_NEXT_ID_SET(hash_cd_ctrl,
2361 : : ICP_QAT_FW_SLICE_DRAM_WR);
2362 : 0 : cdesc->cd_cur_ptr = (uint8_t *)&cdesc->cd;
2363 [ # # ]: 0 : } else if (cdesc->qat_cmd == ICP_QAT_FW_LA_CMD_HASH_CIPHER) {
2364 : : ICP_QAT_FW_COMN_CURR_ID_SET(hash_cd_ctrl,
2365 : : ICP_QAT_FW_SLICE_AUTH);
2366 : 0 : ICP_QAT_FW_COMN_NEXT_ID_SET(hash_cd_ctrl,
2367 : : ICP_QAT_FW_SLICE_CIPHER);
2368 : : ICP_QAT_FW_COMN_CURR_ID_SET(cipher_cd_ctrl,
2369 : : ICP_QAT_FW_SLICE_CIPHER);
2370 : 0 : ICP_QAT_FW_COMN_NEXT_ID_SET(cipher_cd_ctrl,
2371 : : ICP_QAT_FW_SLICE_DRAM_WR);
2372 : 0 : cdesc->cd_cur_ptr = (uint8_t *)&cdesc->cd;
2373 [ # # ]: 0 : } else if (cdesc->qat_cmd != ICP_QAT_FW_LA_CMD_CIPHER_HASH) {
2374 : 0 : QAT_LOG(ERR, "Invalid param, must be a hash command.");
2375 : 0 : return -EFAULT;
2376 : : }
2377 : :
2378 [ # # ]: 0 : if (operation == RTE_CRYPTO_AUTH_OP_VERIFY)
2379 : 0 : cdesc->auth_op = ICP_QAT_HW_AUTH_VERIFY;
2380 : : else
2381 : 0 : cdesc->auth_op = ICP_QAT_HW_AUTH_GENERATE;
2382 : :
2383 : : /*
2384 : : * Setup the inner hash config
2385 : : */
2386 : 0 : hash_offset = cdesc->cd_cur_ptr-((uint8_t *)&cdesc->cd);
2387 : : hash = (struct icp_qat_hw_auth_setup *)cdesc->cd_cur_ptr;
2388 : 0 : hash->auth_config.reserved = 0;
2389 [ # # ]: 0 : if (cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_NULL)
2390 : 0 : hash->auth_config.config =
2391 : 0 : ICP_QAT_HW_AUTH_CONFIG_BUILD(cdesc->auth_mode,
2392 : : cdesc->qat_hash_alg, 4);
2393 : : else
2394 : 0 : hash->auth_config.config =
2395 : 0 : ICP_QAT_HW_AUTH_CONFIG_BUILD(cdesc->auth_mode,
2396 : : cdesc->qat_hash_alg, digestsize);
2397 : :
2398 [ # # ]: 0 : if (cdesc->auth_mode == ICP_QAT_HW_AUTH_MODE0
2399 : : || cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_SNOW_3G_UIA2
2400 : : || cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_KASUMI_F9
2401 : : || cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_ZUC_3G_128_EIA3
2402 : : || cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_ZUC_256_MAC_32
2403 : : || cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_ZUC_256_MAC_64
2404 : : || cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_ZUC_256_MAC_128
2405 : : || cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_AES_XCBC_MAC
2406 : : || cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_AES_128_CMAC
2407 : : || cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_AES_CBC_MAC
2408 : : || cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_NULL
2409 : : || cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_SM3
2410 [ # # ]: 0 : || cdesc->is_cnt_zero
2411 : : )
2412 : 0 : hash->auth_counter.counter = 0;
2413 : : else {
2414 : 0 : int block_size = qat_hash_get_block_size(cdesc->qat_hash_alg);
2415 : :
2416 [ # # ]: 0 : if (block_size < 0)
2417 : : return block_size;
2418 [ # # ]: 0 : hash->auth_counter.counter = rte_bswap32(block_size);
2419 : : }
2420 : :
2421 : 0 : hash_cd_ctrl->hash_cfg_offset = hash_offset >> 3;
2422 : 0 : cdesc->cd_cur_ptr += sizeof(struct icp_qat_hw_auth_setup);
2423 [ # # # # : 0 : switch (cdesc->qat_hash_alg) {
# # # # #
# # # # #
# # # # #
# # ]
2424 [ # # ]: 0 : case ICP_QAT_HW_AUTH_ALGO_SM3:
2425 : : rte_memcpy(cdesc->cd_cur_ptr, sm3InitialState,
2426 : : sizeof(sm3InitialState));
2427 : 0 : state1_size = qat_hash_get_state1_size(
2428 : : cdesc->qat_hash_alg);
2429 : 0 : state2_size = ICP_QAT_HW_SM3_STATE2_SZ;
2430 [ # # ]: 0 : if (cdesc->auth_mode == ICP_QAT_HW_AUTH_MODE0)
2431 : : break;
2432 : 0 : hash_2 = (struct icp_qat_hw_auth_setup *)(cdesc->cd_cur_ptr +
2433 : 0 : state1_size + state2_size);
2434 : 0 : hash_2->auth_config.config =
2435 : 0 : ICP_QAT_HW_AUTH_CONFIG_BUILD(ICP_QAT_HW_AUTH_MODE2,
2436 : : cdesc->qat_hash_alg, digestsize);
2437 [ # # ]: 0 : rte_memcpy(cdesc->cd_cur_ptr + state1_size + state2_size +
2438 : : sizeof(*hash_2), sm3InitialState,
2439 : : sizeof(sm3InitialState));
2440 : 0 : hash_cd_ctrl->inner_state1_sz = state1_size;
2441 : 0 : hash_cd_ctrl->inner_state2_sz = state2_size;
2442 : 0 : hash_cd_ctrl->inner_state2_offset =
2443 : 0 : hash_cd_ctrl->hash_cfg_offset +
2444 : 0 : ((sizeof(struct icp_qat_hw_auth_setup) +
2445 : 0 : RTE_ALIGN_CEIL(hash_cd_ctrl->inner_state1_sz, 8)) >> 3);
2446 : 0 : hash_cd_ctrl->outer_config_offset =
2447 : 0 : hash_cd_ctrl->inner_state2_offset +
2448 : : ((hash_cd_ctrl->inner_state2_sz) >> 3);
2449 : 0 : hash_cd_ctrl->outer_state1_sz = state1_size;
2450 : 0 : hash_cd_ctrl->outer_res_sz = state2_size;
2451 : 0 : hash_cd_ctrl->outer_prefix_sz =
2452 : 0 : qat_hash_get_block_size(cdesc->qat_hash_alg);
2453 : 0 : hash_cd_ctrl->outer_prefix_offset =
2454 : 0 : qat_hash_get_block_size(cdesc->qat_hash_alg) >> 3;
2455 : 0 : auth_param->u2.inner_prefix_sz =
2456 : 0 : qat_hash_get_block_size(cdesc->qat_hash_alg);
2457 : 0 : auth_param->hash_state_sz = (hash_cd_ctrl->outer_prefix_sz +
2458 : 0 : auth_param->u2.inner_prefix_sz) >> 3;
2459 : 0 : if (qat_dev_gen == QAT_GEN4 || qat_dev_gen == QAT_GEN5 ||
2460 [ # # ]: 0 : qat_dev_gen == QAT_VQAT) {
2461 : 0 : ICP_QAT_FW_HASH_FLAG_MODE2_SET(
2462 : : hash_cd_ctrl->hash_flags,
2463 : : QAT_FW_LA_MODE2);
2464 : : } else {
2465 : 0 : hash_cd_ctrl->hash_flags |=
2466 : : ICP_QAT_FW_AUTH_HDR_FLAG_DO_NESTED;
2467 : : }
2468 : 0 : prefix = cdesc->prefix_state;
2469 [ # # ]: 0 : rte_memcpy(prefix, authkey, authkeylen);
2470 [ # # ]: 0 : rte_memcpy(prefix + QAT_PREFIX_SIZE, authkey,
2471 : : authkeylen);
2472 : 0 : cd_extra_size += sizeof(struct icp_qat_hw_auth_setup) +
2473 : 0 : state1_size + state2_size;
2474 : 0 : break;
2475 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA1:
2476 [ # # ]: 0 : if (cdesc->auth_mode == ICP_QAT_HW_AUTH_MODE0) {
2477 : : /* Plain SHA-1 */
2478 : : rte_memcpy(cdesc->cd_cur_ptr, sha1InitialState,
2479 : : sizeof(sha1InitialState));
2480 : 0 : state1_size = qat_hash_get_state1_size(
2481 : : cdesc->qat_hash_alg);
2482 : 0 : break;
2483 : : }
2484 : : /* SHA-1 HMAC */
2485 : : #ifdef RTE_QAT_OPENSSL
2486 : 0 : ret = qat_sym_do_precomputes(ICP_QAT_HW_AUTH_ALGO_SHA1, authkey,
2487 : : authkeylen, cdesc->cd_cur_ptr, &state1_size,
2488 : 0 : cdesc->aes_cmac);
2489 : :
2490 : : #else
2491 : : ret = qat_sym_do_precomputes_ipsec_mb(ICP_QAT_HW_AUTH_ALGO_SHA1,
2492 : : authkey, authkeylen, cdesc->cd_cur_ptr, &state1_size,
2493 : : cdesc->aes_cmac);
2494 : : #endif
2495 : :
2496 [ # # ]: 0 : if (ret) {
2497 : 0 : QAT_LOG(ERR, "(SHA)precompute failed");
2498 : 0 : return -EFAULT;
2499 : : }
2500 : 0 : state2_size = RTE_ALIGN_CEIL(ICP_QAT_HW_SHA1_STATE2_SZ, 8);
2501 : 0 : break;
2502 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA224:
2503 [ # # ]: 0 : if (cdesc->auth_mode == ICP_QAT_HW_AUTH_MODE0) {
2504 : : /* Plain SHA-224 */
2505 : : rte_memcpy(cdesc->cd_cur_ptr, sha224InitialState,
2506 : : sizeof(sha224InitialState));
2507 : 0 : state1_size = qat_hash_get_state1_size(
2508 : : cdesc->qat_hash_alg);
2509 : 0 : break;
2510 : : }
2511 : : /* SHA-224 HMAC */
2512 : : #ifdef RTE_QAT_OPENSSL
2513 : 0 : ret = qat_sym_do_precomputes(ICP_QAT_HW_AUTH_ALGO_SHA224, authkey,
2514 : : authkeylen, cdesc->cd_cur_ptr, &state1_size,
2515 : 0 : cdesc->aes_cmac);
2516 : : #else
2517 : : ret = qat_sym_do_precomputes_ipsec_mb(ICP_QAT_HW_AUTH_ALGO_SHA224,
2518 : : authkey, authkeylen, cdesc->cd_cur_ptr, &state1_size,
2519 : : cdesc->aes_cmac);
2520 : : #endif
2521 [ # # ]: 0 : if (ret) {
2522 : 0 : QAT_LOG(ERR, "(SHA)precompute failed");
2523 : 0 : return -EFAULT;
2524 : : }
2525 : 0 : state2_size = ICP_QAT_HW_SHA224_STATE2_SZ;
2526 : 0 : break;
2527 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA256:
2528 [ # # ]: 0 : if (cdesc->auth_mode == ICP_QAT_HW_AUTH_MODE0) {
2529 : : /* Plain SHA-256 */
2530 : : rte_memcpy(cdesc->cd_cur_ptr, sha256InitialState,
2531 : : sizeof(sha256InitialState));
2532 : 0 : state1_size = qat_hash_get_state1_size(
2533 : : cdesc->qat_hash_alg);
2534 : 0 : break;
2535 : : }
2536 : : /* SHA-256 HMAC */
2537 : : #ifdef RTE_QAT_OPENSSL
2538 : 0 : ret = qat_sym_do_precomputes(ICP_QAT_HW_AUTH_ALGO_SHA256, authkey,
2539 : : authkeylen, cdesc->cd_cur_ptr, &state1_size,
2540 : 0 : cdesc->aes_cmac);
2541 : : #else
2542 : : ret = qat_sym_do_precomputes_ipsec_mb(ICP_QAT_HW_AUTH_ALGO_SHA256,
2543 : : authkey, authkeylen, cdesc->cd_cur_ptr, &state1_size,
2544 : : cdesc->aes_cmac);
2545 : : #endif
2546 [ # # ]: 0 : if (ret) {
2547 : 0 : QAT_LOG(ERR, "(SHA)precompute failed");
2548 : 0 : return -EFAULT;
2549 : : }
2550 : 0 : state2_size = ICP_QAT_HW_SHA256_STATE2_SZ;
2551 : 0 : break;
2552 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA384:
2553 [ # # ]: 0 : if (cdesc->auth_mode == ICP_QAT_HW_AUTH_MODE0) {
2554 : : /* Plain SHA-384 */
2555 : : rte_memcpy(cdesc->cd_cur_ptr, sha384InitialState,
2556 : : sizeof(sha384InitialState));
2557 : 0 : state1_size = qat_hash_get_state1_size(
2558 : : cdesc->qat_hash_alg);
2559 : 0 : break;
2560 : : }
2561 : : /* SHA-384 HMAC */
2562 : : #ifdef RTE_QAT_OPENSSL
2563 : 0 : ret = qat_sym_do_precomputes(ICP_QAT_HW_AUTH_ALGO_SHA384, authkey,
2564 : : authkeylen, cdesc->cd_cur_ptr, &state1_size,
2565 : 0 : cdesc->aes_cmac);
2566 : : #else
2567 : : ret = qat_sym_do_precomputes_ipsec_mb(ICP_QAT_HW_AUTH_ALGO_SHA384,
2568 : : authkey, authkeylen, cdesc->cd_cur_ptr, &state1_size,
2569 : : cdesc->aes_cmac);
2570 : : #endif
2571 [ # # ]: 0 : if (ret) {
2572 : 0 : QAT_LOG(ERR, "(SHA)precompute failed");
2573 : 0 : return -EFAULT;
2574 : : }
2575 : 0 : state2_size = ICP_QAT_HW_SHA384_STATE2_SZ;
2576 : 0 : break;
2577 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA512:
2578 [ # # ]: 0 : if (cdesc->auth_mode == ICP_QAT_HW_AUTH_MODE0) {
2579 : : /* Plain SHA-512 */
2580 : : rte_memcpy(cdesc->cd_cur_ptr, sha512InitialState,
2581 : : sizeof(sha512InitialState));
2582 : 0 : state1_size = qat_hash_get_state1_size(
2583 : : cdesc->qat_hash_alg);
2584 : 0 : break;
2585 : : }
2586 : : /* SHA-512 HMAC */
2587 : : #ifdef RTE_QAT_OPENSSL
2588 : 0 : ret = qat_sym_do_precomputes(ICP_QAT_HW_AUTH_ALGO_SHA512, authkey,
2589 : : authkeylen, cdesc->cd_cur_ptr, &state1_size,
2590 : 0 : cdesc->aes_cmac);
2591 : : #else
2592 : : ret = qat_sym_do_precomputes_ipsec_mb(ICP_QAT_HW_AUTH_ALGO_SHA512,
2593 : : authkey, authkeylen, cdesc->cd_cur_ptr, &state1_size,
2594 : : cdesc->aes_cmac);
2595 : : #endif
2596 [ # # ]: 0 : if (ret) {
2597 : 0 : QAT_LOG(ERR, "(SHA)precompute failed");
2598 : 0 : return -EFAULT;
2599 : : }
2600 : 0 : state2_size = ICP_QAT_HW_SHA512_STATE2_SZ;
2601 : 0 : break;
2602 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA3_224:
2603 : : /* Plain SHA3-224 */
2604 : 0 : state1_size = qat_hash_get_state1_size(
2605 : : cdesc->qat_hash_alg);
2606 : 0 : memset(cdesc->cd_cur_ptr, 0, state1_size);
2607 : : break;
2608 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA3_256:
2609 : : /* Plain SHA3-256 */
2610 : 0 : state1_size = qat_hash_get_state1_size(
2611 : : cdesc->qat_hash_alg);
2612 : 0 : memset(cdesc->cd_cur_ptr, 0, state1_size);
2613 : : break;
2614 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA3_384:
2615 : : /* Plain SHA3-384 */
2616 : 0 : state1_size = qat_hash_get_state1_size(
2617 : : cdesc->qat_hash_alg);
2618 : 0 : memset(cdesc->cd_cur_ptr, 0, state1_size);
2619 : : break;
2620 : 0 : case ICP_QAT_HW_AUTH_ALGO_SHA3_512:
2621 : : /* Plain SHA3-512 */
2622 : 0 : state1_size = qat_hash_get_state1_size(
2623 : : cdesc->qat_hash_alg);
2624 : 0 : memset(cdesc->cd_cur_ptr, 0, state1_size);
2625 : : break;
2626 : 0 : case ICP_QAT_HW_AUTH_ALGO_AES_XCBC_MAC:
2627 : 0 : state1_size = ICP_QAT_HW_AES_XCBC_MAC_STATE1_SZ;
2628 : :
2629 [ # # ]: 0 : if (cdesc->aes_cmac)
2630 : : memset(cdesc->cd_cur_ptr, 0, state1_size);
2631 : : #ifdef RTE_QAT_OPENSSL
2632 : 0 : ret = qat_sym_do_precomputes(ICP_QAT_HW_AUTH_ALGO_AES_XCBC_MAC,
2633 : 0 : authkey, authkeylen, cdesc->cd_cur_ptr + state1_size,
2634 : 0 : &state2_size, cdesc->aes_cmac);
2635 : : #else
2636 : : ret = qat_sym_do_precomputes_ipsec_mb(
2637 : : ICP_QAT_HW_AUTH_ALGO_AES_XCBC_MAC,
2638 : : authkey, authkeylen, cdesc->cd_cur_ptr + state1_size,
2639 : : &state2_size, cdesc->aes_cmac);
2640 : : #endif
2641 [ # # ]: 0 : if (ret) {
2642 [ # # ]: 0 : QAT_LOG(ERR, "(%s)precompute failed",
2643 : : cdesc->aes_cmac ? "CMAC" : "XCBC");
2644 : 0 : return -EFAULT;
2645 : : }
2646 : : break;
2647 : 0 : case ICP_QAT_HW_AUTH_ALGO_AES_128_CMAC:
2648 : 0 : state1_size = ICP_QAT_HW_AES_CMAC_STATE1_SZ;
2649 : : memset(cdesc->cd_cur_ptr, 0, state1_size);
2650 : 0 : memcpy(cdesc->cd_cur_ptr + state1_size, authkey, authkeylen);
2651 : 0 : state2_size = ICP_QAT_HW_AES_128_CMAC_STATE2_SZ;
2652 : 0 : break;
2653 : 0 : case ICP_QAT_HW_AUTH_ALGO_GALOIS_128:
2654 : : case ICP_QAT_HW_AUTH_ALGO_GALOIS_64:
2655 : 0 : cdesc->qat_proto_flag = QAT_CRYPTO_PROTO_FLAG_GCM;
2656 : 0 : state1_size = ICP_QAT_HW_GALOIS_128_STATE1_SZ;
2657 : : #ifdef RTE_QAT_OPENSSL
2658 : 0 : ret = qat_sym_do_precomputes(cdesc->qat_hash_alg, authkey,
2659 : : authkeylen, cdesc->cd_cur_ptr + state1_size,
2660 : 0 : &state2_size, cdesc->aes_cmac);
2661 : : #else
2662 : : ret = qat_sym_do_precomputes_ipsec_mb(cdesc->qat_hash_alg, authkey,
2663 : : authkeylen, cdesc->cd_cur_ptr + state1_size,
2664 : : &state2_size, cdesc->aes_cmac);
2665 : : #endif
2666 [ # # ]: 0 : if (ret) {
2667 : 0 : QAT_LOG(ERR, "(GCM)precompute failed");
2668 : 0 : return -EFAULT;
2669 : : }
2670 : : /*
2671 : : * Write (the length of AAD) into bytes 16-19 of state2
2672 : : * in big-endian format. This field is 8 bytes
2673 : : */
2674 : 0 : auth_param->u2.aad_sz =
2675 : 0 : RTE_ALIGN_CEIL(aad_length, 16);
2676 : 0 : auth_param->hash_state_sz = (auth_param->u2.aad_sz) >> 3;
2677 : :
2678 : 0 : aad_len = (uint32_t *)(cdesc->cd_cur_ptr +
2679 : : ICP_QAT_HW_GALOIS_128_STATE1_SZ +
2680 : : ICP_QAT_HW_GALOIS_H_SZ);
2681 [ # # ]: 0 : *aad_len = rte_bswap32(aad_length);
2682 : 0 : cdesc->aad_len = aad_length;
2683 : 0 : break;
2684 : 0 : case ICP_QAT_HW_AUTH_ALGO_SNOW_3G_UIA2:
2685 [ # # ]: 0 : if (!cdesc->is_wireless)
2686 : 0 : cdesc->qat_proto_flag = QAT_CRYPTO_PROTO_FLAG_SNOW3G;
2687 : 0 : state1_size = qat_hash_get_state1_size(
2688 : : ICP_QAT_HW_AUTH_ALGO_SNOW_3G_UIA2);
2689 : 0 : state2_size = ICP_QAT_HW_SNOW_3G_UIA2_STATE2_SZ;
2690 : : memset(cdesc->cd_cur_ptr, 0, state1_size + state2_size);
2691 : :
2692 : 0 : cipherconfig = (struct icp_qat_hw_cipher_algo_blk *)
2693 : 0 : (cdesc->cd_cur_ptr + state1_size + state2_size);
2694 : 0 : cipherconfig->cipher_config.val =
2695 : : ICP_QAT_HW_CIPHER_CONFIG_BUILD(ICP_QAT_HW_CIPHER_ECB_MODE,
2696 : : ICP_QAT_HW_CIPHER_ALGO_SNOW_3G_UEA2,
2697 : : ICP_QAT_HW_CIPHER_KEY_CONVERT,
2698 : : ICP_QAT_HW_CIPHER_ENCRYPT);
2699 : 0 : memcpy(cipherconfig->key, authkey, authkeylen);
2700 : 0 : memset(cipherconfig->key + authkeylen,
2701 : : 0, ICP_QAT_HW_SNOW_3G_UEA2_IV_SZ);
2702 : 0 : cd_extra_size += sizeof(struct icp_qat_hw_cipher_config) +
2703 : : authkeylen + ICP_QAT_HW_SNOW_3G_UEA2_IV_SZ;
2704 : 0 : auth_param->hash_state_sz = ICP_QAT_HW_SNOW_3G_UEA2_IV_SZ >> 3;
2705 : 0 : break;
2706 : 0 : case ICP_QAT_HW_AUTH_ALGO_ZUC_3G_128_EIA3:
2707 [ # # ]: 0 : if (!cdesc->is_wireless) {
2708 : 0 : hash->auth_config.config =
2709 : 0 : ICP_QAT_HW_AUTH_CONFIG_BUILD(ICP_QAT_HW_AUTH_MODE0,
2710 : : cdesc->qat_hash_alg, digestsize);
2711 : 0 : cdesc->qat_proto_flag = QAT_CRYPTO_PROTO_FLAG_ZUC;
2712 : : }
2713 : 0 : state1_size = qat_hash_get_state1_size(
2714 : : ICP_QAT_HW_AUTH_ALGO_ZUC_3G_128_EIA3);
2715 : 0 : state2_size = ICP_QAT_HW_ZUC_3G_EIA3_STATE2_SZ;
2716 : : memset(cdesc->cd_cur_ptr, 0, state1_size + state2_size
2717 : : + ICP_QAT_HW_ZUC_3G_EEA3_IV_SZ);
2718 : :
2719 : 0 : memcpy(cdesc->cd_cur_ptr + state1_size, authkey, authkeylen);
2720 : : cd_extra_size += ICP_QAT_HW_ZUC_3G_EEA3_IV_SZ;
2721 : 0 : auth_param->hash_state_sz = ICP_QAT_HW_ZUC_3G_EEA3_IV_SZ >> 3;
2722 : :
2723 : 0 : break;
2724 : 0 : case ICP_QAT_HW_AUTH_ALGO_ZUC_256_MAC_32:
2725 : : case ICP_QAT_HW_AUTH_ALGO_ZUC_256_MAC_64:
2726 : : case ICP_QAT_HW_AUTH_ALGO_ZUC_256_MAC_128:
2727 : 0 : state1_size = qat_hash_get_state1_size(cdesc->qat_hash_alg);
2728 : 0 : state2_size = ICP_QAT_HW_ZUC_256_STATE2_SZ;
2729 : 0 : memset(cdesc->cd_cur_ptr, 0, state1_size + state2_size
2730 : 0 : + ICP_QAT_HW_ZUC_256_IV_SZ);
2731 : :
2732 : 0 : memcpy(cdesc->cd_cur_ptr + state1_size, authkey, authkeylen);
2733 : : cd_extra_size += ICP_QAT_HW_ZUC_256_IV_SZ;
2734 : 0 : auth_param->hash_state_sz = ICP_QAT_HW_ZUC_256_IV_SZ >> 3;
2735 : 0 : break;
2736 : 0 : case ICP_QAT_HW_AUTH_ALGO_MD5:
2737 : : #ifdef RTE_QAT_OPENSSL
2738 : 0 : ret = qat_sym_do_precomputes(ICP_QAT_HW_AUTH_ALGO_MD5, authkey,
2739 : : authkeylen, cdesc->cd_cur_ptr, &state1_size,
2740 : 0 : cdesc->aes_cmac);
2741 : : #else
2742 : : ret = qat_sym_do_precomputes_ipsec_mb(ICP_QAT_HW_AUTH_ALGO_MD5,
2743 : : authkey, authkeylen, cdesc->cd_cur_ptr, &state1_size,
2744 : : cdesc->aes_cmac);
2745 : : #endif
2746 [ # # ]: 0 : if (ret) {
2747 : 0 : QAT_LOG(ERR, "(MD5)precompute failed");
2748 : 0 : return -EFAULT;
2749 : : }
2750 : 0 : state2_size = ICP_QAT_HW_MD5_STATE2_SZ;
2751 : 0 : break;
2752 : : case ICP_QAT_HW_AUTH_ALGO_NULL:
2753 : 0 : state1_size = qat_hash_get_state1_size(
2754 : : ICP_QAT_HW_AUTH_ALGO_NULL);
2755 : 0 : state2_size = ICP_QAT_HW_NULL_STATE2_SZ;
2756 : 0 : break;
2757 : 0 : case ICP_QAT_HW_AUTH_ALGO_AES_CBC_MAC:
2758 : 0 : cdesc->qat_proto_flag = QAT_CRYPTO_PROTO_FLAG_CCM;
2759 : 0 : state1_size = qat_hash_get_state1_size(
2760 : : ICP_QAT_HW_AUTH_ALGO_AES_CBC_MAC);
2761 : 0 : state2_size = ICP_QAT_HW_AES_CBC_MAC_KEY_SZ +
2762 : : ICP_QAT_HW_AES_CCM_CBC_E_CTR0_SZ;
2763 : :
2764 [ # # ]: 0 : if (aad_length > 0) {
2765 : 0 : aad_length += ICP_QAT_HW_CCM_AAD_B0_LEN +
2766 : : ICP_QAT_HW_CCM_AAD_LEN_INFO;
2767 : 0 : auth_param->u2.aad_sz =
2768 : 0 : RTE_ALIGN_CEIL(aad_length,
2769 : : ICP_QAT_HW_CCM_AAD_ALIGNMENT);
2770 : : } else {
2771 : 0 : auth_param->u2.aad_sz = ICP_QAT_HW_CCM_AAD_B0_LEN;
2772 : : }
2773 : 0 : cdesc->aad_len = aad_length;
2774 : 0 : hash->auth_counter.counter = 0;
2775 : :
2776 : 0 : hash_cd_ctrl->outer_prefix_sz = digestsize;
2777 : 0 : auth_param->hash_state_sz = digestsize;
2778 : :
2779 : 0 : memcpy(cdesc->cd_cur_ptr + state1_size, authkey, authkeylen);
2780 : : break;
2781 : : case ICP_QAT_HW_AUTH_ALGO_KASUMI_F9:
2782 : 0 : state1_size = qat_hash_get_state1_size(
2783 : : ICP_QAT_HW_AUTH_ALGO_KASUMI_F9);
2784 : 0 : state2_size = ICP_QAT_HW_KASUMI_F9_STATE2_SZ;
2785 : : memset(cdesc->cd_cur_ptr, 0, state1_size + state2_size);
2786 : 0 : pTempKey = (uint32_t *)(cdesc->cd_cur_ptr + state1_size
2787 : 0 : + authkeylen);
2788 : : /*
2789 : : * The Inner Hash Initial State2 block must contain IK
2790 : : * (Initialisation Key), followed by IK XOR-ed with KM
2791 : : * (Key Modifier): IK||(IK^KM).
2792 : : */
2793 : : /* write the auth key */
2794 : 0 : memcpy(cdesc->cd_cur_ptr + state1_size, authkey, authkeylen);
2795 : : /* initialise temp key with auth key */
2796 : : memcpy(pTempKey, authkey, authkeylen);
2797 : : /* XOR Key with KASUMI F9 key modifier at 4 bytes level */
2798 [ # # ]: 0 : for (wordIndex = 0; wordIndex < (authkeylen >> 2); wordIndex++)
2799 : 0 : pTempKey[wordIndex] ^= KASUMI_F9_KEY_MODIFIER_4_BYTES;
2800 : : break;
2801 : 0 : default:
2802 : 0 : QAT_LOG(ERR, "Invalid HASH alg %u", cdesc->qat_hash_alg);
2803 : 0 : return -EFAULT;
2804 : : }
2805 : :
2806 : : /* Auth CD config setup */
2807 : : hash_cd_ctrl->hash_flags |= ICP_QAT_FW_AUTH_HDR_FLAG_NO_NESTED;
2808 : 0 : hash_cd_ctrl->inner_state1_sz = state1_size;
2809 [ # # ]: 0 : if (cdesc->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_NULL) {
2810 : 0 : hash_cd_ctrl->inner_res_sz = 4;
2811 : 0 : hash_cd_ctrl->final_sz = 4;
2812 : 0 : auth_param->auth_res_sz = 4;
2813 : : } else {
2814 : 0 : hash_cd_ctrl->inner_res_sz = digestsize;
2815 : 0 : hash_cd_ctrl->final_sz = digestsize;
2816 : 0 : auth_param->auth_res_sz = digestsize;
2817 : : }
2818 : :
2819 : 0 : hash_cd_ctrl->inner_state2_sz = state2_size;
2820 : 0 : hash_cd_ctrl->inner_state2_offset = hash_cd_ctrl->hash_cfg_offset +
2821 : 0 : ((sizeof(struct icp_qat_hw_auth_setup) +
2822 : 0 : RTE_ALIGN_CEIL(hash_cd_ctrl->inner_state1_sz, 8))
2823 : 0 : >> 3);
2824 : 0 : cdesc->cd_cur_ptr += state1_size + state2_size + cd_extra_size;
2825 : 0 : cd_size = cdesc->cd_cur_ptr-(uint8_t *)&cdesc->cd;
2826 : 0 : cd_pars->u.s.content_desc_addr = cdesc->cd_paddr;
2827 : 0 : cd_pars->u.s.content_desc_params_sz = RTE_ALIGN_CEIL(cd_size, 8) >> 3;
2828 : 0 : return 0;
2829 : : }
2830 : :
2831 : 0 : int qat_sym_validate_aes_key(int key_len, enum icp_qat_hw_cipher_algo *alg)
2832 : : {
2833 [ # # # # ]: 0 : switch (key_len) {
2834 : 0 : case ICP_QAT_HW_AES_128_KEY_SZ:
2835 : 0 : *alg = ICP_QAT_HW_CIPHER_ALGO_AES128;
2836 : 0 : break;
2837 : 0 : case ICP_QAT_HW_AES_192_KEY_SZ:
2838 : 0 : *alg = ICP_QAT_HW_CIPHER_ALGO_AES192;
2839 : 0 : break;
2840 : 0 : case ICP_QAT_HW_AES_256_KEY_SZ:
2841 : 0 : *alg = ICP_QAT_HW_CIPHER_ALGO_AES256;
2842 : 0 : break;
2843 : : default:
2844 : : return -EINVAL;
2845 : : }
2846 : : return 0;
2847 : : }
2848 : :
2849 : 0 : int qat_sym_validate_aes_docsisbpi_key(int key_len,
2850 : : enum icp_qat_hw_cipher_algo *alg)
2851 : : {
2852 [ # # # ]: 0 : switch (key_len) {
2853 : 0 : case ICP_QAT_HW_AES_128_KEY_SZ:
2854 : 0 : *alg = ICP_QAT_HW_CIPHER_ALGO_AES128;
2855 : 0 : break;
2856 : 0 : case ICP_QAT_HW_AES_256_KEY_SZ:
2857 : 0 : *alg = ICP_QAT_HW_CIPHER_ALGO_AES256;
2858 : 0 : break;
2859 : : default:
2860 : : return -EINVAL;
2861 : : }
2862 : : return 0;
2863 : : }
2864 : :
2865 : 0 : int qat_sym_validate_snow3g_key(int key_len, enum icp_qat_hw_cipher_algo *alg)
2866 : : {
2867 [ # # ]: 0 : switch (key_len) {
2868 : 0 : case ICP_QAT_HW_SNOW_3G_UEA2_KEY_SZ:
2869 : 0 : *alg = ICP_QAT_HW_CIPHER_ALGO_SNOW_3G_UEA2;
2870 : : break;
2871 : : default:
2872 : : return -EINVAL;
2873 : : }
2874 : 0 : return 0;
2875 : : }
2876 : :
2877 : 0 : int qat_sym_validate_kasumi_key(int key_len, enum icp_qat_hw_cipher_algo *alg)
2878 : : {
2879 [ # # ]: 0 : switch (key_len) {
2880 : 0 : case ICP_QAT_HW_KASUMI_KEY_SZ:
2881 : 0 : *alg = ICP_QAT_HW_CIPHER_ALGO_KASUMI;
2882 : : break;
2883 : : default:
2884 : : return -EINVAL;
2885 : : }
2886 : 0 : return 0;
2887 : : }
2888 : :
2889 : 0 : int qat_sym_validate_des_key(int key_len, enum icp_qat_hw_cipher_algo *alg)
2890 : : {
2891 [ # # ]: 0 : switch (key_len) {
2892 : 0 : case ICP_QAT_HW_DES_KEY_SZ:
2893 : 0 : *alg = ICP_QAT_HW_CIPHER_ALGO_DES;
2894 : : break;
2895 : : default:
2896 : : return -EINVAL;
2897 : : }
2898 : 0 : return 0;
2899 : : }
2900 : :
2901 : 0 : int qat_sym_validate_3des_key(int key_len, enum icp_qat_hw_cipher_algo *alg)
2902 : : {
2903 [ # # ]: 0 : switch (key_len) {
2904 : 0 : case QAT_3DES_KEY_SZ_OPT1:
2905 : : case QAT_3DES_KEY_SZ_OPT2:
2906 : : case QAT_3DES_KEY_SZ_OPT3:
2907 : 0 : *alg = ICP_QAT_HW_CIPHER_ALGO_3DES;
2908 : : break;
2909 : : default:
2910 : : return -EINVAL;
2911 : : }
2912 : 0 : return 0;
2913 : : }
2914 : :
2915 : 0 : int qat_sym_validate_zuc_key(int key_len, enum icp_qat_hw_cipher_algo *alg)
2916 : : {
2917 [ # # # ]: 0 : switch (key_len) {
2918 : 0 : case ICP_QAT_HW_ZUC_3G_EEA3_KEY_SZ:
2919 : 0 : *alg = ICP_QAT_HW_CIPHER_ALGO_ZUC_3G_128_EEA3;
2920 : 0 : break;
2921 : 0 : case ICP_QAT_HW_ZUC_256_KEY_SZ:
2922 : 0 : *alg = ICP_QAT_HW_CIPHER_ALGO_ZUC_256;
2923 : 0 : break;
2924 : : default:
2925 : : return -EINVAL;
2926 : : }
2927 : : return 0;
2928 : : }
2929 : :
2930 : : static int
2931 : 0 : qat_sec_session_check_docsis(struct rte_security_session_conf *conf)
2932 : : {
2933 : 0 : struct rte_crypto_sym_xform *crypto_sym = conf->crypto_xform;
2934 : : struct rte_security_docsis_xform *docsis = &conf->docsis;
2935 : :
2936 : : /* CRC generate -> Cipher encrypt */
2937 [ # # ]: 0 : if (docsis->direction == RTE_SECURITY_DOCSIS_DOWNLINK) {
2938 : :
2939 [ # # ]: 0 : if (crypto_sym != NULL &&
2940 [ # # ]: 0 : crypto_sym->type == RTE_CRYPTO_SYM_XFORM_CIPHER &&
2941 [ # # ]: 0 : crypto_sym->cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT &&
2942 : : crypto_sym->cipher.algo ==
2943 : 0 : RTE_CRYPTO_CIPHER_AES_DOCSISBPI &&
2944 : 0 : (crypto_sym->cipher.key.length ==
2945 [ # # ]: 0 : ICP_QAT_HW_AES_128_KEY_SZ ||
2946 : : crypto_sym->cipher.key.length ==
2947 : 0 : ICP_QAT_HW_AES_256_KEY_SZ) &&
2948 [ # # ]: 0 : crypto_sym->cipher.iv.length == ICP_QAT_HW_AES_BLK_SZ &&
2949 [ # # ]: 0 : crypto_sym->next == NULL) {
2950 : 0 : return 0;
2951 : : }
2952 : : /* Cipher decrypt -> CRC verify */
2953 [ # # ]: 0 : } else if (docsis->direction == RTE_SECURITY_DOCSIS_UPLINK) {
2954 : :
2955 [ # # ]: 0 : if (crypto_sym != NULL &&
2956 [ # # ]: 0 : crypto_sym->type == RTE_CRYPTO_SYM_XFORM_CIPHER &&
2957 [ # # ]: 0 : crypto_sym->cipher.op == RTE_CRYPTO_CIPHER_OP_DECRYPT &&
2958 : : crypto_sym->cipher.algo ==
2959 : 0 : RTE_CRYPTO_CIPHER_AES_DOCSISBPI &&
2960 : 0 : (crypto_sym->cipher.key.length ==
2961 [ # # ]: 0 : ICP_QAT_HW_AES_128_KEY_SZ ||
2962 : : crypto_sym->cipher.key.length ==
2963 : 0 : ICP_QAT_HW_AES_256_KEY_SZ) &&
2964 [ # # ]: 0 : crypto_sym->cipher.iv.length == ICP_QAT_HW_AES_BLK_SZ &&
2965 [ # # ]: 0 : crypto_sym->next == NULL) {
2966 : 0 : return 0;
2967 : : }
2968 : : }
2969 : :
2970 : : return -EINVAL;
2971 : : }
2972 : :
2973 : : static int
2974 : 0 : qat_sym_cd_crc_set(struct qat_sym_session *cdesc,
2975 : : enum qat_device_gen qat_dev_gen)
2976 : : {
2977 : : struct icp_qat_hw_gen2_crc_cd *crc_cd_gen2;
2978 : : struct icp_qat_hw_gen3_crc_cd *crc_cd_gen3;
2979 : : struct icp_qat_hw_gen4_crc_cd *crc_cd_gen4;
2980 : : struct icp_qat_fw_la_bulk_req *req_tmpl = &cdesc->fw_req;
2981 : : struct icp_qat_fw_comn_req_hdr_cd_pars *cd_pars = &req_tmpl->cd_pars;
2982 : : void *ptr = &req_tmpl->cd_ctrl;
2983 : : struct icp_qat_fw_auth_cd_ctrl_hdr *crc_cd_ctrl = ptr;
2984 : : struct icp_qat_fw_la_auth_req_params *crc_param =
2985 : : (struct icp_qat_fw_la_auth_req_params *)
2986 : : ((char *)&req_tmpl->serv_specif_rqpars +
2987 : : ICP_QAT_FW_HASH_REQUEST_PARAMETERS_OFFSET);
2988 : : struct icp_qat_fw_ucs_slice_cipher_config crc_cfg;
2989 : : uint16_t crc_cfg_offset, cd_size;
2990 : :
2991 : 0 : crc_cfg_offset = cdesc->cd_cur_ptr - ((uint8_t *)&cdesc->cd);
2992 : :
2993 [ # # # # ]: 0 : switch (qat_dev_gen) {
2994 : 0 : case QAT_GEN2:
2995 : : crc_cd_gen2 =
2996 : : (struct icp_qat_hw_gen2_crc_cd *)cdesc->cd_cur_ptr;
2997 : 0 : crc_cd_gen2->flags = 0;
2998 : 0 : crc_cd_gen2->initial_crc = 0;
2999 : 0 : memset(&crc_cd_gen2->reserved1,
3000 : : 0,
3001 : : sizeof(crc_cd_gen2->reserved1));
3002 : 0 : memset(&crc_cd_gen2->reserved2,
3003 : : 0,
3004 : : sizeof(crc_cd_gen2->reserved2));
3005 : 0 : cdesc->cd_cur_ptr += sizeof(struct icp_qat_hw_gen2_crc_cd);
3006 : 0 : break;
3007 : 0 : case QAT_GEN3:
3008 : : crc_cd_gen3 =
3009 : : (struct icp_qat_hw_gen3_crc_cd *)cdesc->cd_cur_ptr;
3010 : 0 : crc_cd_gen3->flags = ICP_QAT_HW_GEN3_CRC_FLAGS_BUILD(1, 1);
3011 : 0 : crc_cd_gen3->polynomial = ETH_CRC32_POLYNOMIAL;
3012 : 0 : crc_cd_gen3->initial_crc = ETH_CRC32_INIT_VAL;
3013 : 0 : crc_cd_gen3->xor_val = ETH_CRC32_XOR_OUT;
3014 : 0 : memset(&crc_cd_gen3->reserved1,
3015 : : 0,
3016 : : sizeof(crc_cd_gen3->reserved1));
3017 : 0 : memset(&crc_cd_gen3->reserved2,
3018 : : 0,
3019 : : sizeof(crc_cd_gen3->reserved2));
3020 : 0 : crc_cd_gen3->reserved3 = 0;
3021 : 0 : cdesc->cd_cur_ptr += sizeof(struct icp_qat_hw_gen3_crc_cd);
3022 : 0 : break;
3023 : 0 : case QAT_GEN4:
3024 : : case QAT_GEN5:
3025 : : crc_cfg.mode = ICP_QAT_HW_CIPHER_ECB_MODE;
3026 : : crc_cfg.algo = ICP_QAT_HW_CIPHER_ALGO_NULL;
3027 : : crc_cfg.hash_cmp_val = 0;
3028 : : crc_cfg.dir = ICP_QAT_HW_CIPHER_ENCRYPT;
3029 : : crc_cfg.associated_data_len_in_bytes = 0;
3030 : : crc_cfg.crc_reflect_out =
3031 : : ICP_QAT_HW_CIPHER_UCS_REFLECT_OUT_ENABLED;
3032 : : crc_cfg.crc_reflect_in =
3033 : : ICP_QAT_HW_CIPHER_UCS_REFLECT_IN_ENABLED;
3034 : : crc_cfg.crc_encoding = ICP_QAT_HW_CIPHER_UCS_CRC32;
3035 : :
3036 : : crc_cd_gen4 =
3037 : : (struct icp_qat_hw_gen4_crc_cd *)cdesc->cd_cur_ptr;
3038 : 0 : crc_cd_gen4->ucs_config[0] =
3039 : : ICP_QAT_HW_UCS_CIPHER_GEN4_BUILD_CONFIG_LOWER(crc_cfg);
3040 : 0 : crc_cd_gen4->ucs_config[1] =
3041 : 0 : ICP_QAT_HW_UCS_CIPHER_GEN4_BUILD_CONFIG_UPPER(crc_cfg);
3042 : 0 : crc_cd_gen4->polynomial = ETH_CRC32_POLYNOMIAL_BE;
3043 : 0 : crc_cd_gen4->initial_crc = ETH_CRC32_INIT_VAL_BE;
3044 : 0 : crc_cd_gen4->xor_val = ETH_CRC32_XOR_OUT_BE;
3045 : 0 : crc_cd_gen4->reserved1 = 0;
3046 : 0 : crc_cd_gen4->reserved2 = 0;
3047 : 0 : crc_cd_gen4->reserved3 = 0;
3048 : 0 : cdesc->cd_cur_ptr += sizeof(struct icp_qat_hw_gen4_crc_cd);
3049 : 0 : break;
3050 : : default:
3051 : : return -EINVAL;
3052 : : }
3053 : :
3054 : 0 : crc_cd_ctrl->hash_cfg_offset = crc_cfg_offset >> 3;
3055 : 0 : crc_cd_ctrl->hash_flags = ICP_QAT_FW_AUTH_HDR_FLAG_NO_NESTED;
3056 : 0 : crc_cd_ctrl->inner_res_sz = cdesc->digest_length;
3057 : 0 : crc_cd_ctrl->final_sz = cdesc->digest_length;
3058 : 0 : crc_cd_ctrl->inner_state1_sz = 0;
3059 : 0 : crc_cd_ctrl->inner_state2_sz = 0;
3060 : 0 : crc_cd_ctrl->inner_state2_offset = 0;
3061 : 0 : crc_cd_ctrl->outer_prefix_sz = 0;
3062 : 0 : crc_cd_ctrl->outer_config_offset = 0;
3063 : 0 : crc_cd_ctrl->outer_state1_sz = 0;
3064 : 0 : crc_cd_ctrl->outer_res_sz = 0;
3065 : 0 : crc_cd_ctrl->outer_prefix_offset = 0;
3066 : :
3067 : 0 : crc_param->auth_res_sz = cdesc->digest_length;
3068 : 0 : crc_param->u2.aad_sz = 0;
3069 : 0 : crc_param->hash_state_sz = 0;
3070 : :
3071 : 0 : cd_size = cdesc->cd_cur_ptr - (uint8_t *)&cdesc->cd;
3072 : 0 : cd_pars->u.s.content_desc_addr = cdesc->cd_paddr;
3073 : 0 : cd_pars->u.s.content_desc_params_sz = RTE_ALIGN_CEIL(cd_size, 8) >> 3;
3074 : :
3075 : 0 : return 0;
3076 : : }
3077 : :
3078 : : static int
3079 : 0 : qat_sym_session_configure_crc(struct rte_cryptodev *dev,
3080 : : const struct rte_crypto_sym_xform *cipher_xform,
3081 : : struct qat_sym_session *session)
3082 : : {
3083 : 0 : struct qat_cryptodev_private *internals = dev->data->dev_private;
3084 : 0 : enum qat_device_gen qat_dev_gen = internals->qat_dev->qat_dev_gen;
3085 : : int ret;
3086 : :
3087 : 0 : session->is_auth = 1;
3088 : 0 : session->qat_hash_alg = ICP_QAT_HW_AUTH_ALGO_NULL;
3089 : 0 : session->auth_mode = ICP_QAT_HW_AUTH_MODE0;
3090 : 0 : session->auth_op = cipher_xform->cipher.op ==
3091 : : RTE_CRYPTO_CIPHER_OP_ENCRYPT ?
3092 : 0 : ICP_QAT_HW_AUTH_GENERATE :
3093 : : ICP_QAT_HW_AUTH_VERIFY;
3094 : 0 : session->digest_length = RTE_ETHER_CRC_LEN;
3095 : :
3096 : 0 : ret = qat_sym_cd_crc_set(session, qat_dev_gen);
3097 : : if (ret < 0)
3098 : : return ret;
3099 : :
3100 : : return 0;
3101 : : }
3102 : :
3103 : : static int
3104 : 0 : qat_sec_session_set_docsis_parameters(struct rte_cryptodev *dev,
3105 : : struct rte_security_session_conf *conf, void *session_private,
3106 : : rte_iova_t session_paddr)
3107 : : {
3108 : : int ret;
3109 : : int qat_cmd_id;
3110 : : struct rte_cryptodev *cdev = (struct rte_cryptodev *)dev;
3111 : : struct rte_crypto_sym_xform *xform = NULL;
3112 : : struct qat_sym_session *session = session_private;
3113 : 0 : struct qat_cryptodev_private *internals = cdev->data->dev_private;
3114 : 0 : enum qat_device_gen qat_dev_gen = internals->qat_dev->qat_dev_gen;
3115 : :
3116 : : /* Clear the session */
3117 [ # # ]: 0 : memset(session, 0, qat_sym_session_get_private_size(dev));
3118 : :
3119 : 0 : ret = qat_sec_session_check_docsis(conf);
3120 [ # # ]: 0 : if (ret) {
3121 : 0 : QAT_LOG(ERR, "Unsupported DOCSIS security configuration");
3122 : 0 : return ret;
3123 : : }
3124 : :
3125 : 0 : xform = conf->crypto_xform;
3126 : :
3127 : : /* Verify the session physical address is known */
3128 [ # # ]: 0 : if (session_paddr == 0 || session_paddr == RTE_BAD_IOVA) {
3129 : 0 : QAT_LOG(ERR,
3130 : : "Session physical address unknown. Bad memory pool.");
3131 : 0 : return -EINVAL;
3132 : : }
3133 : :
3134 : : /* Set context descriptor physical address */
3135 : 0 : session->cd_paddr = session_paddr +
3136 : : offsetof(struct qat_sym_session, cd);
3137 : 0 : session->prefix_paddr = session_paddr +
3138 : : offsetof(struct qat_sym_session, prefix_state);
3139 : :
3140 : : /* Get requested QAT command id - should be cipher */
3141 : 0 : qat_cmd_id = qat_get_cmd_id(xform);
3142 [ # # ]: 0 : if (qat_cmd_id != ICP_QAT_FW_LA_CMD_CIPHER) {
3143 : 0 : QAT_LOG(ERR, "Unsupported xform chain requested");
3144 : 0 : return -ENOTSUP;
3145 : 0 : } else if (internals->internal_capabilities
3146 [ # # ]: 0 : & QAT_SYM_CAP_CIPHER_CRC) {
3147 : : qat_cmd_id = ICP_QAT_FW_LA_CMD_CIPHER_CRC;
3148 : : }
3149 : 0 : session->qat_cmd = (enum icp_qat_fw_la_cmd_id)qat_cmd_id;
3150 : :
3151 : 0 : ret = qat_sym_session_configure_cipher(dev, xform, session);
3152 [ # # ]: 0 : if (ret < 0)
3153 : : return ret;
3154 : :
3155 [ # # ]: 0 : if (qat_cmd_id == ICP_QAT_FW_LA_CMD_CIPHER_CRC) {
3156 : 0 : ret = qat_sym_session_configure_crc(dev, xform, session);
3157 [ # # ]: 0 : if (ret < 0)
3158 : : return ret;
3159 : : } else {
3160 : : /* Initialize CRC algorithm */
3161 : 0 : session->crc = rte_net_crc_set_alg(RTE_NET_CRC_AVX512,
3162 : : RTE_NET_CRC32_ETH);
3163 [ # # ]: 0 : if (session->crc == NULL) {
3164 : 0 : QAT_LOG(ERR, "Cannot initialize CRC context");
3165 : 0 : return -1;
3166 : : }
3167 : : }
3168 : : qat_sym_session_finalize(session);
3169 : :
3170 : 0 : return qat_sym_gen_dev_ops[qat_dev_gen].set_session((void *)cdev,
3171 : : (void *)session);
3172 : : }
3173 : :
3174 : : int
3175 : 0 : qat_security_session_create(void *dev,
3176 : : struct rte_security_session_conf *conf,
3177 : : struct rte_security_session *sess)
3178 : : {
3179 : 0 : void *sess_private_data = SECURITY_GET_SESS_PRIV(sess);
3180 : : struct rte_cryptodev *cdev = (struct rte_cryptodev *)dev;
3181 : : int ret;
3182 : :
3183 [ # # ]: 0 : if (conf->action_type != RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL ||
3184 : : conf->protocol != RTE_SECURITY_PROTOCOL_DOCSIS) {
3185 : 0 : QAT_LOG(ERR, "Invalid security protocol");
3186 : 0 : return -EINVAL;
3187 : : }
3188 : :
3189 : : #ifdef RTE_QAT_OPENSSL
3190 : : #if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
3191 [ # # ]: 0 : if (ossl_legacy_provider_load())
3192 : : return -EINVAL;
3193 : : #endif
3194 : : #endif
3195 : 0 : ret = qat_sec_session_set_docsis_parameters(cdev, conf,
3196 : : sess_private_data, SECURITY_GET_SESS_PRIV_IOVA(sess));
3197 [ # # ]: 0 : if (ret != 0) {
3198 : 0 : QAT_LOG(ERR, "Failed to configure session parameters");
3199 : 0 : return ret;
3200 : : }
3201 : :
3202 : : #ifdef RTE_QAT_OPENSSL
3203 : : #if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
3204 : 0 : ossl_legacy_provider_unload();
3205 : : #endif
3206 : : #endif
3207 : 0 : return 0;
3208 : : }
3209 : :
3210 : : int
3211 : 0 : qat_security_session_destroy(void *dev __rte_unused,
3212 : : struct rte_security_session *sess)
3213 : : {
3214 : 0 : void *sess_priv = SECURITY_GET_SESS_PRIV(sess);
3215 : : struct qat_sym_session *s = (struct qat_sym_session *)sess_priv;
3216 : :
3217 : : if (sess_priv) {
3218 : : #ifdef RTE_QAT_OPENSSL
3219 [ # # ]: 0 : if (s->bpi_ctx)
3220 : : bpi_cipher_ctx_free(s->bpi_ctx);
3221 : : #else
3222 : : if (s->mb_mgr)
3223 : : free_mb_mgr(s->mb_mgr);
3224 : : #endif
3225 : 0 : rte_memzero_explicit(s, qat_sym_session_get_private_size(dev));
3226 : : }
3227 : :
3228 : 0 : return 0;
3229 : : }
3230 : :
3231 : : unsigned int
3232 : 0 : qat_security_session_get_size(void *device __rte_unused)
3233 : : {
3234 : 0 : return sizeof(struct qat_sym_session);
3235 : : }
|
