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