]> git.proxmox.com Git - ceph.git/blob - ceph/src/spdk/intel-ipsec-mb/intel-ipsec-mb.h
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update source to Ceph Pacific 16.2.2
[ceph.git] / ceph / src / spdk / intel-ipsec-mb / intel-ipsec-mb.h
1 /*******************************************************************************
2 Copyright (c) 2012-2019, Intel Corporation
3
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions are met:
6
7 * Redistributions of source code must retain the above copyright notice,
8 this list of conditions and the following disclaimer.
9 * Redistributions in binary form must reproduce the above copyright
10 notice, this list of conditions and the following disclaimer in the
11 documentation and/or other materials provided with the distribution.
12 * Neither the name of Intel Corporation nor the names of its contributors
13 may be used to endorse or promote products derived from this software
14 without specific prior written permission.
15
16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
20 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 *******************************************************************************/
27
28 #ifndef IMB_IPSEC_MB_H
29 #define IMB_IPSEC_MB_H
30
31 #include <stdlib.h>
32 #include <stdint.h>
33
34 #ifdef __cplusplus
35 extern "C" {
36 #endif
37
38 /* 128-bit data type that is not in sdtint.h */
39 typedef struct {
40 uint64_t low;
41 uint64_t high;
42 } uint128_t;
43
44 /*
45 * Macros for aligning data structures and function inlines
46 */
47 #if defined __linux__ || defined __FreeBSD__
48 /* Linux/FreeBSD */
49 #define DECLARE_ALIGNED(decl, alignval) \
50 decl __attribute__((aligned(alignval)))
51 #define __forceinline \
52 static inline __attribute__((always_inline))
53
54 #if __GNUC__ >= 4
55 #define IMB_DLL_EXPORT __attribute__((visibility("default")))
56 #define IMB_DLL_LOCAL __attribute__((visibility("hidden")))
57 #else /* GNU C 4.0 and later */
58 #define IMB_DLL_EXPORT
59 #define IMB_DLL_LOCAL
60 #endif /* different C compiler */
61
62 #else
63 /* Windows */
64 #define DECLARE_ALIGNED(decl, alignval) \
65 __declspec(align(alignval)) decl
66 #define __forceinline \
67 static __forceinline
68
69 /* Windows DLL export is done via DEF file */
70 #define IMB_DLL_EXPORT
71 #define IMB_DLL_LOCAL
72 #endif
73
74 /* Library version */
75 #define IMB_VERSION_STR "0.53.0"
76 #define IMB_VERSION_NUM 0x3500
77
78 /* Macro to translate version number */
79 #define IMB_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
80
81 /*
82 * Custom ASSERT and DIM macros
83 */
84 #ifdef DEBUG
85 #include <assert.h>
86 #define IMB_ASSERT(x) assert(x)
87 #else
88 #define IMB_ASSERT(x)
89 #endif
90
91 #ifndef IMB_DIM
92 #define IMB_DIM(x) (sizeof(x) / sizeof(x[0]))
93 #endif
94
95 /*
96 * Algorithm constants
97 */
98
99 #define DES_KEY_SCHED_SIZE (16 * 8) /* 16 rounds x 8 bytes */
100 #define DES_BLOCK_SIZE 8
101
102 #define AES_BLOCK_SIZE 16
103
104 #define NUM_MD5_DIGEST_WORDS 4
105 #define NUM_SHA_DIGEST_WORDS 5
106 #define NUM_SHA_256_DIGEST_WORDS 8
107 #define NUM_SHA_224_DIGEST_WORDS 7
108 #define NUM_SHA_512_DIGEST_WORDS 8
109 #define NUM_SHA_384_DIGEST_WORDS 6
110
111 #define SHA_DIGEST_WORD_SIZE 4
112 #define SHA224_DIGEST_WORD_SIZE 4
113 #define SHA256_DIGEST_WORD_SIZE 4
114 #define SHA384_DIGEST_WORD_SIZE 8
115 #define SHA512_DIGEST_WORD_SIZE 8
116
117 #define SHA1_DIGEST_SIZE_IN_BYTES \
118 (NUM_SHA_DIGEST_WORDS * SHA_DIGEST_WORD_SIZE)
119 #define SHA224_DIGEST_SIZE_IN_BYTES \
120 (NUM_SHA_224_DIGEST_WORDS * SHA224_DIGEST_WORD_SIZE)
121 #define SHA256_DIGEST_SIZE_IN_BYTES \
122 (NUM_SHA_256_DIGEST_WORDS * SHA256_DIGEST_WORD_SIZE)
123 #define SHA384_DIGEST_SIZE_IN_BYTES \
124 (NUM_SHA_384_DIGEST_WORDS * SHA384_DIGEST_WORD_SIZE)
125 #define SHA512_DIGEST_SIZE_IN_BYTES \
126 (NUM_SHA_512_DIGEST_WORDS * SHA512_DIGEST_WORD_SIZE)
127
128 #define SHA1_BLOCK_SIZE 64 /* 512 bits is 64 byte blocks */
129 #define SHA_256_BLOCK_SIZE 64 /* 512 bits is 64 byte blocks */
130 #define SHA_384_BLOCK_SIZE 128
131 #define SHA_512_BLOCK_SIZE 128
132
133 #define KASUMI_KEY_SIZE 16
134 #define KASUMI_IV_SIZE 8
135 #define KASUMI_BLOCK_SIZE 8
136 #define KASUMI_DIGEST_SIZE 4
137
138 /* Number of lanes AVX512, AVX2, AVX and SSE */
139 #define AVX512_NUM_SHA1_LANES 16
140 #define AVX512_NUM_SHA256_LANES 16
141 #define AVX512_NUM_SHA512_LANES 8
142 #define AVX512_NUM_MD5_LANES 32
143 #define AVX512_NUM_DES_LANES 16
144
145 #define AVX2_NUM_SHA1_LANES 8
146 #define AVX2_NUM_SHA256_LANES 8
147 #define AVX2_NUM_SHA512_LANES 4
148 #define AVX2_NUM_MD5_LANES 16
149
150 #define AVX_NUM_SHA1_LANES 4
151 #define AVX_NUM_SHA256_LANES 4
152 #define AVX_NUM_SHA512_LANES 2
153 #define AVX_NUM_MD5_LANES 8
154
155 #define SSE_NUM_SHA1_LANES AVX_NUM_SHA1_LANES
156 #define SSE_NUM_SHA256_LANES AVX_NUM_SHA256_LANES
157 #define SSE_NUM_SHA512_LANES AVX_NUM_SHA512_LANES
158 #define SSE_NUM_MD5_LANES AVX_NUM_MD5_LANES
159
160 /*
161 * Each row is sized to hold enough lanes for AVX2, AVX1 and SSE use a subset
162 * of each row. Thus one row is not adjacent in memory to its neighboring rows
163 * in the case of SSE and AVX1.
164 */
165 #define MD5_DIGEST_SZ (NUM_MD5_DIGEST_WORDS * AVX512_NUM_MD5_LANES)
166 #define SHA1_DIGEST_SZ (NUM_SHA_DIGEST_WORDS * AVX512_NUM_SHA1_LANES)
167 #define SHA256_DIGEST_SZ (NUM_SHA_256_DIGEST_WORDS * AVX512_NUM_SHA256_LANES)
168 #define SHA512_DIGEST_SZ (NUM_SHA_512_DIGEST_WORDS * AVX512_NUM_SHA512_LANES)
169
170 /*
171 * Job structure definitions
172 */
173
174 typedef enum {
175 STS_BEING_PROCESSED = 0,
176 STS_COMPLETED_AES = 1,
177 STS_COMPLETED_HMAC = 2,
178 STS_COMPLETED = 3, /* COMPLETED_AES | COMPLETED_HMAC */
179 STS_INVALID_ARGS = 4,
180 STS_INTERNAL_ERROR,
181 STS_ERROR
182 } JOB_STS;
183
184 typedef enum {
185 CBC = 1,
186 CNTR,
187 NULL_CIPHER,
188 DOCSIS_SEC_BPI,
189 #ifndef NO_GCM
190 GCM,
191 #endif /* !NO_GCM */
192 CUSTOM_CIPHER,
193 DES,
194 DOCSIS_DES,
195 CCM,
196 DES3,
197 PON_AES_CNTR,
198 ECB,
199 CNTR_BITLEN, /* 128-EEA2/NIA2 (3GPP) */
200 } JOB_CIPHER_MODE;
201
202 typedef enum {
203 ENCRYPT = 1,
204 DECRYPT
205 } JOB_CIPHER_DIRECTION;
206
207 typedef enum {
208 SHA1 = 1, /* HMAC-SHA1 */
209 SHA_224, /* HMAC-SHA224 */
210 SHA_256, /* HMAC-SHA256 */
211 SHA_384, /* HMAC-SHA384 */
212 SHA_512, /* HMAC-SHA512 */
213 AES_XCBC,
214 MD5, /* HMAC-MD5 */
215 NULL_HASH,
216 #ifndef NO_GCM
217 AES_GMAC,
218 #endif /* !NO_GCM */
219 CUSTOM_HASH,
220 AES_CCM, /* AES128-CCM */
221 AES_CMAC, /* AES128-CMAC */
222 PLAIN_SHA1, /* SHA1 */
223 PLAIN_SHA_224, /* SHA224 */
224 PLAIN_SHA_256, /* SHA256 */
225 PLAIN_SHA_384, /* SHA384 */
226 PLAIN_SHA_512, /* SHA512 */
227 AES_CMAC_BITLEN, /* 128-EIA2 (3GPP) */
228 PON_CRC_BIP
229 } JOB_HASH_ALG;
230
231 typedef enum {
232 CIPHER_HASH = 1,
233 HASH_CIPHER
234 } JOB_CHAIN_ORDER;
235
236 typedef enum {
237 AES_128_BYTES = 16,
238 AES_192_BYTES = 24,
239 AES_256_BYTES = 32
240 } AES_KEY_SIZE_BYTES;
241
242 typedef struct JOB_AES_HMAC {
243 /*
244 * For AES, aes_enc_key_expanded and aes_dec_key_expanded are
245 * expected to point to expanded keys structure.
246 * - AES-CTR, AES-ECB and AES-CCM, only aes_enc_key_expanded is used
247 * - DOCSIS (AES-CBC + AES-CFB), both pointers are used
248 * aes_enc_key_expanded has to be set always for the partial block
249 *
250 * For DES, aes_enc_key_expanded and aes_dec_key_expanded are
251 * expected to point to DES key schedule.
252 * - same key schedule used for enc and dec operations
253 *
254 * For 3DES, aes_enc_key_expanded and aes_dec_key_expanded are
255 * expected to point to an array of 3 pointers for
256 * the corresponding 3 key schedules.
257 * - same key schedule used for enc and dec operations
258 */
259 const void *aes_enc_key_expanded; /* 16-byte aligned pointer. */
260 const void *aes_dec_key_expanded;
261 uint64_t aes_key_len_in_bytes; /* 16, 24 and 32 byte (128, 192 and
262 * 256-bit) keys supported */
263 const uint8_t *src; /* Input. May be cipher text or plaintext.
264 * In-place ciphering allowed. */
265 uint8_t *dst; /*Output. May be cipher text or plaintext.
266 * In-place ciphering allowed, i.e. dst = src. */
267 uint64_t cipher_start_src_offset_in_bytes;
268 /* Max len = 65472 bytes.
269 * IPSec case, the maximum cipher
270 * length would be:
271 * 65535 -
272 * 20 (outer IP header) -
273 * 24 (ESP header + IV) -
274 * 12 (supported ICV length) */
275 union {
276 uint64_t msg_len_to_cipher_in_bytes;
277 uint64_t msg_len_to_cipher_in_bits;
278 };
279 uint64_t hash_start_src_offset_in_bytes;
280 /* Max len = 65496 bytes.
281 * (Max cipher len +
282 * 24 bytes ESP header) */
283 union {
284 uint64_t msg_len_to_hash_in_bytes;
285 uint64_t msg_len_to_hash_in_bits;
286 };
287 const uint8_t *iv; /* AES IV. */
288 uint64_t iv_len_in_bytes; /* AES IV length in bytes. */
289 uint8_t *auth_tag_output; /* HMAC Tag output. This may point to
290 * a location in the src buffer
291 * (for in place)*/
292 uint64_t auth_tag_output_len_in_bytes; /* Authentication (i.e. HMAC) tag
293 * output length in bytes
294 * (may be a truncated value) */
295
296 /* Start algorithm-specific fields */
297 union {
298 struct _HMAC_specific_fields {
299 /* Hashed result of HMAC key xor'd with ipad (0x36). */
300 const uint8_t *_hashed_auth_key_xor_ipad;
301 /* Hashed result of HMAC key xor'd with opad (0x5c). */
302 const uint8_t *_hashed_auth_key_xor_opad;
303 } HMAC;
304 struct _AES_XCBC_specific_fields {
305 /* 16-byte aligned pointers */
306 const uint32_t *_k1_expanded;
307 const uint8_t *_k2;
308 const uint8_t *_k3;
309 } XCBC;
310 struct _AES_CCM_specific_fields {
311 /* Additional Authentication Data (AAD) */
312 const void *aad;
313 uint64_t aad_len_in_bytes; /* Length of AAD */
314 } CCM;
315 struct _AES_CMAC_specific_fields {
316 const void *_key_expanded; /* 16-byte aligned */
317 const void *_skey1;
318 const void *_skey2;
319 } CMAC;
320 #ifndef NO_GCM
321 struct _AES_GCM_specific_fields {
322 /* Additional Authentication Data (AAD) */
323 const void *aad;
324 uint64_t aad_len_in_bytes; /* Length of AAD */
325 } GCM;
326 #endif /* !NO_GCM */
327 } u;
328
329 JOB_STS status;
330 JOB_CIPHER_MODE cipher_mode; /* CBC, CNTR, DES, GCM etc. */
331 JOB_CIPHER_DIRECTION cipher_direction; /* Encrypt/decrypt */
332 JOB_HASH_ALG hash_alg; /* SHA-1 or others... */
333 JOB_CHAIN_ORDER chain_order; /* CIPHER_HASH or HASH_CIPHER.
334 * For AES-CCM, when encrypting,
335 * HASH_CIPHER must be selected,
336 * and when decrypting,
337 * CIPHER_HASH must be selected. */
338
339 void *user_data;
340 void *user_data2;
341
342 /*
343 * stateless custom cipher and hash
344 * Return:
345 * success: 0
346 * fail: other
347 */
348 int (*cipher_func)(struct JOB_AES_HMAC *);
349 int (*hash_func)(struct JOB_AES_HMAC *);
350 } JOB_AES_HMAC;
351
352 /*
353 * Argument structures for various algorithms
354 */
355 typedef struct {
356 const uint8_t *in[16];
357 uint8_t *out[16];
358 const uint32_t *keys[16];
359 DECLARE_ALIGNED(uint128_t IV[16], 64);
360 DECLARE_ALIGNED(uint128_t key_tab[15][16], 64);
361 } AES_ARGS;
362
363 typedef struct {
364 DECLARE_ALIGNED(uint32_t digest[SHA1_DIGEST_SZ], 32);
365 uint8_t *data_ptr[AVX512_NUM_SHA1_LANES];
366 } SHA1_ARGS;
367
368 typedef struct {
369 DECLARE_ALIGNED(uint32_t digest[SHA256_DIGEST_SZ], 32);
370 uint8_t *data_ptr[AVX512_NUM_SHA256_LANES];
371 } SHA256_ARGS;
372
373 typedef struct {
374 DECLARE_ALIGNED(uint64_t digest[SHA512_DIGEST_SZ], 32);
375 uint8_t *data_ptr[AVX512_NUM_SHA512_LANES];
376 } SHA512_ARGS;
377
378 typedef struct {
379 DECLARE_ALIGNED(uint32_t digest[MD5_DIGEST_SZ], 32);
380 uint8_t *data_ptr[AVX512_NUM_MD5_LANES];
381 } MD5_ARGS;
382
383 typedef struct {
384 const uint8_t *in[8];
385 const uint32_t *keys[8];
386 DECLARE_ALIGNED(uint128_t ICV[8], 32);
387 } AES_XCBC_ARGS_x8;
388
389 typedef struct {
390 const uint8_t *in[AVX512_NUM_DES_LANES];
391 uint8_t *out[AVX512_NUM_DES_LANES];
392 const uint8_t *keys[AVX512_NUM_DES_LANES];
393 uint32_t IV[AVX512_NUM_DES_LANES * 2]; /* uint32_t is more handy here */
394 uint32_t partial_len[AVX512_NUM_DES_LANES];
395 uint32_t block_len[AVX512_NUM_DES_LANES];
396 const uint8_t *last_in[AVX512_NUM_DES_LANES];
397 uint8_t *last_out[AVX512_NUM_DES_LANES];
398 } DES_ARGS_x16;
399
400 /* AES out-of-order scheduler fields */
401 typedef struct {
402 AES_ARGS args;
403 DECLARE_ALIGNED(uint16_t lens[16], 16);
404 /* each nibble is index (0...15) of an unused lane,
405 * the last nibble is set to F as a flag
406 */
407 uint64_t unused_lanes;
408 JOB_AES_HMAC *job_in_lane[16];
409 uint64_t num_lanes_inuse;
410 } MB_MGR_AES_OOO;
411
412 /* AES XCBC out-of-order scheduler fields */
413 typedef struct {
414 DECLARE_ALIGNED(uint8_t final_block[2 * 16], 32);
415 JOB_AES_HMAC *job_in_lane;
416 uint64_t final_done;
417 } XCBC_LANE_DATA;
418
419 typedef struct {
420 AES_XCBC_ARGS_x8 args;
421 DECLARE_ALIGNED(uint16_t lens[8], 16);
422 /* each byte is index (0...3) of unused lanes
423 * byte 4 is set to FF as a flag
424 */
425 uint64_t unused_lanes;
426 XCBC_LANE_DATA ldata[8];
427 } MB_MGR_AES_XCBC_OOO;
428
429 /* AES-CCM out-of-order scheduler structure */
430 typedef struct {
431 AES_ARGS args; /* need to re-use AES arguments */
432 DECLARE_ALIGNED(uint16_t lens[8], 16);
433 DECLARE_ALIGNED(uint16_t init_done[8], 16);
434 /* each byte is index (0...3) of unused lanes
435 * byte 4 is set to FF as a flag
436 */
437 uint64_t unused_lanes;
438 JOB_AES_HMAC *job_in_lane[8];
439 DECLARE_ALIGNED(uint8_t init_blocks[8 * (4 * 16)], 32);
440 } MB_MGR_CCM_OOO;
441
442
443 /* AES-CMAC out-of-order scheduler structure */
444 typedef struct {
445 AES_ARGS args; /* need to re-use AES arguments */
446 DECLARE_ALIGNED(uint16_t lens[8], 16);
447 DECLARE_ALIGNED(uint16_t init_done[8], 16);
448 /* each byte is index (0...3) of unused lanes
449 * byte 4 is set to FF as a flag
450 */
451 uint64_t unused_lanes;
452 JOB_AES_HMAC *job_in_lane[8];
453 DECLARE_ALIGNED(uint8_t scratch[8 * 16], 32);
454 } MB_MGR_CMAC_OOO;
455
456
457 /* DES out-of-order scheduler fields */
458 typedef struct {
459 DES_ARGS_x16 args;
460 DECLARE_ALIGNED(uint16_t lens[16], 16);
461 /* each nibble is index (0...7) of unused lanes
462 * nibble 8 is set to F as a flag
463 */
464 uint64_t unused_lanes;
465 JOB_AES_HMAC *job_in_lane[16];
466 uint64_t num_lanes_inuse;
467 } MB_MGR_DES_OOO;
468
469
470 /* HMAC-SHA1 and HMAC-SHA256/224 */
471 typedef struct {
472 /* YMM aligned access to extra_block */
473 DECLARE_ALIGNED(uint8_t extra_block[2 * SHA1_BLOCK_SIZE+8], 32);
474 JOB_AES_HMAC *job_in_lane;
475 uint8_t outer_block[64];
476 uint32_t outer_done;
477 uint32_t extra_blocks; /* num extra blocks (1 or 2) */
478 uint32_t size_offset; /* offset in extra_block to start of
479 * size field */
480 uint32_t start_offset; /* offset to start of data */
481 } HMAC_SHA1_LANE_DATA;
482
483 /* HMAC-SHA512/384 */
484 typedef struct {
485 DECLARE_ALIGNED(uint8_t extra_block[2 * SHA_512_BLOCK_SIZE + 16], 32);
486 uint8_t outer_block[SHA_512_BLOCK_SIZE];
487 JOB_AES_HMAC *job_in_lane;
488 uint32_t outer_done;
489 uint32_t extra_blocks; /* num extra blocks (1 or 2) */
490 uint32_t size_offset; /* offset in extra_block to start of
491 * size field */
492 uint32_t start_offset; /* offset to start of data */
493 } HMAC_SHA512_LANE_DATA;
494
495 /*
496 * unused_lanes contains a list of unused lanes stored as bytes or as
497 * nibbles depending on the arch. The end of list is either FF or F.
498 */
499 typedef struct {
500 SHA1_ARGS args;
501 DECLARE_ALIGNED(uint16_t lens[16], 32);
502 uint64_t unused_lanes;
503 HMAC_SHA1_LANE_DATA ldata[AVX512_NUM_SHA1_LANES];
504 uint32_t num_lanes_inuse;
505 } MB_MGR_HMAC_SHA_1_OOO;
506
507 typedef struct {
508 SHA256_ARGS args;
509 DECLARE_ALIGNED(uint16_t lens[16], 16);
510 uint64_t unused_lanes;
511 HMAC_SHA1_LANE_DATA ldata[AVX512_NUM_SHA256_LANES];
512 uint32_t num_lanes_inuse;
513 } MB_MGR_HMAC_SHA_256_OOO;
514
515 typedef struct {
516 SHA512_ARGS args;
517 DECLARE_ALIGNED(uint16_t lens[8], 16);
518 uint64_t unused_lanes;
519 HMAC_SHA512_LANE_DATA ldata[AVX512_NUM_SHA512_LANES];
520 } MB_MGR_HMAC_SHA_512_OOO;
521
522 /* MD5-HMAC out-of-order scheduler fields */
523 typedef struct {
524 MD5_ARGS args;
525 DECLARE_ALIGNED(uint16_t lens[AVX512_NUM_MD5_LANES], 16);
526 /*
527 * In the avx2 case, all 16 nibbles of unused lanes are used.
528 * In that case num_lanes_inuse is used to detect the end of the list
529 */
530 uint64_t unused_lanes;
531 HMAC_SHA1_LANE_DATA ldata[AVX512_NUM_MD5_LANES];
532 uint32_t num_lanes_inuse;
533 } MB_MGR_HMAC_MD5_OOO;
534
535
536 /* KASUMI */
537
538 /* 64 precomputed words for key schedule */
539 #define KASUMI_KEY_SCHEDULE_SIZE 64
540
541 /**
542 * Structure to maintain internal key scheduling
543 */
544 typedef struct kasumi_key_sched_s {
545 /* Kasumi internal scheduling */
546 uint16_t sk16[KASUMI_KEY_SCHEDULE_SIZE]; /* key schedule */
547 uint16_t msk16[KASUMI_KEY_SCHEDULE_SIZE]; /* modified key schedule */
548 } kasumi_key_sched_t;
549
550 /* GCM data structures */
551 #define GCM_BLOCK_LEN 16
552
553 /**
554 * @brief holds GCM operation context
555 */
556 struct gcm_context_data {
557 /* init, update and finalize context data */
558 uint8_t aad_hash[GCM_BLOCK_LEN];
559 uint64_t aad_length;
560 uint64_t in_length;
561 uint8_t partial_block_enc_key[GCM_BLOCK_LEN];
562 uint8_t orig_IV[GCM_BLOCK_LEN];
563 uint8_t current_counter[GCM_BLOCK_LEN];
564 uint64_t partial_block_length;
565 };
566
567 /* Authenticated Tag Length in bytes.
568 * Valid values are 16 (most likely), 12 or 8. */
569 #define MAX_TAG_LEN (16)
570
571 /*
572 * IV data is limited to 16 bytes as follows:
573 * 12 bytes is provided by an application -
574 * pre-counter block j0: 4 byte salt (from Security Association)
575 * concatenated with 8 byte Initialization Vector (from IPSec ESP
576 * Payload).
577 * 4 byte value 0x00000001 is padded automatically by the library -
578 * there is no need to add these 4 bytes on application side anymore.
579 */
580 #define GCM_IV_DATA_LEN (12)
581
582 #define LONGEST_TESTED_AAD_LENGTH (2 * 1024)
583
584 /* Key lengths of 128 and 256 supported */
585 #define GCM_128_KEY_LEN (16)
586 #define GCM_192_KEY_LEN (24)
587 #define GCM_256_KEY_LEN (32)
588
589 /* #define GCM_BLOCK_LEN 16 */
590 #define GCM_ENC_KEY_LEN 16
591 #define GCM_KEY_SETS (15) /*exp key + 14 exp round keys*/
592
593 /**
594 * @brief holds intermediate key data needed to improve performance
595 *
596 * gcm_key_data hold internal key information used by gcm128, gcm192 and gcm256.
597 */
598 #ifdef __WIN32
599 __declspec(align(64))
600 #endif /* WIN32 */
601 struct gcm_key_data {
602 uint8_t expanded_keys[GCM_ENC_KEY_LEN * GCM_KEY_SETS];
603 union {
604 /* Storage for precomputed hash keys */
605 struct {
606 /*
607 * This is needed for schoolbook multiply purposes.
608 * (HashKey<<1 mod poly), (HashKey^2<<1 mod poly), ...,
609 * (Hashkey^48<<1 mod poly)
610 */
611 uint8_t shifted_hkey[GCM_ENC_KEY_LEN * 8];
612 /*
613 * This is needed for Karatsuba multiply purposes.
614 * Storage for XOR of High 64 bits and low 64 bits
615 * of HashKey mod poly.
616 *
617 * (HashKey<<1 mod poly), (HashKey^2<<1 mod poly), ...,
618 * (Hashkey^128<<1 mod poly)
619 */
620 uint8_t shifted_hkey_k[GCM_ENC_KEY_LEN * 8];
621 } sse_avx;
622 struct {
623 /*
624 * This is needed for schoolbook multiply purposes.
625 * (HashKey<<1 mod poly), (HashKey^2<<1 mod poly), ...,
626 * (Hashkey^48<<1 mod poly)
627 */
628 uint8_t shifted_hkey[GCM_ENC_KEY_LEN * 8];
629 } avx2_avx512;
630 struct {
631 #ifdef GCM_BIG_DATA
632 /*
633 * (HashKey<<1 mod poly), (HashKey^2<<1 mod poly), ...,
634 * (Hashkey^128<<1 mod poly)
635 */
636 uint8_t shifted_hkey[GCM_ENC_KEY_LEN * 128];
637 #else
638 /*
639 * (HashKey<<1 mod poly), (HashKey^2<<1 mod poly), ...,
640 * (Hashkey^48<<1 mod poly)
641 */
642 uint8_t shifted_hkey[GCM_ENC_KEY_LEN * 48];
643 #endif
644 } vaes_avx512;
645 } ghash_keys;
646 }
647 #ifdef LINUX
648 __attribute__((aligned(64)));
649 #else
650 ;
651 #endif
652
653 /* ========================================================================== */
654 /* API data type definitions */
655 struct MB_MGR;
656
657 typedef void (*init_mb_mgr_t)(struct MB_MGR *);
658 typedef JOB_AES_HMAC *(*get_next_job_t)(struct MB_MGR *);
659 typedef JOB_AES_HMAC *(*submit_job_t)(struct MB_MGR *);
660 typedef JOB_AES_HMAC *(*get_completed_job_t)(struct MB_MGR *);
661 typedef JOB_AES_HMAC *(*flush_job_t)(struct MB_MGR *);
662 typedef uint32_t (*queue_size_t)(struct MB_MGR *);
663 typedef void (*keyexp_t)(const void *, void *, void *);
664 typedef void (*cmac_subkey_gen_t)(const void *, void *, void *);
665 typedef void (*hash_one_block_t)(const void *, void *);
666 typedef void (*hash_fn_t)(const void *, const uint64_t, void *);
667 typedef void (*xcbc_keyexp_t)(const void *, void *, void *, void *);
668 typedef int (*des_keysched_t)(uint64_t *, const void *);
669 typedef void (*aes128_cfb_t)(void *, const void *, const void *, const void *,
670 uint64_t);
671 typedef void (*aes_gcm_enc_dec_t)(const struct gcm_key_data *,
672 struct gcm_context_data *,
673 uint8_t *, uint8_t const *, uint64_t,
674 const uint8_t *, uint8_t const *, uint64_t,
675 uint8_t *, uint64_t);
676 typedef void (*aes_gcm_init_t)(const struct gcm_key_data *,
677 struct gcm_context_data *,
678 const uint8_t *, uint8_t const *, uint64_t);
679 typedef void (*aes_gcm_enc_dec_update_t)(const struct gcm_key_data *,
680 struct gcm_context_data *,
681 uint8_t *, const uint8_t *, uint64_t);
682 typedef void (*aes_gcm_enc_dec_finalize_t)(const struct gcm_key_data *,
683 struct gcm_context_data *,
684 uint8_t *, uint64_t);
685 typedef void (*aes_gcm_precomp_t)(struct gcm_key_data *);
686 typedef void (*aes_gcm_pre_t)(const void *, struct gcm_key_data *);
687
688 typedef void (*zuc_eea3_1_buffer_t)(const void *, const void *, const void *,
689 void *, const uint32_t);
690
691 typedef void (*zuc_eea3_4_buffer_t)(const void * const *, const void * const *,
692 const void * const *, void **,
693 const uint32_t *);
694
695 typedef void (*zuc_eea3_n_buffer_t)(const void * const *, const void * const *,
696 const void * const *, void **,
697 const uint32_t *, const uint32_t);
698
699 typedef void (*zuc_eia3_1_buffer_t)(const void *, const void *, const void *,
700 const uint32_t, uint32_t *);
701
702 typedef void (*kasumi_f8_1_buffer_t)(const kasumi_key_sched_t *,
703 const uint64_t, const void *, void *,
704 const uint32_t);
705 typedef void (*kasumi_f8_1_buffer_bit_t)(const kasumi_key_sched_t *,
706 const uint64_t, const void *,
707 void *,
708 const uint32_t, const uint32_t);
709 typedef void (*kasumi_f8_2_buffer_t)(const kasumi_key_sched_t *,
710 const uint64_t, const uint64_t,
711 const void *, void *,
712 const uint32_t,
713 const void *, void *,
714 const uint32_t);
715 typedef void (*kasumi_f8_3_buffer_t)(const kasumi_key_sched_t *,
716 const uint64_t, const uint64_t,
717 const uint64_t,
718 const void *, void *,
719 const void *, void *,
720 const void *, void *,
721 const uint32_t);
722 typedef void (*kasumi_f8_4_buffer_t)(const kasumi_key_sched_t *,
723 const uint64_t, const uint64_t,
724 const uint64_t, const uint64_t,
725 const void *, void *,
726 const void *, void *,
727 const void *, void *,
728 const void *, void *,
729 const uint32_t);
730 typedef void (*kasumi_f8_n_buffer_t)(const kasumi_key_sched_t *,
731 const uint64_t *, const void * const *,
732 void **, const uint32_t *,
733 const uint32_t);
734 typedef void (*kasumi_f9_1_buffer_user_t)(const kasumi_key_sched_t *,
735 const uint64_t, const void *,
736 const uint32_t, void *,
737 const uint32_t);
738 typedef void (*kasumi_f9_1_buffer_t)(const kasumi_key_sched_t *,
739 const void *,
740 const uint32_t, void *);
741 typedef int (*kasumi_init_f8_key_sched_t)(const void *,
742 kasumi_key_sched_t *);
743 typedef int (*kasumi_init_f9_key_sched_t)(const void *,
744 kasumi_key_sched_t *);
745 typedef size_t (*kasumi_key_sched_size_t)(void);
746
747
748 /**
749 * Snow3G key scheduling structure
750 */
751 typedef struct snow3g_key_schedule_s {
752 /* KEY */
753 uint32_t k[4];
754 } snow3g_key_schedule_t;
755
756 typedef void (*snow3g_f8_1_buffer_t)(const snow3g_key_schedule_t *,
757 const void *, const void *,
758 void *, const uint32_t);
759
760 typedef void (*snow3g_f8_1_buffer_bit_t)(const snow3g_key_schedule_t *,
761 const void *, const void *, void *,
762 const uint32_t, const uint32_t);
763
764 typedef void (*snow3g_f8_2_buffer_t)(const snow3g_key_schedule_t *,
765 const void *, const void *,
766 const void *, void *, const uint32_t,
767 const void *, void *,const uint32_t);
768
769 typedef void (*snow3g_f8_4_buffer_t)(const snow3g_key_schedule_t *,
770 const void *, const void *,const void *,
771 const void *, const void *, void *,
772 const uint32_t, const void *, void *,
773 const uint32_t, const void *, void *,
774 const uint32_t, const void *, void *,
775 const uint32_t);
776
777 typedef void (*snow3g_f8_8_buffer_t)(const snow3g_key_schedule_t *,
778 const void *, const void *,const void *,
779 const void *, const void *, const void *,
780 const void *, const void *, const void *,
781 void *, const uint32_t, const void *,
782 void *, const uint32_t, const void *,
783 void *, const uint32_t, const void *,
784 void *, const uint32_t, const void *,
785 void *, const uint32_t, const void *,
786 void *, const uint32_t, const void *,
787 void *, const uint32_t, const void *,
788 void *, const uint32_t);
789
790 typedef void
791 (*snow3g_f8_8_buffer_multikey_t)(const snow3g_key_schedule_t * const [],
792 const void * const [], const void * const [],
793 void *[], const uint32_t[]);
794
795 typedef void (*snow3g_f8_n_buffer_t)(const snow3g_key_schedule_t *,
796 const void * const [],
797 const void * const [],
798 void *[], const uint32_t[],
799 const uint32_t);
800
801 typedef void
802 (*snow3g_f8_n_buffer_multikey_t)(const snow3g_key_schedule_t * const [],
803 const void * const [],
804 const void * const [],
805 void *[], const uint32_t[],
806 const uint32_t);
807
808 typedef void (*snow3g_f9_1_buffer_t)(const snow3g_key_schedule_t *,
809 const void *, const void *,
810 const uint64_t, void *);
811
812 typedef int (*snow3g_init_key_sched_t)(const void *,
813 snow3g_key_schedule_t *);
814
815 typedef size_t (*snow3g_key_sched_size_t)(void);
816
817 /* ========================================================================== */
818 /* Multi-buffer manager flags passed to alloc_mb_mgr() */
819
820 #define IMB_FLAG_SHANI_OFF (1ULL << 0) /* disable use of SHANI extension */
821 #define IMB_FLAG_AESNI_OFF (1ULL << 1) /* disable use of AESNI extension */
822
823 /* ========================================================================== */
824 /* Multi-buffer manager detected features
825 * - if bit is set then hardware supports given extension
826 * - valid after call to init_mb_mgr() or alloc_mb_mgr()
827 * - some HW supported features can be disabled via IMB_FLAG_xxx (see above)
828 */
829
830 #define IMB_FEATURE_SHANI (1ULL << 0)
831 #define IMB_FEATURE_AESNI (1ULL << 1)
832 #define IMB_FEATURE_PCLMULQDQ (1ULL << 2)
833 #define IMB_FEATURE_CMOV (1ULL << 3)
834 #define IMB_FEATURE_SSE4_2 (1ULL << 4)
835 #define IMB_FEATURE_AVX (1ULL << 5)
836 #define IMB_FEATURE_AVX2 (1ULL << 6)
837 #define IMB_FEATURE_AVX512F (1ULL << 7)
838 #define IMB_FEATURE_AVX512DQ (1ULL << 8)
839 #define IMB_FEATURE_AVX512CD (1ULL << 9)
840 #define IMB_FEATURE_AVX512BW (1ULL << 10)
841 #define IMB_FEATURE_AVX512VL (1ULL << 11)
842 #define IMB_FEATURE_AVX512_SKX (IMB_FEATURE_AVX512F | IMB_FEATURE_AVX512DQ | \
843 IMB_FEATURE_AVX512CD | IMB_FEATURE_AVX512BW | \
844 IMB_FEATURE_AVX512VL)
845 #define IMB_FEATURE_VAES (1ULL << 12)
846 #define IMB_FEATURE_VPCLMULQDQ (1ULL << 13)
847 #define IMB_FEATURE_SAFE_DATA (1ULL << 14)
848 #define IMB_FEATURE_SAFE_PARAM (1ULL << 15)
849
850 /* ========================================================================== */
851 /* TOP LEVEL (MB_MGR) Data structure fields */
852
853 #define MAX_JOBS 128
854
855 typedef struct MB_MGR {
856 /*
857 * flags - passed to alloc_mb_mgr()
858 * features - reflects features of multi-buffer instance
859 */
860 uint64_t flags;
861 uint64_t features;
862
863 /*
864 * Reserved for the future
865 */
866 uint64_t reserved[6];
867
868 /*
869 * ARCH handlers / API
870 * Careful as changes here can break ABI compatibility
871 */
872 get_next_job_t get_next_job;
873 submit_job_t submit_job;
874 submit_job_t submit_job_nocheck;
875 get_completed_job_t get_completed_job;
876 flush_job_t flush_job;
877 queue_size_t queue_size;
878 keyexp_t keyexp_128;
879 keyexp_t keyexp_192;
880 keyexp_t keyexp_256;
881 cmac_subkey_gen_t cmac_subkey_gen_128;
882 xcbc_keyexp_t xcbc_keyexp;
883 des_keysched_t des_key_sched;
884 hash_one_block_t sha1_one_block;
885 hash_one_block_t sha224_one_block;
886 hash_one_block_t sha256_one_block;
887 hash_one_block_t sha384_one_block;
888 hash_one_block_t sha512_one_block;
889 hash_one_block_t md5_one_block;
890 hash_fn_t sha1;
891 hash_fn_t sha224;
892 hash_fn_t sha256;
893 hash_fn_t sha384;
894 hash_fn_t sha512;
895 aes128_cfb_t aes128_cfb_one;
896
897 aes_gcm_enc_dec_t gcm128_enc;
898 aes_gcm_enc_dec_t gcm192_enc;
899 aes_gcm_enc_dec_t gcm256_enc;
900 aes_gcm_enc_dec_t gcm128_dec;
901 aes_gcm_enc_dec_t gcm192_dec;
902 aes_gcm_enc_dec_t gcm256_dec;
903 aes_gcm_init_t gcm128_init;
904 aes_gcm_init_t gcm192_init;
905 aes_gcm_init_t gcm256_init;
906 aes_gcm_enc_dec_update_t gcm128_enc_update;
907 aes_gcm_enc_dec_update_t gcm192_enc_update;
908 aes_gcm_enc_dec_update_t gcm256_enc_update;
909 aes_gcm_enc_dec_update_t gcm128_dec_update;
910 aes_gcm_enc_dec_update_t gcm192_dec_update;
911 aes_gcm_enc_dec_update_t gcm256_dec_update;
912 aes_gcm_enc_dec_finalize_t gcm128_enc_finalize;
913 aes_gcm_enc_dec_finalize_t gcm192_enc_finalize;
914 aes_gcm_enc_dec_finalize_t gcm256_enc_finalize;
915 aes_gcm_enc_dec_finalize_t gcm128_dec_finalize;
916 aes_gcm_enc_dec_finalize_t gcm192_dec_finalize;
917 aes_gcm_enc_dec_finalize_t gcm256_dec_finalize;
918 aes_gcm_precomp_t gcm128_precomp;
919 aes_gcm_precomp_t gcm192_precomp;
920 aes_gcm_precomp_t gcm256_precomp;
921 aes_gcm_pre_t gcm128_pre;
922 aes_gcm_pre_t gcm192_pre;
923 aes_gcm_pre_t gcm256_pre;
924
925 zuc_eea3_1_buffer_t eea3_1_buffer;
926 zuc_eea3_4_buffer_t eea3_4_buffer;
927 zuc_eea3_n_buffer_t eea3_n_buffer;
928 zuc_eia3_1_buffer_t eia3_1_buffer;
929
930 kasumi_f8_1_buffer_t f8_1_buffer;
931 kasumi_f8_1_buffer_bit_t f8_1_buffer_bit;
932 kasumi_f8_2_buffer_t f8_2_buffer;
933 kasumi_f8_3_buffer_t f8_3_buffer;
934 kasumi_f8_4_buffer_t f8_4_buffer;
935 kasumi_f8_n_buffer_t f8_n_buffer;
936 kasumi_f9_1_buffer_t f9_1_buffer;
937 kasumi_f9_1_buffer_user_t f9_1_buffer_user;
938 kasumi_init_f8_key_sched_t kasumi_init_f8_key_sched;
939 kasumi_init_f9_key_sched_t kasumi_init_f9_key_sched;
940 kasumi_key_sched_size_t kasumi_key_sched_size;
941
942 snow3g_f8_1_buffer_bit_t snow3g_f8_1_buffer_bit;
943 snow3g_f8_1_buffer_t snow3g_f8_1_buffer;
944 snow3g_f8_2_buffer_t snow3g_f8_2_buffer;
945 snow3g_f8_4_buffer_t snow3g_f8_4_buffer;
946 snow3g_f8_8_buffer_t snow3g_f8_8_buffer;
947 snow3g_f8_n_buffer_t snow3g_f8_n_buffer;
948 snow3g_f8_8_buffer_multikey_t snow3g_f8_8_buffer_multikey;
949 snow3g_f8_n_buffer_multikey_t snow3g_f8_n_buffer_multikey;
950 snow3g_f9_1_buffer_t snow3g_f9_1_buffer;
951 snow3g_init_key_sched_t snow3g_init_key_sched;
952 snow3g_key_sched_size_t snow3g_key_sched_size;
953
954 /* in-order scheduler fields */
955 int earliest_job; /* byte offset, -1 if none */
956 int next_job; /* byte offset */
957 JOB_AES_HMAC jobs[MAX_JOBS];
958
959 /* out of order managers */
960 DECLARE_ALIGNED(MB_MGR_AES_OOO aes128_ooo, 64);
961 DECLARE_ALIGNED(MB_MGR_AES_OOO aes192_ooo, 64);
962 DECLARE_ALIGNED(MB_MGR_AES_OOO aes256_ooo, 64);
963 DECLARE_ALIGNED(MB_MGR_AES_OOO docsis_sec_ooo, 64);
964 DECLARE_ALIGNED(MB_MGR_DES_OOO des_enc_ooo, 64);
965 DECLARE_ALIGNED(MB_MGR_DES_OOO des_dec_ooo, 64);
966 DECLARE_ALIGNED(MB_MGR_DES_OOO des3_enc_ooo, 64);
967 DECLARE_ALIGNED(MB_MGR_DES_OOO des3_dec_ooo, 64);
968 DECLARE_ALIGNED(MB_MGR_DES_OOO docsis_des_enc_ooo, 64);
969 DECLARE_ALIGNED(MB_MGR_DES_OOO docsis_des_dec_ooo, 64);
970
971 DECLARE_ALIGNED(MB_MGR_HMAC_SHA_1_OOO hmac_sha_1_ooo, 64);
972 DECLARE_ALIGNED(MB_MGR_HMAC_SHA_256_OOO hmac_sha_224_ooo, 64);
973 DECLARE_ALIGNED(MB_MGR_HMAC_SHA_256_OOO hmac_sha_256_ooo, 64);
974 DECLARE_ALIGNED(MB_MGR_HMAC_SHA_512_OOO hmac_sha_384_ooo, 64);
975 DECLARE_ALIGNED(MB_MGR_HMAC_SHA_512_OOO hmac_sha_512_ooo, 64);
976 DECLARE_ALIGNED(MB_MGR_HMAC_MD5_OOO hmac_md5_ooo, 64);
977 DECLARE_ALIGNED(MB_MGR_AES_XCBC_OOO aes_xcbc_ooo, 64);
978 DECLARE_ALIGNED(MB_MGR_CCM_OOO aes_ccm_ooo, 64);
979 DECLARE_ALIGNED(MB_MGR_CMAC_OOO aes_cmac_ooo, 64);
980 } MB_MGR;
981
982 /* ========================================================================== */
983 /* API definitions */
984
985 /**
986 * @brief Get library version in string format
987 *
988 * @return library version string
989 */
990 IMB_DLL_EXPORT const char *imb_get_version_str(void);
991
992 /**
993 * @brief Get library version in numerical format
994 *
995 * Use IMB_VERSION() macro to compare this
996 * numerical version against known library version.
997 *
998 * @return library version number
999 */
1000 IMB_DLL_EXPORT unsigned imb_get_version(void);
1001
1002 /*
1003 * get_next_job returns a job object. This must be filled in and returned
1004 * via submit_job before get_next_job is called again.
1005 * After submit_job is called, one should call get_completed_job() at least
1006 * once (and preferably until it returns NULL).
1007 * get_completed_job and flush_job returns a job object. This job object ceases
1008 * to be usable at the next call to get_next_job
1009 */
1010 IMB_DLL_EXPORT MB_MGR *alloc_mb_mgr(uint64_t flags);
1011 IMB_DLL_EXPORT void free_mb_mgr(MB_MGR *state);
1012
1013 IMB_DLL_EXPORT void init_mb_mgr_avx(MB_MGR *state);
1014 IMB_DLL_EXPORT JOB_AES_HMAC *submit_job_avx(MB_MGR *state);
1015 IMB_DLL_EXPORT JOB_AES_HMAC *submit_job_nocheck_avx(MB_MGR *state);
1016 IMB_DLL_EXPORT JOB_AES_HMAC *flush_job_avx(MB_MGR *state);
1017 IMB_DLL_EXPORT uint32_t queue_size_avx(MB_MGR *state);
1018 IMB_DLL_EXPORT JOB_AES_HMAC *get_completed_job_avx(MB_MGR *state);
1019 IMB_DLL_EXPORT JOB_AES_HMAC *get_next_job_avx(MB_MGR *state);
1020
1021 IMB_DLL_EXPORT void init_mb_mgr_avx2(MB_MGR *state);
1022 IMB_DLL_EXPORT JOB_AES_HMAC *submit_job_avx2(MB_MGR *state);
1023 IMB_DLL_EXPORT JOB_AES_HMAC *submit_job_nocheck_avx2(MB_MGR *state);
1024 IMB_DLL_EXPORT JOB_AES_HMAC *flush_job_avx2(MB_MGR *state);
1025 IMB_DLL_EXPORT uint32_t queue_size_avx2(MB_MGR *state);
1026 IMB_DLL_EXPORT JOB_AES_HMAC *get_completed_job_avx2(MB_MGR *state);
1027 IMB_DLL_EXPORT JOB_AES_HMAC *get_next_job_avx2(MB_MGR *state);
1028
1029 IMB_DLL_EXPORT void init_mb_mgr_avx512(MB_MGR *state);
1030 IMB_DLL_EXPORT JOB_AES_HMAC *submit_job_avx512(MB_MGR *state);
1031 IMB_DLL_EXPORT JOB_AES_HMAC *submit_job_nocheck_avx512(MB_MGR *state);
1032 IMB_DLL_EXPORT JOB_AES_HMAC *flush_job_avx512(MB_MGR *state);
1033 IMB_DLL_EXPORT uint32_t queue_size_avx512(MB_MGR *state);
1034 IMB_DLL_EXPORT JOB_AES_HMAC *get_completed_job_avx512(MB_MGR *state);
1035 IMB_DLL_EXPORT JOB_AES_HMAC *get_next_job_avx512(MB_MGR *state);
1036
1037 IMB_DLL_EXPORT void init_mb_mgr_sse(MB_MGR *state);
1038 IMB_DLL_EXPORT JOB_AES_HMAC *submit_job_sse(MB_MGR *state);
1039 IMB_DLL_EXPORT JOB_AES_HMAC *submit_job_nocheck_sse(MB_MGR *state);
1040 IMB_DLL_EXPORT JOB_AES_HMAC *flush_job_sse(MB_MGR *state);
1041 IMB_DLL_EXPORT uint32_t queue_size_sse(MB_MGR *state);
1042 IMB_DLL_EXPORT JOB_AES_HMAC *get_completed_job_sse(MB_MGR *state);
1043 IMB_DLL_EXPORT JOB_AES_HMAC *get_next_job_sse(MB_MGR *state);
1044
1045 /*
1046 * Wrapper macros to call arch API's set up
1047 * at init phase of multi-buffer manager.
1048 *
1049 * For example, after calling init_mb_mgr_sse(&mgr)
1050 * The 'mgr' structure be set up so that:
1051 * mgr.get_next_job will point to get_next_job_sse(),
1052 * mgr.submit_job will point to submit_job_sse(),
1053 * mgr.submit_job_nocheck will point to submit_job_nocheck_sse(),
1054 * mgr.get_completed_job will point to get_completed_job_sse(),
1055 * mgr.flush_job will point to flush_job_sse(),
1056 * mgr.queue_size will point to queue_size_sse()
1057 * mgr.keyexp_128 will point to aes_keyexp_128_sse()
1058 * mgr.keyexp_192 will point to aes_keyexp_192_sse()
1059 * mgr.keyexp_256 will point to aes_keyexp_256_sse()
1060 * etc.
1061 *
1062 * Direct use of arch API's may result in better performance.
1063 * Using below indirect interface may produce slightly worse performance but
1064 * it can simplify application implementation.
1065 * LibTestApp provides example of using the indirect interface.
1066 */
1067 #define IMB_GET_NEXT_JOB(_mgr) ((_mgr)->get_next_job((_mgr)))
1068 #define IMB_SUBMIT_JOB(_mgr) ((_mgr)->submit_job((_mgr)))
1069 #define IMB_SUBMIT_JOB_NOCHECK(_mgr) ((_mgr)->submit_job_nocheck((_mgr)))
1070 #define IMB_GET_COMPLETED_JOB(_mgr) ((_mgr)->get_completed_job((_mgr)))
1071 #define IMB_FLUSH_JOB(_mgr) ((_mgr)->flush_job((_mgr)))
1072 #define IMB_QUEUE_SIZE(_mgr) ((_mgr)->queue_size((_mgr)))
1073
1074 /* Key expansion and generation API's */
1075 #define IMB_AES_KEYEXP_128(_mgr, _raw, _enc, _dec) \
1076 ((_mgr)->keyexp_128((_raw), (_enc), (_dec)))
1077 #define IMB_AES_KEYEXP_192(_mgr, _raw, _enc, _dec) \
1078 ((_mgr)->keyexp_192((_raw), (_enc), (_dec)))
1079 #define IMB_AES_KEYEXP_256(_mgr, _raw, _enc, _dec) \
1080 ((_mgr)->keyexp_256((_raw), (_enc), (_dec)))
1081
1082 #define IMB_AES_CMAC_SUBKEY_GEN_128(_mgr, _key_exp, _k1, _k2) \
1083 ((_mgr)->cmac_subkey_gen_128((_key_exp), (_k1), (_k2)))
1084
1085 #define IMB_AES_XCBC_KEYEXP(_mgr, _key, _k1_exp, _k2, _k3) \
1086 ((_mgr)->xcbc_keyexp((_key), (_k1_exp), (_k2), (_k3)))
1087
1088 #define IMB_DES_KEYSCHED(_mgr, _ks, _key) \
1089 ((_mgr)->des_key_sched((_ks), (_key)))
1090
1091 /* Hash API's */
1092 #define IMB_SHA1_ONE_BLOCK(_mgr, _data, _digest) \
1093 ((_mgr)->sha1_one_block((_data), (_digest)))
1094 #define IMB_SHA1(_mgr, _data, _length, _digest) \
1095 ((_mgr)->sha1((_data), (_length), (_digest)))
1096 #define IMB_SHA224_ONE_BLOCK(_mgr, _data, _digest) \
1097 ((_mgr)->sha224_one_block((_data), (_digest)))
1098 #define IMB_SHA224(_mgr, _data, _length, _digest) \
1099 ((_mgr)->sha224((_data), (_length), (_digest)))
1100 #define IMB_SHA256_ONE_BLOCK(_mgr, _data, _digest) \
1101 ((_mgr)->sha256_one_block((_data), (_digest)))
1102 #define IMB_SHA256(_mgr, _data, _length, _digest) \
1103 ((_mgr)->sha256((_data), (_length), (_digest)))
1104 #define IMB_SHA384_ONE_BLOCK(_mgr, _data, _digest) \
1105 ((_mgr)->sha384_one_block((_data), (_digest)))
1106 #define IMB_SHA384(_mgr, _data, _length, _digest) \
1107 ((_mgr)->sha384((_data), (_length), (_digest)))
1108 #define IMB_SHA512_ONE_BLOCK(_mgr, _data, _digest) \
1109 ((_mgr)->sha512_one_block((_data), (_digest)))
1110 #define IMB_SHA512(_mgr, _data, _length, _digest) \
1111 ((_mgr)->sha512((_data), (_length), (_digest)))
1112 #define IMB_MD5_ONE_BLOCK(_mgr, _data, _digest) \
1113 ((_mgr)->md5_one_block((_data), (_digest)))
1114
1115 /* AES-CFB API */
1116 #define IMB_AES128_CFB_ONE(_mgr, _out, _in, _iv, _enc, _len) \
1117 ((_mgr)->aes128_cfb_one((_out), (_in), (_iv), (_enc), (_len)))
1118
1119 /* AES-GCM API's */
1120 #define IMB_AES128_GCM_ENC(_mgr, _key, _ctx, _out, _in, _len, _iv, _aad, _aadl,\
1121 _tag, _tagl) \
1122 ((_mgr)->gcm128_enc((_key), (_ctx), (_out), (_in), (_len), (_iv), \
1123 (_aad), (_aadl), (_tag), (_tagl)))
1124 #define IMB_AES192_GCM_ENC(_mgr, _key, _ctx, _out, _in, _len, _iv, _aad, _aadl,\
1125 _tag, _tagl) \
1126 ((_mgr)->gcm192_enc((_key), (_ctx), (_out), (_in), (_len), (_iv), \
1127 (_aad), (_aadl), (_tag), (_tagl)))
1128 #define IMB_AES256_GCM_ENC(_mgr, _key, _ctx, _out, _in, _len, _iv, _aad, _aadl,\
1129 _tag, _tagl) \
1130 ((_mgr)->gcm256_enc((_key), (_ctx), (_out), (_in), (_len), (_iv), \
1131 (_aad), (_aadl), (_tag), (_tagl)))
1132
1133 #define IMB_AES128_GCM_DEC(_mgr, _key, _ctx, _out, _in, _len, _iv, _aad, _aadl,\
1134 _tag, _tagl) \
1135 ((_mgr)->gcm128_dec((_key), (_ctx), (_out), (_in), (_len), (_iv), \
1136 (_aad), (_aadl), (_tag), (_tagl)))
1137 #define IMB_AES192_GCM_DEC(_mgr, _key, _ctx, _out, _in, _len, _iv, _aad, _aadl,\
1138 _tag, _tagl) \
1139 ((_mgr)->gcm192_dec((_key), (_ctx), (_out), (_in), (_len), (_iv), \
1140 (_aad), (_aadl), (_tag), (_tagl)))
1141 #define IMB_AES256_GCM_DEC(_mgr, _key, _ctx, _out, _in, _len, _iv, _aad, _aadl,\
1142 _tag, _tagl) \
1143 ((_mgr)->gcm256_dec((_key), (_ctx), (_out), (_in), (_len), (_iv), \
1144 (_aad), (_aadl), (_tag), (_tagl)))
1145
1146 #define IMB_AES128_GCM_INIT(_mgr, _key, _ctx, _iv, _aad, _aadl) \
1147 ((_mgr)->gcm128_init((_key), (_ctx), (_iv), (_aad), (_aadl)))
1148 #define IMB_AES192_GCM_INIT(_mgr, _key, _ctx, _iv, _aad, _aadl) \
1149 ((_mgr)->gcm192_init((_key), (_ctx), (_iv), (_aad), (_aadl)))
1150 #define IMB_AES256_GCM_INIT(_mgr, _key, _ctx, _iv, _aad, _aadl) \
1151 ((_mgr)->gcm256_init((_key), (_ctx), (_iv), (_aad), (_aadl)))
1152
1153 #define IMB_AES128_GCM_ENC_UPDATE(_mgr, _key, _ctx, _out, _in, _len) \
1154 ((_mgr)->gcm128_enc_update((_key), (_ctx), (_out), (_in), (_len)))
1155 #define IMB_AES192_GCM_ENC_UPDATE(_mgr, _key, _ctx, _out, _in, _len) \
1156 ((_mgr)->gcm192_enc_update((_key), (_ctx), (_out), (_in), (_len)))
1157 #define IMB_AES256_GCM_ENC_UPDATE(_mgr, _key, _ctx, _out, _in, _len) \
1158 ((_mgr)->gcm256_enc_update((_key), (_ctx), (_out), (_in), (_len)))
1159
1160 #define IMB_AES128_GCM_DEC_UPDATE(_mgr, _key, _ctx, _out, _in, _len) \
1161 ((_mgr)->gcm128_dec_update((_key), (_ctx), (_out), (_in), (_len)))
1162 #define IMB_AES192_GCM_DEC_UPDATE(_mgr, _key, _ctx, _out, _in, _len) \
1163 ((_mgr)->gcm192_dec_update((_key), (_ctx), (_out), (_in), (_len)))
1164 #define IMB_AES256_GCM_DEC_UPDATE(_mgr, _key, _ctx, _out, _in, _len) \
1165 ((_mgr)->gcm256_dec_update((_key), (_ctx), (_out), (_in), (_len)))
1166
1167 #define IMB_AES128_GCM_ENC_FINALIZE(_mgr, _key, _ctx, _tag, _tagl) \
1168 ((_mgr)->gcm128_enc_finalize((_key), (_ctx), (_tag), (_tagl)))
1169 #define IMB_AES192_GCM_ENC_FINALIZE(_mgr, _key, _ctx, _tag, _tagl) \
1170 ((_mgr)->gcm192_enc_finalize((_key), (_ctx), (_tag), (_tagl)))
1171 #define IMB_AES256_GCM_ENC_FINALIZE(_mgr, _key, _ctx, _tag, _tagl) \
1172 ((_mgr)->gcm256_enc_finalize((_key), (_ctx), (_tag), (_tagl)))
1173
1174 #define IMB_AES128_GCM_DEC_FINALIZE(_mgr, _key, _ctx, _tag, _tagl) \
1175 ((_mgr)->gcm128_dec_finalize((_key), (_ctx), (_tag), (_tagl)))
1176 #define IMB_AES192_GCM_DEC_FINALIZE(_mgr, _key, _ctx, _tag, _tagl) \
1177 ((_mgr)->gcm192_dec_finalize((_key), (_ctx), (_tag), (_tagl)))
1178 #define IMB_AES256_GCM_DEC_FINALIZE(_mgr, _key, _ctx, _tag, _tagl) \
1179 ((_mgr)->gcm256_dec_finalize((_key), (_ctx), (_tag), (_tagl)))
1180
1181 #define IMB_AES128_GCM_PRECOMP(_mgr, _key) \
1182 ((_mgr)->gcm128_precomp((_key)))
1183 #define IMB_AES192_GCM_PRECOMP(_mgr, _key) \
1184 ((_mgr)->gcm192_precomp((_key)))
1185 #define IMB_AES256_GCM_PRECOMP(_mgr, _key) \
1186 ((_mgr)->gcm256_precomp((_key)))
1187
1188 #define IMB_AES128_GCM_PRE(_mgr, _key_in, _key_exp) \
1189 ((_mgr)->gcm128_pre((_key_in), (_key_exp)))
1190 #define IMB_AES192_GCM_PRE(_mgr, _key_in, _key_exp) \
1191 ((_mgr)->gcm192_pre((_key_in), (_key_exp)))
1192 #define IMB_AES256_GCM_PRE(_mgr, _key_in, _key_exp) \
1193 ((_mgr)->gcm256_pre((_key_in), (_key_exp)))
1194
1195 /* ZUC EEA3/EIA3 functions */
1196
1197 /**
1198 * @brief ZUC EEA3 Confidentiality functions
1199 *
1200 * @param mgr Pointer to multi-buffer structure
1201 * @param key Pointer to key
1202 * @param iv Pointer to 16-byte IV
1203 * @param in Pointer to Plaintext/Ciphertext input.
1204 * @param out Pointer to Ciphertext/Plaintext output.
1205 * @param len Length of input data in bytes.
1206 */
1207 #define IMB_ZUC_EEA3_1_BUFFER(_mgr, _key, _iv, _in, _out, _len) \
1208 ((_mgr)->eea3_1_buffer((_key), (_iv), (_in), (_out), (_len)))
1209 #define IMB_ZUC_EEA3_4_BUFFER(_mgr, _key, _iv, _in, _out, _len) \
1210 ((_mgr)->eea3_4_buffer((_key), (_iv), (_in), (_out), (_len)))
1211 #define IMB_ZUC_EEA3_N_BUFFER(_mgr, _key, _iv, _in, _out, _len, _num) \
1212 ((_mgr)->eea3_n_buffer((_key), (_iv), (_in), (_out), (_len), (_num)))
1213
1214
1215 /**
1216 * @brief ZUC EIA3 Integrity function
1217 *
1218 * @param mgr Pointer to multi-buffer structure
1219 * @param key Pointer to key
1220 * @param iv Pointer to 16-byte IV
1221 * @param in Pointer to Plaintext/Ciphertext input.
1222 * @param len Length of input data in bits.
1223 * @param tag Pointer to Authenticated Tag output (4 bytes)
1224 */
1225 #define IMB_ZUC_EIA3_1_BUFFER(_mgr, _key, _iv, _in, _len, _tag) \
1226 ((_mgr)->eia3_1_buffer((_key), (_iv), (_in), (_len), (_tag)))
1227
1228
1229 /* KASUMI F8/F9 functions */
1230
1231 /**
1232 * @brief Kasumi byte-level f8 operation on a single buffer
1233 *
1234 * This function performs kasumi f8 operation on a single buffer. The key has
1235 * already been scheduled with kasumi_init_f8_key_sched().
1236 * No extra bits are modified.
1237 *
1238 * @param [in] ctx Context where the scheduled keys are stored
1239 * @param [in] iv Initialization vector
1240 * @param [in] in Input buffer
1241 * @param [out] out Output buffer
1242 * @param [in] len Length in BYTES
1243 *
1244 ******************************************************************************/
1245 #define IMB_KASUMI_F8_1_BUFFER(_mgr, _ctx, _iv, _in, _out, _len) \
1246 ((_mgr)->f8_1_buffer((_ctx), (_iv), (_in), (_out), (_len)))
1247
1248 /**
1249 * @brief Kasumi bit-level f8 operation on a single buffer
1250 *
1251 * This function performs kasumi f8 operation on a single buffer. The key has
1252 * already been scheduled with kasumi_init_f8_key_sched().
1253 * No extra bits are modified.
1254 *
1255 * @param [in] ctx Context where the scheduled keys are stored
1256 * @param [in] iv Initialization vector
1257 * @param [in] in Input buffer
1258 * @param [out] out Output buffer
1259 * @param [in] len Length in BITS
1260 * @param [in] offset Offset in BITS from begin of input buffer
1261 *
1262 ******************************************************************************/
1263 #define IMB_KASUMI_F8_1_BUFFER_BIT(_mgr, _ctx, _iv, _in, _out, _len, _offset) \
1264 ((_mgr)->f8_1_buffer_bit((_ctx), (_iv), (_in), (_out), (_len), \
1265 (_offset)))
1266
1267 /**
1268 * @brief Kasumi byte-level f8 operation in parallel on two buffers
1269 *
1270 * This function performs kasumi f8 operation on a two buffers.
1271 * They will be processed with the same key, which has already been scheduled
1272 * with kasumi_init_f8_key_sched().
1273 *
1274 * @param [in] ctx Context where the scheduled keys are stored
1275 * @param [in] iv1 Initialization vector for buffer in1
1276 * @param [in] iv2 Initialization vector for buffer in2
1277 * @param [in] in1 Input buffer 1
1278 * @param [out] out1 Output buffer 1
1279 * @param [in] len1 Length in BYTES of input buffer 1
1280 * @param [in] in2 Input buffer 2
1281 * @param [out] out2 Output buffer 2
1282 * @param [in] len2 Length in BYTES of input buffer 2
1283 *
1284 ******************************************************************************/
1285 #define IMB_KASUMI_F8_2_BUFFER(_mgr, _ctx, _iv1, _iv2, _in1, _out1, _len1, \
1286 _in2, _out2, _len2) \
1287 ((_mgr)->f8_2_buffer((_ctx), (_iv1), (_iv2), (_in1), (_out1), (_len1), \
1288 (_in2), (_out2), (_len2)))
1289 /**
1290 * @brief kasumi byte-level f8 operation in parallel on three buffers
1291 *
1292 * This function performs kasumi f8 operation on a three buffers.
1293 * They must all have the same length and they will be processed with the same
1294 * key, which has already been scheduled with kasumi_init_f8_key_sched().
1295 *
1296 * @param [in] ctx Context where the scheduled keys are stored
1297 * @param [in] iv1 Initialization vector for buffer in1
1298 * @param [in] iv2 Initialization vector for buffer in2
1299 * @param [in] iv3 Initialization vector for buffer in3
1300 * @param [in] in1 Input buffer 1
1301 * @param [out] out1 Output buffer 1
1302 * @param [in] in2 Input buffer 2
1303 * @param [out] out2 Output buffer 2
1304 * @param [in] in3 Input buffer 3
1305 * @param [out] out3 Output buffer 3
1306 * @param [in] len Common length in bytes for all buffers
1307 *
1308 ******************************************************************************/
1309 #define IMB_KASUMI_F8_3_BUFFER(_mgr, _ctx, _iv1, _iv2, _iv3, _in1, _out1, \
1310 _in2, _out2, _in3, _out3, _len) \
1311 ((_mgr)->f8_3_buffer((_ctx), (_iv1), (_iv2), (_iv3), (_in1), (_out1), \
1312 (_in2), (_out2), (_in3), (_out3), (_len)))
1313 /**
1314 * @brief kasumi byte-level f8 operation in parallel on four buffers
1315 *
1316 * This function performs kasumi f8 operation on four buffers.
1317 * They must all have the same length and they will be processed with the same
1318 * key, which has already been scheduled with kasumi_init_f8_key_sched().
1319 *
1320 * @param [in] ctx Context where the scheduled keys are stored
1321 * @param [in] iv1 Initialization vector for buffer in1
1322 * @param [in] iv2 Initialization vector for buffer in2
1323 * @param [in] iv3 Initialization vector for buffer in3
1324 * @param [in] iv4 Initialization vector for buffer in4
1325 * @param [in] in1 Input buffer 1
1326 * @param [out] out1 Output buffer 1
1327 * @param [in] in2 Input buffer 2
1328 * @param [out] out2 Output buffer 2
1329 * @param [in] in3 Input buffer 3
1330 * @param [out] out3 Output buffer 3
1331 * @param [in] in4 Input buffer 4
1332 * @param [out] out4 Output buffer 4
1333 * @param [in] len Common length in bytes for all buffers
1334 *
1335 ******************************************************************************/
1336 #define IMB_KASUMI_F8_4_BUFFER(_mgr, _ctx, _iv1, _iv2, _iv3, _iv4, \
1337 _in1, _out1, _in2, _out2, _in3, _out3, \
1338 _in4, _out4, _len) \
1339 ((_mgr)->f8_4_buffer((_ctx), (_iv1), (_iv2), (_iv3), (_iv4), \
1340 (_in1), (_out1), (_in2), (_out2), \
1341 (_in3), (_out3), (_in4), (_out4), (_len)))
1342 /**
1343 * @brief Kasumi f8 operation on N buffers
1344 *
1345 * All input buffers can have different lengths and they will be processed
1346 * with the same key, which has already been scheduled
1347 * with kasumi_init_f8_key_sched().
1348 *
1349 * @param [in] ctx Context where the scheduled keys are stored
1350 * @param [in] iv Array of IV values
1351 * @param [in] in Array of input buffers
1352 * @param [out] out Array of output buffers
1353 * @param [in] len Array of corresponding input buffer lengths in BITS
1354 * @param [in] count Number of input buffers
1355 */
1356 #define IMB_KASUMI_F8_N_BUFFER(_mgr, _ctx, _iv, _in, _out, _len, _count) \
1357 ((_mgr)->f8_n_buffer((_ctx), (_iv), (_in), (_out), (_len), \
1358 (_count)))
1359 /**
1360 * @brief Kasumi bit-level f9 operation on a single buffer.
1361 *
1362 * The first QWORD of in represents the COUNT and FRESH, the last QWORD
1363 * represents the DIRECTION and PADDING. (See 3GPP TS 35.201 v10.0 section 4)
1364 *
1365 * The key has already been scheduled with kasumi_init_f9_key_sched().
1366 *
1367 * @param [in] ctx Context where the scheduled keys are stored
1368 * @param [in] in Input buffer
1369 * @param [in] len Length in BYTES of the data to be hashed
1370 * @param [out] tag Computed digest
1371 *
1372 */
1373 #define IMB_KASUMI_F9_1_BUFFER(_mgr, _ctx, _in, _len, _tag) \
1374 ((_mgr)->f9_1_buffer((_ctx), (_in), (_len), (_tag)))
1375
1376 /**
1377 * @brief Kasumi bit-level f9 operation on a single buffer.
1378 *
1379 * The key has already been scheduled with kasumi_init_f9_key_sched().
1380 *
1381 * @param [in] ctx Context where the scheduled keys are stored
1382 * @param [in] iv Initialization vector
1383 * @param [in] in Input buffer
1384 * @param [in] len Length in BITS of the data to be hashed
1385 * @param [out] tag Computed digest
1386 * @param [in] dir Direction bit
1387 *
1388 */
1389 #define IMB_KASUMI_F9_1_BUFFER_USER(_mgr, _ctx, _iv, _in, _len, _tag, _dir) \
1390 ((_mgr)->f9_1_buffer_user((_ctx), (_iv), (_in), (_len), \
1391 (_tag), (_dir)))
1392
1393 /**
1394 * KASUMI F8 key schedule init function.
1395 *
1396 * @param[in] mgr Pointer to multi-buffer structure
1397 * @param[in] key Confidentiality key (expected in LE format)
1398 * @param[out] ctx Key schedule context to be initialised
1399 * @return 0 on success, -1 on failure
1400 *
1401 ******************************************************************************/
1402 #define IMB_KASUMI_INIT_F8_KEY_SCHED(_mgr, _key, _ctx) \
1403 ((_mgr)->kasumi_init_f8_key_sched((_key), (_ctx)))
1404
1405 /**
1406 * KASUMI F9 key schedule init function.
1407 *
1408 * @param[in] mgr Pointer to multi-buffer structure
1409 * @param[in] key Integrity key (expected in LE format)
1410 * @param[out] ctx Key schedule context to be initialised
1411 * @return 0 on success, -1 on failure
1412 *
1413 ******************************************************************************/
1414 #define IMB_KASUMI_INIT_F9_KEY_SCHED(_mgr, _key, _ctx) \
1415 ((_mgr)->kasumi_init_f9_key_sched((_key), (_ctx)))
1416
1417 /**
1418 *******************************************************************************
1419 * This function returns the size of the kasumi_key_sched_t, used
1420 * to store the key schedule.
1421 *
1422 * @param[in] mgr Pointer to multi-buffer structure
1423 * @return size of kasumi_key_sched_t type success
1424 *
1425 ******************************************************************************/
1426 #define IMB_KASUMI_KEY_SCHED_SIZE(_mgr)((_mgr)->kasumi_key_sched_size())
1427
1428
1429 /* SNOW3G F8/F9 functions */
1430
1431 /**
1432 * This function performs snow3g f8 operation on a single buffer. The key has
1433 * already been scheduled with snow3g_init_key_sched().
1434 *
1435 * @param[in] mgr Pointer to multi-buffer structure
1436 * @param[in] ctx Context where the scheduled keys are stored
1437 * @param[in] iv iv[3] = count
1438 * iv[2] = (bearer << 27) | ((dir & 0x1) << 26)
1439 * iv[1] = pIV[3]
1440 * iv[0] = pIV[2]
1441 * @param[in] in Input buffer
1442 * @param[out] out Output buffer
1443 * @param[in] len Length in bits of input buffer
1444 * @param[in] offset Offset in input/output buffer (in bits)
1445 */
1446 #define IMB_SNOW3G_F8_1_BUFFER_BIT(_mgr, _ctx, _iv, _in, _out, _len, _offset) \
1447 ((_mgr)->snow3g_f8_1_buffer_bit((_ctx), (_iv), (_in), \
1448 (_out), (_len), (_offset)))
1449
1450 /**
1451 * This function performs snow3g f8 operation on a single buffer. The key has
1452 * already been scheduled with snow3g_init_key_sched().
1453 *
1454 * @param[in] mgr Pointer to multi-buffer structure
1455 * @param[in] ctx Context where the scheduled keys are stored
1456 * @param[in] iv iv[3] = count
1457 * iv[2] = (bearer << 27) | ((dir & 0x1) << 26)
1458 * iv[1] = pIV[3]
1459 * iv[0] = pIV[2]
1460 * @param[in] in Input buffer
1461 * @param[out] out Output buffer
1462 * @param[in] len Length in bits of input buffer
1463 */
1464 #define IMB_SNOW3G_F8_1_BUFFER(_mgr, _ctx, _iv, _in, _out, _len) \
1465 ((_mgr)->snow3g_f8_1_buffer((_ctx), (_iv), (_in), (_out), (_len)))
1466
1467 /**
1468 * This function performs snow3g f8 operation on two buffers. They will
1469 * be processed with the same key, which has already been scheduled with
1470 * snow3g_init_key_sched().
1471 *
1472 * @param[in] mgr Pointer to multi-buffer structure
1473 * @param[in] ctx Context where the scheduled keys are stored
1474 * @param[in] iv1 IV to use for buffer pBufferIn1
1475 * @param[in] iv2 IV to use for buffer pBufferIn2
1476 * @param[in] in1 Input buffer 1
1477 * @param[out] out1 Output buffer 1
1478 * @param[in] len1 Length in bytes of input buffer 1
1479 * @param[in] in2 Input buffer 2
1480 * @param[out] out2 Output buffer 2
1481 * @param[in] len2 Length in bytes of input buffer 2
1482 */
1483 #define IMB_SNOW3G_F8_2_BUFFER(_mgr, _ctx, _iv1, _iv2, \
1484 _in1, _out1, _len1, \
1485 _in2, _out2, _len2) \
1486 ((_mgr)->snow3g_f8_2_buffer((_ctx), (_iv1), (_iv2), \
1487 (_in1), (_out1), (_len1), \
1488 (_in2), (_out2), (_len2)))
1489
1490 /**
1491 *******************************************************************************
1492 * This function performs snow3g f8 operation on four buffers. They will
1493 * be processed with the same key, which has already been scheduled with
1494 * snow3g_init_key_sched().
1495 *
1496 * @param[in] mgr Pointer to multi-buffer structure
1497 * @param[in] ctx Context where the scheduled keys are stored
1498 * @param[in] iv1 IV to use for buffer pBufferIn1
1499 * @param[in] iv2 IV to use for buffer pBufferIn2
1500 * @param[in] iv3 IV to use for buffer pBufferIn3
1501 * @param[in] iv4 IV to use for buffer pBufferIn4
1502 * @param[in] in1 Input buffer 1
1503 * @param[out] out1 Output buffer 1
1504 * @param[in] len1 Length in bytes of input buffer 1
1505 * @param[in] in2 Input buffer 2
1506 * @param[out] out2 Output buffer 2
1507 * @param[in] len2 Length in bytes of input buffer 2
1508 * @param[in] in3 Input buffer 3
1509 * @param[out] out3 Output buffer 3
1510 * @param[in] len3 Length in bytes of input buffer 3
1511 * @param[in] in4 Input buffer 4
1512 * @param[out] out4 Output buffer 4
1513 * @param[in] len4 Length in bytes of input buffer 4
1514 */
1515 #define IMB_SNOW3G_F8_4_BUFFER(_mgr, _ctx, _iv1, _iv2, _iv3, _iv4, \
1516 _in1, _out1, _len1, \
1517 _in2, _out2, _len2, \
1518 _in3, _out3, _len3, \
1519 _in4, _out4, _len4) \
1520 ((_mgr)->snow3g_f8_4_buffer((_ctx), (_iv1), (_iv2), (_iv3), (_iv4), \
1521 (_in1), (_out1), (_len1), \
1522 (_in2), (_out2), (_len2), \
1523 (_in3), (_out3), (_len3), \
1524 (_in4), (_out4), (_len4)))
1525
1526 /**
1527 *******************************************************************************
1528 * This function performs snow3g f8 operation on eight buffers. They will
1529 * be processed with the same key, which has already been scheduled with
1530 * snow3g_init_key_sched().
1531 *
1532 * @param[in] mgr Pointer to multi-buffer structure
1533 * @param[in] ctx Context where the scheduled keys are stored
1534 * @param[in] iv1 IV to use for buffer pBufferIn1
1535 * @param[in] iv2 IV to use for buffer pBufferIn2
1536 * @param[in] iv3 IV to use for buffer pBufferIn3
1537 * @param[in] iv4 IV to use for buffer pBufferIn4
1538 * @param[in] iv5 IV to use for buffer pBufferIn5
1539 * @param[in] iv6 IV to use for buffer pBufferIn6
1540 * @param[in] iv7 IV to use for buffer pBufferIn7
1541 * @param[in] iv8 IV to use for buffer pBufferIn8
1542 * @param[in] in1 Input buffer 1
1543 * @param[out] out1 Output buffer 1
1544 * @param[in] len1 Length in bytes of input buffer 1
1545 * @param[in] in2 Input buffer 2
1546 * @param[out] out2 Output buffer 2
1547 * @param[in] len2 Length in bytes of input buffer 2
1548 * @param[in] in3 Input buffer 3
1549 * @param[out] out3 Output buffer 3
1550 * @param[in] len3 Length in bytes of input buffer 3
1551 * @param[in] in4 Input buffer 4
1552 * @param[out] out4 Output buffer 4
1553 * @param[in] len4 Length in bytes of input buffer 4
1554 * @param[in] in5 Input buffer 5
1555 * @param[out] out5 Output buffer 5
1556 * @param[in] len5 Length in bytes of input buffer 5
1557 * @param[in] in6 Input buffer 6
1558 * @param[out] out6 Output buffer 6
1559 * @param[in] len6 Length in bytes of input buffer 6
1560 * @param[in] in7 Input buffer 7
1561 * @param[out] out7 Output buffer 7
1562 * @param[in] len7 Length in bytes of input buffer 7
1563 * @param[in] in8 Input buffer 8
1564 * @param[out] out8 Output buffer 8
1565 * @param[in] len8 Length in bytes of input buffer 8
1566 */
1567 #define IMB_SNOW3G_F8_8_BUFFER(_mgr, _ctx, _iv1, _iv2, _iv3, _iv4, \
1568 _iv5, _iv6, _iv7, _iv8, \
1569 _in1, _out1, _len1, \
1570 _in2, _out2, _len2, \
1571 _in3, _out3, _len3, \
1572 _in4, _out4, _len4, \
1573 _in5, _out5, _len5, \
1574 _in6, _out6, _len6, \
1575 _in7, _out7, _len7, \
1576 _in8, _out8, _len8) \
1577 ((_mgr)->snow3g_f8_8_buffer((_ctx), (_iv1), (_iv2), (_iv3), (_iv4), \
1578 (_iv5), (_iv6), (_iv7), (_iv8), \
1579 (_in1), (_out1), (_len1), \
1580 (_in2), (_out2), (_len2), \
1581 (_in3), (_out3), (_len3), \
1582 (_in4), (_out4), (_len4), \
1583 (_in5), (_out5), (_len5), \
1584 (_in6), (_out6), (_len6), \
1585 (_in7), (_out7), (_len7), \
1586 (_in8), (_out8), (_len8)))
1587 /**
1588 * This function performs snow3g f8 operation on eight buffers. They will
1589 * be processed with individual keys, which have already been scheduled
1590 * with snow3g_init_key_sched().
1591 *
1592 * @param[in] mgr Pointer to multi-buffer structure
1593 * @param[in] ctx Array of 8 Contexts, where the scheduled keys are stored
1594 * @param[in] iv Array of 8 IV values
1595 * @param[in] in Array of 8 input buffers
1596 * @param[out] out Array of 8 output buffers
1597 * @param[in] lens Array of 8 corresponding input buffer lengths
1598 */
1599 #define IMB_SNOW3G_F8_8_BUFFER_MULTIKEY(_mgr, _ctx, _iv, _in, _out, _len) \
1600 ((_mgr)->snow3g_f8_8_buffer_multikey((_ctx), (_iv), (_in), (_out),\
1601 (_len)))
1602
1603 /**
1604 * This function performs snow3g f8 operation in parallel on N buffers. All
1605 * input buffers can have different lengths and they will be processed with the
1606 * same key, which has already been scheduled with snow3g_init_key_sched().
1607 *
1608 * @param[in] mgr Pointer to multi-buffer structure
1609 * @param[in] ctx Context where the scheduled keys are stored
1610 * @param[in] iv Array of IV values
1611 * @param[in] in Array of input buffers
1612 * @param[out] out Array of output buffers - out[0] set to NULL on failure
1613 * @param[in] len Array of corresponding input buffer lengths
1614 * @param[in] count Number of input buffers
1615 *
1616 ******************************************************************************/
1617 #define IMB_SNOW3G_F8_N_BUFFER(_mgr, _ctx, _iv, _in, _out, _len, _count) \
1618 ((_mgr)->snow3g_f8_n_buffer((_ctx), (_iv), (_in), \
1619 (_out), (_len), (_count)))
1620
1621 /**
1622 * This function performs snow3g f8 operation in parallel on N buffers. All
1623 * input buffers can have different lengths. Confidentiallity keys can vary,
1624 * schedules with snow3g_init_key_sched_multi().
1625 *
1626 * @param[in] mgr Pointer to multi-buffer structure
1627 * @param[in] ctx Array of Contexts, where the scheduled keys are stored
1628 * @param[in] iv Array of IV values
1629 * @param[in] in Array of input buffers
1630 * @param[out] out Array of output buffers
1631 * - out[0] set to NULL on failure
1632 * @param[in] len Array of corresponding input buffer lengths
1633 * @param[in] count Number of input buffers
1634 */
1635 #define IMB_SNOW3G_F8_N_BUFFER_MULTIKEY(_mgr, _ctx, _iv, _in, \
1636 _out, _len, _count) \
1637 ((_mgr)->snow3g_f8_n_buffer_multikey((_ctx), (_iv), (_in), \
1638 (_out), (_len), (_count)))
1639
1640 /**
1641 * This function performs a snow3g f9 operation on a single block of data. The
1642 * key has already been scheduled with snow3g_init_f8_key_sched().
1643 *
1644 * @param[in] mgr Pointer to multi-buffer structure
1645 * @param[in] ctx Context where the scheduled keys are stored
1646 * @param[in] iv iv[3] = _BSWAP32(fresh^(dir<<15))
1647 * iv[2] = _BSWAP32(count^(dir<<31))
1648 * iv[1] = _BSWAP32(fresh)
1649 * iv[0] = _BSWAP32(count)
1650 *
1651 * @param[in] in Input buffer
1652 * @param[in] len Length in bits of the data to be hashed
1653 * @param[out] digest Computed digest
1654 */
1655 #define IMB_SNOW3G_F9_1_BUFFER(_mgr, _ctx, _iv, _in, _len, _digest) \
1656 ((_mgr)->snow3g_f9_1_buffer((_ctx), (_iv), (_in), (_len), (_digest)))
1657
1658 /**
1659 * Snow3g key schedule init function.
1660 *
1661 * @param[in] mgr Pointer to multi-buffer structure
1662 * @param[in] key Confidentiality/Integrity key (expected in LE format)
1663 * @param[out] ctx Key schedule context to be initialised
1664 * @return 0 on success
1665 * @return -1 on error
1666 *
1667 ******************************************************************************/
1668 #define IMB_SNOW3G_INIT_KEY_SCHED(_mgr, _key, _ctx) \
1669 ((_mgr)->snow3g_init_key_sched((_key), (_ctx)))
1670
1671 /**
1672 *******************************************************************************
1673 * This function returns the size of the snow3g_key_schedule_t, used
1674 * to store the key schedule.
1675 *
1676 * @param[in] mgr Pointer to multi-buffer structure
1677 * @return size of snow3g_key_schedule_t type
1678 *
1679 ******************************************************************************/
1680 #define IMB_SNOW3G_KEY_SCHED_SIZE(_mgr)((_mgr)->snow3g_key_sched_size())
1681
1682
1683 /* Auxiliary functions */
1684
1685 /**
1686 * @brief DES key schedule set up
1687 *
1688 * \a ks buffer needs to accomodate \a DES_KEY_SCHED_SIZE (128) bytes of data.
1689 *
1690 * @param ks destination buffer to accomodate DES key schedule
1691 * @param key a pointer to an 8 byte DES key
1692 *
1693 * @return Operation status
1694 * @retval 0 success
1695 * @retval !0 error
1696 */
1697 IMB_DLL_EXPORT int
1698 des_key_schedule(uint64_t *ks, const void *key);
1699
1700 /* SSE */
1701 IMB_DLL_EXPORT void sha1_sse(const void *data, const uint64_t length,
1702 void *digest);
1703 IMB_DLL_EXPORT void sha1_one_block_sse(const void *data, void *digest);
1704 IMB_DLL_EXPORT void sha224_sse(const void *data, const uint64_t length,
1705 void *digest);
1706 IMB_DLL_EXPORT void sha224_one_block_sse(const void *data, void *digest);
1707 IMB_DLL_EXPORT void sha256_sse(const void *data, const uint64_t length,
1708 void *digest);
1709 IMB_DLL_EXPORT void sha256_one_block_sse(const void *data, void *digest);
1710 IMB_DLL_EXPORT void sha384_sse(const void *data, const uint64_t length,
1711 void *digest);
1712 IMB_DLL_EXPORT void sha384_one_block_sse(const void *data, void *digest);
1713 IMB_DLL_EXPORT void sha512_sse(const void *data, const uint64_t length,
1714 void *digest);
1715 IMB_DLL_EXPORT void sha512_one_block_sse(const void *data, void *digest);
1716 IMB_DLL_EXPORT void md5_one_block_sse(const void *data, void *digest);
1717 IMB_DLL_EXPORT void aes_keyexp_128_sse(const void *key, void *enc_exp_keys,
1718 void *dec_exp_keys);
1719 IMB_DLL_EXPORT void aes_keyexp_192_sse(const void *key, void *enc_exp_keys,
1720 void *dec_exp_keys);
1721 IMB_DLL_EXPORT void aes_keyexp_256_sse(const void *key, void *enc_exp_keys,
1722 void *dec_exp_keys);
1723 IMB_DLL_EXPORT void aes_xcbc_expand_key_sse(const void *key, void *k1_exp,
1724 void *k2, void *k3);
1725 IMB_DLL_EXPORT void aes_keyexp_128_enc_sse(const void *key,
1726 void *enc_exp_keys);
1727 IMB_DLL_EXPORT void aes_keyexp_192_enc_sse(const void *key,
1728 void *enc_exp_keys);
1729 IMB_DLL_EXPORT void aes_keyexp_256_enc_sse(const void *key,
1730 void *enc_exp_keys);
1731 IMB_DLL_EXPORT void aes_cmac_subkey_gen_sse(const void *key_exp, void *key1,
1732 void *key2);
1733 IMB_DLL_EXPORT void aes_cfb_128_one_sse(void *out, const void *in,
1734 const void *iv, const void *keys,
1735 uint64_t len);
1736
1737 /* AVX */
1738 IMB_DLL_EXPORT void sha1_avx(const void *data, const uint64_t length,
1739 void *digest);
1740 IMB_DLL_EXPORT void sha1_one_block_avx(const void *data, void *digest);
1741 IMB_DLL_EXPORT void sha224_avx(const void *data, const uint64_t length,
1742 void *digest);
1743 IMB_DLL_EXPORT void sha224_one_block_avx(const void *data, void *digest);
1744 IMB_DLL_EXPORT void sha256_avx(const void *data, const uint64_t length,
1745 void *digest);
1746 IMB_DLL_EXPORT void sha256_one_block_avx(const void *data, void *digest);
1747 IMB_DLL_EXPORT void sha384_avx(const void *data, const uint64_t length,
1748 void *digest);
1749 IMB_DLL_EXPORT void sha384_one_block_avx(const void *data, void *digest);
1750 IMB_DLL_EXPORT void sha512_avx(const void *data, const uint64_t length,
1751 void *digest);
1752 IMB_DLL_EXPORT void sha512_one_block_avx(const void *data, void *digest);
1753 IMB_DLL_EXPORT void md5_one_block_avx(const void *data, void *digest);
1754 IMB_DLL_EXPORT void aes_keyexp_128_avx(const void *key, void *enc_exp_keys,
1755 void *dec_exp_keys);
1756 IMB_DLL_EXPORT void aes_keyexp_192_avx(const void *key, void *enc_exp_keys,
1757 void *dec_exp_keys);
1758 IMB_DLL_EXPORT void aes_keyexp_256_avx(const void *key, void *enc_exp_keys,
1759 void *dec_exp_keys);
1760 IMB_DLL_EXPORT void aes_xcbc_expand_key_avx(const void *key, void *k1_exp,
1761 void *k2, void *k3);
1762 IMB_DLL_EXPORT void aes_keyexp_128_enc_avx(const void *key,
1763 void *enc_exp_keys);
1764 IMB_DLL_EXPORT void aes_keyexp_192_enc_avx(const void *key,
1765 void *enc_exp_keys);
1766 IMB_DLL_EXPORT void aes_keyexp_256_enc_avx(const void *key,
1767 void *enc_exp_keys);
1768 IMB_DLL_EXPORT void aes_cmac_subkey_gen_avx(const void *key_exp, void *key1,
1769 void *key2);
1770 IMB_DLL_EXPORT void aes_cfb_128_one_avx(void *out, const void *in,
1771 const void *iv, const void *keys,
1772 uint64_t len);
1773
1774 /* AVX2 */
1775 IMB_DLL_EXPORT void sha1_avx2(const void *data, const uint64_t length,
1776 void *digest);
1777 IMB_DLL_EXPORT void sha1_one_block_avx2(const void *data, void *digest);
1778 IMB_DLL_EXPORT void sha224_avx2(const void *data, const uint64_t length,
1779 void *digest);
1780 IMB_DLL_EXPORT void sha224_one_block_avx2(const void *data, void *digest);
1781 IMB_DLL_EXPORT void sha256_avx2(const void *data, const uint64_t length,
1782 void *digest);
1783 IMB_DLL_EXPORT void sha256_one_block_avx2(const void *data, void *digest);
1784 IMB_DLL_EXPORT void sha384_avx2(const void *data, const uint64_t length,
1785 void *digest);
1786 IMB_DLL_EXPORT void sha384_one_block_avx2(const void *data, void *digest);
1787 IMB_DLL_EXPORT void sha512_avx2(const void *data, const uint64_t length,
1788 void *digest);
1789 IMB_DLL_EXPORT void sha512_one_block_avx2(const void *data, void *digest);
1790 IMB_DLL_EXPORT void md5_one_block_avx2(const void *data, void *digest);
1791 IMB_DLL_EXPORT void aes_keyexp_128_avx2(const void *key, void *enc_exp_keys,
1792 void *dec_exp_keys);
1793 IMB_DLL_EXPORT void aes_keyexp_192_avx2(const void *key, void *enc_exp_keys,
1794 void *dec_exp_keys);
1795 IMB_DLL_EXPORT void aes_keyexp_256_avx2(const void *key, void *enc_exp_keys,
1796 void *dec_exp_keys);
1797 IMB_DLL_EXPORT void aes_xcbc_expand_key_avx2(const void *key, void *k1_exp,
1798 void *k2, void *k3);
1799 IMB_DLL_EXPORT void aes_keyexp_128_enc_avx2(const void *key,
1800 void *enc_exp_keys);
1801 IMB_DLL_EXPORT void aes_keyexp_192_enc_avx2(const void *key,
1802 void *enc_exp_keys);
1803 IMB_DLL_EXPORT void aes_keyexp_256_enc_avx2(const void *key,
1804 void *enc_exp_keys);
1805 IMB_DLL_EXPORT void aes_cmac_subkey_gen_avx2(const void *key_exp, void *key1,
1806 void *key2);
1807 IMB_DLL_EXPORT void aes_cfb_128_one_avx2(void *out, const void *in,
1808 const void *iv, const void *keys,
1809 uint64_t len);
1810
1811 /* AVX512 */
1812 IMB_DLL_EXPORT void sha1_avx512(const void *data, const uint64_t length,
1813 void *digest);
1814 IMB_DLL_EXPORT void sha1_one_block_avx512(const void *data, void *digest);
1815 IMB_DLL_EXPORT void sha224_avx512(const void *data, const uint64_t length,
1816 void *digest);
1817 IMB_DLL_EXPORT void sha224_one_block_avx512(const void *data, void *digest);
1818 IMB_DLL_EXPORT void sha256_avx512(const void *data, const uint64_t length,
1819 void *digest);
1820 IMB_DLL_EXPORT void sha256_one_block_avx512(const void *data, void *digest);
1821 IMB_DLL_EXPORT void sha384_avx512(const void *data, const uint64_t length,
1822 void *digest);
1823 IMB_DLL_EXPORT void sha384_one_block_avx512(const void *data, void *digest);
1824 IMB_DLL_EXPORT void sha512_avx512(const void *data, const uint64_t length,
1825 void *digest);
1826 IMB_DLL_EXPORT void sha512_one_block_avx512(const void *data, void *digest);
1827 IMB_DLL_EXPORT void md5_one_block_avx512(const void *data, void *digest);
1828 IMB_DLL_EXPORT void aes_keyexp_128_avx512(const void *key, void *enc_exp_keys,
1829 void *dec_exp_keys);
1830 IMB_DLL_EXPORT void aes_keyexp_192_avx512(const void *key, void *enc_exp_keys,
1831 void *dec_exp_keys);
1832 IMB_DLL_EXPORT void aes_keyexp_256_avx512(const void *key, void *enc_exp_keys,
1833 void *dec_exp_keys);
1834 IMB_DLL_EXPORT void aes_xcbc_expand_key_avx512(const void *key, void *k1_exp,
1835 void *k2, void *k3);
1836 IMB_DLL_EXPORT void aes_keyexp_128_enc_avx512(const void *key,
1837 void *enc_exp_keys);
1838 IMB_DLL_EXPORT void aes_keyexp_192_enc_avx512(const void *key,
1839 void *enc_exp_keys);
1840 IMB_DLL_EXPORT void aes_keyexp_256_enc_avx512(const void *key,
1841 void *enc_exp_keys);
1842 IMB_DLL_EXPORT void aes_cmac_subkey_gen_avx512(const void *key_exp, void *key1,
1843 void *key2);
1844 IMB_DLL_EXPORT void aes_cfb_128_one_avx512(void *out, const void *in,
1845 const void *iv, const void *keys,
1846 uint64_t len);
1847
1848 /*
1849 * Direct GCM API.
1850 * Note that GCM is also availabe through job API.
1851 */
1852 #ifndef NO_GCM
1853 /**
1854 * @brief GCM-AES Encryption
1855 *
1856 * @param key_data GCM expanded key data
1857 * @param context_data GCM operation context data
1858 * @param out Ciphertext output. Encrypt in-place is allowed.
1859 * @param in Plaintext input.
1860 * @param len Length of data in Bytes for encryption.
1861 * @param iv pointer to 12 byte IV structure. Internally, library
1862 * concates 0x00000001 value to it.
1863 * @param aad Additional Authentication Data (AAD).
1864 * @param aad_len Length of AAD.
1865 * @param auth_tag Authenticated Tag output.
1866 * @param auth_tag_len Authenticated Tag Length in bytes (must be
1867 * a multiple of 4 bytes). Valid values are
1868 * 16 (most likely), 12 or 8.
1869 */
1870 IMB_DLL_EXPORT void
1871 aes_gcm_enc_128_sse(const struct gcm_key_data *key_data,
1872 struct gcm_context_data *context_data,
1873 uint8_t *out, uint8_t const *in, uint64_t len,
1874 const uint8_t *iv, uint8_t const *aad, uint64_t aad_len,
1875 uint8_t *auth_tag, uint64_t auth_tag_len);
1876 IMB_DLL_EXPORT void
1877 aes_gcm_enc_128_avx_gen2(const struct gcm_key_data *key_data,
1878 struct gcm_context_data *context_data,
1879 uint8_t *out, uint8_t const *in, uint64_t len,
1880 const uint8_t *iv,
1881 uint8_t const *aad, uint64_t aad_len,
1882 uint8_t *auth_tag, uint64_t auth_tag_len);
1883 IMB_DLL_EXPORT void
1884 aes_gcm_enc_128_avx_gen4(const struct gcm_key_data *key_data,
1885 struct gcm_context_data *context_data,
1886 uint8_t *out, uint8_t const *in, uint64_t len,
1887 const uint8_t *iv,
1888 uint8_t const *aad, uint64_t aad_len,
1889 uint8_t *auth_tag, uint64_t auth_tag_len);
1890
1891 IMB_DLL_EXPORT void
1892 aes_gcm_enc_192_sse(const struct gcm_key_data *key_data,
1893 struct gcm_context_data *context_data,
1894 uint8_t *out, uint8_t const *in, uint64_t len,
1895 const uint8_t *iv, uint8_t const *aad, uint64_t aad_len,
1896 uint8_t *auth_tag, uint64_t auth_tag_len);
1897 IMB_DLL_EXPORT void
1898 aes_gcm_enc_192_avx_gen2(const struct gcm_key_data *key_data,
1899 struct gcm_context_data *context_data,
1900 uint8_t *out, uint8_t const *in, uint64_t len,
1901 const uint8_t *iv,
1902 uint8_t const *aad, uint64_t aad_len,
1903 uint8_t *auth_tag, uint64_t auth_tag_len);
1904 IMB_DLL_EXPORT void
1905 aes_gcm_enc_192_avx_gen4(const struct gcm_key_data *key_data,
1906 struct gcm_context_data *context_data,
1907 uint8_t *out, uint8_t const *in, uint64_t len,
1908 const uint8_t *iv,
1909 uint8_t const *aad, uint64_t aad_len,
1910 uint8_t *auth_tag, uint64_t auth_tag_len);
1911
1912 IMB_DLL_EXPORT void
1913 aes_gcm_enc_256_sse(const struct gcm_key_data *key_data,
1914 struct gcm_context_data *context_data,
1915 uint8_t *out, uint8_t const *in, uint64_t len,
1916 const uint8_t *iv,
1917 uint8_t const *aad, uint64_t aad_len,
1918 uint8_t *auth_tag, uint64_t auth_tag_len);
1919 IMB_DLL_EXPORT void
1920 aes_gcm_enc_256_avx_gen2(const struct gcm_key_data *key_data,
1921 struct gcm_context_data *context_data,
1922 uint8_t *out, uint8_t const *in, uint64_t len,
1923 const uint8_t *iv,
1924 uint8_t const *aad, uint64_t aad_len,
1925 uint8_t *auth_tag, uint64_t auth_tag_len);
1926 IMB_DLL_EXPORT void
1927 aes_gcm_enc_256_avx_gen4(const struct gcm_key_data *key_data,
1928 struct gcm_context_data *context_data,
1929 uint8_t *out, uint8_t const *in, uint64_t len,
1930 const uint8_t *iv,
1931 uint8_t const *aad, uint64_t aad_len,
1932 uint8_t *auth_tag, uint64_t auth_tag_len);
1933
1934 /**
1935 * @brief GCM-AES Decryption
1936 *
1937 * @param key_data GCM expanded keys data
1938 * @param context_data GCM operation context data
1939 * @param out Plaintext output. Decrypt in-place is allowed.
1940 * @param in Ciphertext input.
1941 * @param len Length of data in Bytes for decryption.
1942 * @param iv pointer to 12 byte IV structure. Internally, library
1943 * concates 0x00000001 value to it.
1944 * @param aad Additional Authentication Data (AAD).
1945 * @param aad_len Length of AAD.
1946 * @param auth_tag Authenticated Tag output.
1947 * @param auth_tag_len Authenticated Tag Length in bytes (must be
1948 * a multiple of 4 bytes). Valid values are
1949 * 16 (most likely), 12 or 8.
1950 */
1951 IMB_DLL_EXPORT void
1952 aes_gcm_dec_128_sse(const struct gcm_key_data *key_data,
1953 struct gcm_context_data *context_data,
1954 uint8_t *out, uint8_t const *in, uint64_t len,
1955 const uint8_t *iv, uint8_t const *aad, uint64_t aad_len,
1956 uint8_t *auth_tag, uint64_t auth_tag_len);
1957 IMB_DLL_EXPORT void
1958 aes_gcm_dec_128_avx_gen2(const struct gcm_key_data *key_data,
1959 struct gcm_context_data *context_data,
1960 uint8_t *out, uint8_t const *in, uint64_t len,
1961 const uint8_t *iv,
1962 uint8_t const *aad, uint64_t aad_len,
1963 uint8_t *auth_tag, uint64_t auth_tag_len);
1964 IMB_DLL_EXPORT void
1965 aes_gcm_dec_128_avx_gen4(const struct gcm_key_data *key_data,
1966 struct gcm_context_data *context_data,
1967 uint8_t *out, uint8_t const *in, uint64_t len,
1968 const uint8_t *iv,
1969 uint8_t const *aad, uint64_t aad_len,
1970 uint8_t *auth_tag, uint64_t auth_tag_len);
1971
1972 IMB_DLL_EXPORT void
1973 aes_gcm_dec_192_sse(const struct gcm_key_data *key_data,
1974 struct gcm_context_data *context_data,
1975 uint8_t *out, uint8_t const *in, uint64_t len,
1976 const uint8_t *iv, uint8_t const *aad, uint64_t aad_len,
1977 uint8_t *auth_tag, uint64_t auth_tag_len);
1978 IMB_DLL_EXPORT void
1979 aes_gcm_dec_192_avx_gen2(const struct gcm_key_data *key_data,
1980 struct gcm_context_data *context_data,
1981 uint8_t *out, uint8_t const *in, uint64_t len,
1982 const uint8_t *iv,
1983 uint8_t const *aad, uint64_t aad_len,
1984 uint8_t *auth_tag, uint64_t auth_tag_len);
1985 IMB_DLL_EXPORT void
1986 aes_gcm_dec_192_avx_gen4(const struct gcm_key_data *key_data,
1987 struct gcm_context_data *context_data,
1988 uint8_t *out, uint8_t const *in, uint64_t len,
1989 const uint8_t *iv,
1990 uint8_t const *aad, uint64_t aad_len,
1991 uint8_t *auth_tag, uint64_t auth_tag_len);
1992
1993 IMB_DLL_EXPORT void
1994 aes_gcm_dec_256_sse(const struct gcm_key_data *key_data,
1995 struct gcm_context_data *context_data,
1996 uint8_t *out, uint8_t const *in, uint64_t len,
1997 const uint8_t *iv, uint8_t const *aad, uint64_t aad_len,
1998 uint8_t *auth_tag, uint64_t auth_tag_len);
1999 IMB_DLL_EXPORT void
2000 aes_gcm_dec_256_avx_gen2(const struct gcm_key_data *key_data,
2001 struct gcm_context_data *context_data,
2002 uint8_t *out, uint8_t const *in, uint64_t len,
2003 const uint8_t *iv,
2004 uint8_t const *aad, uint64_t aad_len,
2005 uint8_t *auth_tag, uint64_t auth_tag_len);
2006 IMB_DLL_EXPORT void
2007 aes_gcm_dec_256_avx_gen4(const struct gcm_key_data *key_data,
2008 struct gcm_context_data *context_data,
2009 uint8_t *out, uint8_t const *in, uint64_t len,
2010 const uint8_t *iv,
2011 uint8_t const *aad, uint64_t aad_len,
2012 uint8_t *auth_tag, uint64_t auth_tag_len);
2013
2014 /**
2015 * @brief Start a AES-GCM Encryption message
2016 *
2017 * @param key_data GCM expanded key data
2018 * @param context_data GCM operation context data
2019 * @param iv pointer to 12 byte IV structure. Internally, library
2020 * concates 0x00000001 value to it.
2021 * @param aad Additional Authentication Data (AAD).
2022 * @param aad_len Length of AAD.
2023 *
2024 */
2025 IMB_DLL_EXPORT void
2026 aes_gcm_init_128_sse(const struct gcm_key_data *key_data,
2027 struct gcm_context_data *context_data,
2028 const uint8_t *iv, uint8_t const *aad, uint64_t aad_len);
2029 IMB_DLL_EXPORT void
2030 aes_gcm_init_128_avx_gen2(const struct gcm_key_data *key_data,
2031 struct gcm_context_data *context_data,
2032 const uint8_t *iv,
2033 uint8_t const *aad, uint64_t aad_len);
2034 IMB_DLL_EXPORT void
2035 aes_gcm_init_128_avx_gen4(const struct gcm_key_data *key_data,
2036 struct gcm_context_data *context_data,
2037 const uint8_t *iv,
2038 uint8_t const *aad, uint64_t aad_len);
2039
2040 IMB_DLL_EXPORT void
2041 aes_gcm_init_192_sse(const struct gcm_key_data *key_data,
2042 struct gcm_context_data *context_data,
2043 const uint8_t *iv, uint8_t const *aad, uint64_t aad_len);
2044 IMB_DLL_EXPORT void
2045 aes_gcm_init_192_avx_gen2(const struct gcm_key_data *key_data,
2046 struct gcm_context_data *context_data,
2047 const uint8_t *iv,
2048 uint8_t const *aad, uint64_t aad_len);
2049 IMB_DLL_EXPORT void
2050 aes_gcm_init_192_avx_gen4(const struct gcm_key_data *key_data,
2051 struct gcm_context_data *context_data,
2052 const uint8_t *iv,
2053 uint8_t const *aad, uint64_t aad_len);
2054
2055 IMB_DLL_EXPORT void
2056 aes_gcm_init_256_sse(const struct gcm_key_data *key_data,
2057 struct gcm_context_data *context_data,
2058 const uint8_t *iv, uint8_t const *aad, uint64_t aad_len);
2059 IMB_DLL_EXPORT void
2060 aes_gcm_init_256_avx_gen2(const struct gcm_key_data *key_data,
2061 struct gcm_context_data *context_data,
2062 const uint8_t *iv,
2063 uint8_t const *aad, uint64_t aad_len);
2064 IMB_DLL_EXPORT void
2065 aes_gcm_init_256_avx_gen4(const struct gcm_key_data *key_data,
2066 struct gcm_context_data *context_data,
2067 const uint8_t *iv,
2068 uint8_t const *aad, uint64_t aad_len);
2069
2070 /**
2071 * @brief encrypt a block of a AES-GCM Encryption message
2072 *
2073 * @param key_data GCM expanded key data
2074 * @param context_data GCM operation context data
2075 * @param out Ciphertext output. Encrypt in-place is allowed.
2076 * @param in Plaintext input.
2077 * @param len Length of data in Bytes for decryption.
2078 */
2079 IMB_DLL_EXPORT void
2080 aes_gcm_enc_128_update_sse(const struct gcm_key_data *key_data,
2081 struct gcm_context_data *context_data,
2082 uint8_t *out, const uint8_t *in, uint64_t len);
2083 IMB_DLL_EXPORT void
2084 aes_gcm_enc_128_update_avx_gen2(const struct gcm_key_data *key_data,
2085 struct gcm_context_data *context_data,
2086 uint8_t *out, const uint8_t *in, uint64_t len);
2087 IMB_DLL_EXPORT void
2088 aes_gcm_enc_128_update_avx_gen4(const struct gcm_key_data *key_data,
2089 struct gcm_context_data *context_data,
2090 uint8_t *out, const uint8_t *in, uint64_t len);
2091
2092 IMB_DLL_EXPORT void
2093 aes_gcm_enc_192_update_sse(const struct gcm_key_data *key_data,
2094 struct gcm_context_data *context_data,
2095 uint8_t *out, const uint8_t *in, uint64_t len);
2096 IMB_DLL_EXPORT void
2097 aes_gcm_enc_192_update_avx_gen2(const struct gcm_key_data *key_data,
2098 struct gcm_context_data *context_data,
2099 uint8_t *out, const uint8_t *in, uint64_t len);
2100 IMB_DLL_EXPORT void
2101 aes_gcm_enc_192_update_avx_gen4(const struct gcm_key_data *key_data,
2102 struct gcm_context_data *context_data,
2103 uint8_t *out, const uint8_t *in, uint64_t len);
2104
2105 IMB_DLL_EXPORT void
2106 aes_gcm_enc_256_update_sse(const struct gcm_key_data *key_data,
2107 struct gcm_context_data *context_data,
2108 uint8_t *out, const uint8_t *in, uint64_t len);
2109 IMB_DLL_EXPORT void
2110 aes_gcm_enc_256_update_avx_gen2(const struct gcm_key_data *key_data,
2111 struct gcm_context_data *context_data,
2112 uint8_t *out, const uint8_t *in, uint64_t len);
2113 IMB_DLL_EXPORT void
2114 aes_gcm_enc_256_update_avx_gen4(const struct gcm_key_data *key_data,
2115 struct gcm_context_data *context_data,
2116 uint8_t *out, const uint8_t *in, uint64_t len);
2117
2118 /**
2119 * @brief decrypt a block of a AES-GCM Encryption message
2120 *
2121 * @param key_data GCM expanded key data
2122 * @param context_data GCM operation context data
2123 * @param out Plaintext output. Decrypt in-place is allowed.
2124 * @param in Ciphertext input.
2125 * @param len Length of data in Bytes for decryption.
2126 */
2127 IMB_DLL_EXPORT void
2128 aes_gcm_dec_128_update_sse(const struct gcm_key_data *key_data,
2129 struct gcm_context_data *context_data,
2130 uint8_t *out, const uint8_t *in, uint64_t len);
2131 IMB_DLL_EXPORT void
2132 aes_gcm_dec_128_update_avx_gen2(const struct gcm_key_data *key_data,
2133 struct gcm_context_data *context_data,
2134 uint8_t *out, const uint8_t *in, uint64_t len);
2135 IMB_DLL_EXPORT void
2136 aes_gcm_dec_128_update_avx_gen4(const struct gcm_key_data *key_data,
2137 struct gcm_context_data *context_data,
2138 uint8_t *out, const uint8_t *in, uint64_t len);
2139
2140 IMB_DLL_EXPORT void
2141 aes_gcm_dec_192_update_sse(const struct gcm_key_data *key_data,
2142 struct gcm_context_data *context_data,
2143 uint8_t *out, const uint8_t *in, uint64_t len);
2144 IMB_DLL_EXPORT void
2145 aes_gcm_dec_192_update_avx_gen2(const struct gcm_key_data *key_data,
2146 struct gcm_context_data *context_data,
2147 uint8_t *out, const uint8_t *in, uint64_t len);
2148 IMB_DLL_EXPORT void
2149 aes_gcm_dec_192_update_avx_gen4(const struct gcm_key_data *key_data,
2150 struct gcm_context_data *context_data,
2151 uint8_t *out, const uint8_t *in, uint64_t len);
2152
2153 IMB_DLL_EXPORT void
2154 aes_gcm_dec_256_update_sse(const struct gcm_key_data *key_data,
2155 struct gcm_context_data *context_data,
2156 uint8_t *out, const uint8_t *in, uint64_t len);
2157 IMB_DLL_EXPORT void
2158 aes_gcm_dec_256_update_avx_gen2(const struct gcm_key_data *key_data,
2159 struct gcm_context_data *context_data,
2160 uint8_t *out, const uint8_t *in, uint64_t len);
2161 IMB_DLL_EXPORT void
2162 aes_gcm_dec_256_update_avx_gen4(const struct gcm_key_data *key_data,
2163 struct gcm_context_data *context_data,
2164 uint8_t *out, const uint8_t *in, uint64_t len);
2165
2166 /**
2167 * @brief End encryption of a AES-GCM Encryption message
2168 *
2169 * @param key_data GCM expanded key data
2170 * @param context_data GCM operation context data
2171 * @param auth_tag Authenticated Tag output.
2172 * @param auth_tag_len Authenticated Tag Length in bytes (must be
2173 * a multiple of 4 bytes). Valid values are
2174 * 16 (most likely), 12 or 8.
2175 */
2176 IMB_DLL_EXPORT void
2177 aes_gcm_enc_128_finalize_sse(const struct gcm_key_data *key_data,
2178 struct gcm_context_data *context_data,
2179 uint8_t *auth_tag, uint64_t auth_tag_len);
2180 IMB_DLL_EXPORT void
2181 aes_gcm_enc_128_finalize_avx_gen2(const struct gcm_key_data *key_data,
2182 struct gcm_context_data *context_data,
2183 uint8_t *auth_tag, uint64_t auth_tag_len);
2184 IMB_DLL_EXPORT void
2185 aes_gcm_enc_128_finalize_avx_gen4(const struct gcm_key_data *key_data,
2186 struct gcm_context_data *context_data,
2187 uint8_t *auth_tag, uint64_t auth_tag_len);
2188
2189 IMB_DLL_EXPORT void
2190 aes_gcm_enc_192_finalize_sse(const struct gcm_key_data *key_data,
2191 struct gcm_context_data *context_data,
2192 uint8_t *auth_tag, uint64_t auth_tag_len);
2193 IMB_DLL_EXPORT void
2194 aes_gcm_enc_192_finalize_avx_gen2(const struct gcm_key_data *key_data,
2195 struct gcm_context_data *context_data,
2196 uint8_t *auth_tag, uint64_t auth_tag_len);
2197 IMB_DLL_EXPORT void
2198 aes_gcm_enc_192_finalize_avx_gen4(const struct gcm_key_data *key_data,
2199 struct gcm_context_data *context_data,
2200 uint8_t *auth_tag, uint64_t auth_tag_len);
2201
2202 IMB_DLL_EXPORT void
2203 aes_gcm_enc_256_finalize_sse(const struct gcm_key_data *key_data,
2204 struct gcm_context_data *context_data,
2205 uint8_t *auth_tag, uint64_t auth_tag_len);
2206 IMB_DLL_EXPORT void
2207 aes_gcm_enc_256_finalize_avx_gen2(const struct gcm_key_data *key_data,
2208 struct gcm_context_data *context_data,
2209 uint8_t *auth_tag, uint64_t auth_tag_len);
2210 IMB_DLL_EXPORT void
2211 aes_gcm_enc_256_finalize_avx_gen4(const struct gcm_key_data *key_data,
2212 struct gcm_context_data *context_data,
2213 uint8_t *auth_tag, uint64_t auth_tag_len);
2214
2215 /**
2216 * @brief End decryption of a AES-GCM Encryption message
2217 *
2218 * @param key_data GCM expanded key data
2219 * @param context_data GCM operation context data
2220 * @param auth_tag Authenticated Tag output.
2221 * @param auth_tag_len Authenticated Tag Length in bytes (must be
2222 * a multiple of 4 bytes). Valid values are
2223 * 16 (most likely), 12 or 8.
2224 */
2225 IMB_DLL_EXPORT void
2226 aes_gcm_dec_128_finalize_sse(const struct gcm_key_data *key_data,
2227 struct gcm_context_data *context_data,
2228 uint8_t *auth_tag, uint64_t auth_tag_len);
2229 IMB_DLL_EXPORT void
2230 aes_gcm_dec_128_finalize_avx_gen2(const struct gcm_key_data *key_data,
2231 struct gcm_context_data *context_data,
2232 uint8_t *auth_tag, uint64_t auth_tag_len);
2233 IMB_DLL_EXPORT void
2234 aes_gcm_dec_128_finalize_avx_gen4(const struct gcm_key_data *key_data,
2235 struct gcm_context_data *context_data,
2236 uint8_t *auth_tag, uint64_t auth_tag_len);
2237
2238 IMB_DLL_EXPORT void
2239 aes_gcm_dec_192_finalize_sse(const struct gcm_key_data *key_data,
2240 struct gcm_context_data *context_data,
2241 uint8_t *auth_tag, uint64_t auth_tag_len);
2242 IMB_DLL_EXPORT void
2243 aes_gcm_dec_192_finalize_avx_gen2(const struct gcm_key_data *key_data,
2244 struct gcm_context_data *context_data,
2245 uint8_t *auth_tag, uint64_t auth_tag_len);
2246 IMB_DLL_EXPORT void
2247 aes_gcm_dec_192_finalize_avx_gen4(const struct gcm_key_data *key_data,
2248 struct gcm_context_data *context_data,
2249 uint8_t *auth_tag, uint64_t auth_tag_len);
2250
2251 IMB_DLL_EXPORT void
2252 aes_gcm_dec_256_finalize_sse(const struct gcm_key_data *key_data,
2253 struct gcm_context_data *context_data,
2254 uint8_t *auth_tag, uint64_t auth_tag_len);
2255 IMB_DLL_EXPORT void
2256 aes_gcm_dec_256_finalize_avx_gen2(const struct gcm_key_data *key_data,
2257 struct gcm_context_data *context_data,
2258 uint8_t *auth_tag, uint64_t auth_tag_len);
2259 IMB_DLL_EXPORT void
2260 aes_gcm_dec_256_finalize_avx_gen4(const struct gcm_key_data *key_data,
2261 struct gcm_context_data *context_data,
2262 uint8_t *auth_tag, uint64_t auth_tag_len);
2263
2264 /**
2265 * @brief Precomputation of HashKey constants
2266 *
2267 * Precomputation of HashKey<<1 mod poly constants (shifted_hkey_X and
2268 * shifted_hkey_X_k).
2269 *
2270 * @param gdata GCM context data
2271 */
2272 IMB_DLL_EXPORT void aes_gcm_precomp_128_sse(struct gcm_key_data *key_data);
2273 IMB_DLL_EXPORT void aes_gcm_precomp_128_avx_gen2(struct gcm_key_data *key_data);
2274 IMB_DLL_EXPORT void aes_gcm_precomp_128_avx_gen4(struct gcm_key_data *key_data);
2275
2276 IMB_DLL_EXPORT void aes_gcm_precomp_192_sse(struct gcm_key_data *key_data);
2277 IMB_DLL_EXPORT void aes_gcm_precomp_192_avx_gen2(struct gcm_key_data *key_data);
2278 IMB_DLL_EXPORT void aes_gcm_precomp_192_avx_gen4(struct gcm_key_data *key_data);
2279
2280 IMB_DLL_EXPORT void aes_gcm_precomp_256_sse(struct gcm_key_data *key_data);
2281 IMB_DLL_EXPORT void aes_gcm_precomp_256_avx_gen2(struct gcm_key_data *key_data);
2282 IMB_DLL_EXPORT void aes_gcm_precomp_256_avx_gen4(struct gcm_key_data *key_data);
2283
2284 /**
2285 * @brief Pre-processes GCM key data
2286 *
2287 * Prefills the gcm key data with key values for each round and
2288 * the initial sub hash key for tag encoding
2289 *
2290 * @param key pointer to key data
2291 * @param key_data GCM expanded key data
2292 *
2293 */
2294 IMB_DLL_EXPORT void aes_gcm_pre_128_sse(const void *key,
2295 struct gcm_key_data *key_data);
2296 IMB_DLL_EXPORT void aes_gcm_pre_128_avx_gen2(const void *key,
2297 struct gcm_key_data *key_data);
2298 IMB_DLL_EXPORT void aes_gcm_pre_128_avx_gen4(const void *key,
2299 struct gcm_key_data *key_data);
2300 IMB_DLL_EXPORT void aes_gcm_pre_192_sse(const void *key,
2301 struct gcm_key_data *key_data);
2302 IMB_DLL_EXPORT void aes_gcm_pre_192_avx_gen2(const void *key,
2303 struct gcm_key_data *key_data);
2304 IMB_DLL_EXPORT void aes_gcm_pre_192_avx_gen4(const void *key,
2305 struct gcm_key_data *key_data);
2306 IMB_DLL_EXPORT void aes_gcm_pre_256_sse(const void *key,
2307 struct gcm_key_data *key_data);
2308 IMB_DLL_EXPORT void aes_gcm_pre_256_avx_gen2(const void *key,
2309 struct gcm_key_data *key_data);
2310 IMB_DLL_EXPORT void aes_gcm_pre_256_avx_gen4(const void *key,
2311 struct gcm_key_data *key_data);
2312 #endif /* !NO_GCM */
2313
2314 /**
2315 * @brief Generation of ZUC Initialization Vectors (for EEA3 and EIA3)
2316 *
2317 * @param [in] count COUNT (4 bytes in Little Endian)
2318 * @param [in] bearer BEARER (5 bits)
2319 * @param [in] dir DIRECTION (1 bit)
2320 * @param [out] iv_ptr Pointer to generated IV (16 bytes)
2321 *
2322 * @return
2323 * - 0 if success
2324 * - 1 if one or more parameters are wrong
2325 */
2326 IMB_DLL_EXPORT int zuc_eea3_iv_gen(const uint32_t count,
2327 const uint8_t bearer,
2328 const uint8_t dir,
2329 void *iv_ptr);
2330 IMB_DLL_EXPORT int zuc_eia3_iv_gen(const uint32_t count,
2331 const uint8_t bearer,
2332 const uint8_t dir,
2333 void *iv_ptr);
2334
2335 /**
2336 * @brief Generation of KASUMI F8 Initialization Vector
2337 *
2338 * @param [in] count COUNT (4 bytes in Little Endian)
2339 * @param [in] bearer BEARER (5 bits)
2340 * @param [in] dir DIRECTION (1 bit)
2341 * @param [out] iv_ptr Pointer to generated IV (16 bytes)
2342 *
2343 * @return
2344 * - 0 if success
2345 * - 1 if one or more parameters are wrong
2346 */
2347 IMB_DLL_EXPORT int kasumi_f8_iv_gen(const uint32_t count,
2348 const uint8_t bearer,
2349 const uint8_t dir,
2350 void *iv_ptr);
2351 /**
2352 * @brief Generation of KASUMI F9 Initialization Vector
2353 *
2354 * @param [in] count COUNT (4 bytes in Little Endian)
2355 * @param [in] fresh FRESH (4 bytes in Little Endian)
2356 * @param [out] iv_ptr Pointer to generated IV (16 bytes)
2357 *
2358 * @return
2359 * - 0 if success
2360 * - 1 if one or more parameters are wrong
2361 */
2362 IMB_DLL_EXPORT int kasumi_f9_iv_gen(const uint32_t count,
2363 const uint32_t fresh,
2364 void *iv_ptr);
2365
2366 /**
2367 * @brief Generation of SNOW3G F8 Initialization Vector
2368 *
2369 * Parameters are passed in Little Endian format and
2370 * used to generate the IV in Big Endian format
2371 *
2372 * @param [in] count COUNT (4 bytes in Little Endian)
2373 * @param [in] bearer BEARER (5 bits)
2374 * @param [in] dir DIRECTION (1 bit)
2375 * @param [out] iv_ptr Pointer to generated IV (16 bytes) in Big Endian format
2376 *
2377 * @return
2378 * - 0 if success
2379 * - 1 if one or more parameters are wrong
2380 */
2381 IMB_DLL_EXPORT int snow3g_f8_iv_gen(const uint32_t count,
2382 const uint8_t bearer,
2383 const uint8_t dir,
2384 void *iv_ptr);
2385 /**
2386 * @brief Generation of SNOW3G F9 Initialization Vector
2387 *
2388 * Parameters are passed in Little Endian format and
2389 * used to generate the IV in Big Endian format
2390 *
2391 * @param [in] count COUNT (4 bytes in Little Endian)
2392 * @param [in] fresh FRESH (4 bytes in Little Endian)
2393 * @param [in] dir DIRECTION (1 bit)
2394 * @param [out] iv_ptr Pointer to generated IV (16 bytes) in Big Endian format
2395 *
2396 * @return
2397 * - 0 if success
2398 * - 1 if one or more parameters are wrong
2399 */
2400 IMB_DLL_EXPORT int snow3g_f9_iv_gen(const uint32_t count,
2401 const uint32_t fresh,
2402 const uint8_t dir,
2403 void *iv_ptr);
2404
2405 #ifdef __cplusplus
2406 }
2407 #endif
2408
2409 #endif /* IMB_IPSEC_MB_H */
Ceph