/src/liboqs/src/common/sha3/avx512vl_sha3x4.c

Source
/**
 * \file avx512vl_sha3x4.c
 * \brief Implementation of the OQS SHA3 times 4 API using the AVX512VL low interface.
 *
 * Copyright (c) 2025 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 */

#include "sha3x4.h"

#include <oqs/common.h>
#include <oqs/oqsconfig.h>

#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#define KECCAK_X4_CTX_ALIGNMENT 32
#define _KECCAK_X4_CTX_BYTES    (800 + sizeof(uint64_t))
#define KECCAK_X4_CTX_BYTES                                                                        \
        (KECCAK_X4_CTX_ALIGNMENT *                                                                 \
         ((_KECCAK_X4_CTX_BYTES + KECCAK_X4_CTX_ALIGNMENT - 1) / KECCAK_X4_CTX_ALIGNMENT))

/********** SHAKE128 ***********/

/* SHAKE128 external */

extern void
SHA3_shake128_x4_avx512vl(uint8_t *out0, uint8_t *out1, uint8_t *out2, uint8_t *out3, size_t outlen,
                          const uint8_t *in0, const uint8_t *in1, const uint8_t *in2,
                          const uint8_t *in3, size_t inlen);

extern void
SHA3_shake128_x4_inc_ctx_reset_avx512vl(OQS_SHA3_shake128_x4_inc_ctx *state);

extern void
SHA3_shake128_x4_inc_absorb_avx512vl(OQS_SHA3_shake128_x4_inc_ctx *state, const uint8_t *in0,
                                     const uint8_t *in1, const uint8_t *in2, const uint8_t *in3,
                                     size_t inlen);

extern void
SHA3_shake128_x4_inc_finalize_avx512vl(OQS_SHA3_shake128_x4_inc_ctx *state);

extern void
SHA3_shake128_x4_inc_squeeze_avx512vl(uint8_t *out0, uint8_t *out1, uint8_t *out2, uint8_t *out3,
                                      size_t outlen, OQS_SHA3_shake128_x4_inc_ctx *state);

/* SHAKE128 incremental */

static void
SHA3_shake128_x4_inc_init_avx512vl(OQS_SHA3_shake128_x4_inc_ctx *state) {
  state->ctx = OQS_MEM_aligned_alloc(KECCAK_X4_CTX_ALIGNMENT, KECCAK_X4_CTX_BYTES);
  OQS_EXIT_IF_NULLPTR(state->ctx, "SHA3x4");
  SHA3_shake128_x4_inc_ctx_reset_avx512vl(state);
}

static void
SHA3_shake128_x4_inc_ctx_clone_avx512vl(OQS_SHA3_shake128_x4_inc_ctx *dest,
                                        const OQS_SHA3_shake128_x4_inc_ctx *src) {
  memcpy(dest->ctx, src->ctx, KECCAK_X4_CTX_BYTES);
}

static void
SHA3_shake128_x4_inc_ctx_release_avx512vl(OQS_SHA3_shake128_x4_inc_ctx *state) {
  SHA3_shake128_x4_inc_ctx_reset_avx512vl(state);
  OQS_MEM_aligned_free(state->ctx);
}

/********** SHAKE256 ***********/

/* SHAKE256 external */

extern void
SHA3_shake256_x4_avx512vl(uint8_t *out0, uint8_t *out1, uint8_t *out2, uint8_t *out3, size_t outlen,
                          const uint8_t *in0, const uint8_t *in1, const uint8_t *in2,
                          const uint8_t *in3, size_t inlen);

extern void
SHA3_shake256_x4_inc_ctx_reset_avx512vl(OQS_SHA3_shake256_x4_inc_ctx *state);

extern void
SHA3_shake256_x4_inc_absorb_avx512vl(OQS_SHA3_shake256_x4_inc_ctx *state, const uint8_t *in0,
                                     const uint8_t *in1, const uint8_t *in2, const uint8_t *in3,
                                     size_t inlen);

extern void
SHA3_shake256_x4_inc_finalize_avx512vl(OQS_SHA3_shake256_x4_inc_ctx *state);

extern void
SHA3_shake256_x4_inc_squeeze_avx512vl(uint8_t *out0, uint8_t *out1, uint8_t *out2, uint8_t *out3,
                                      size_t outlen, OQS_SHA3_shake256_x4_inc_ctx *state);

/* SHAKE256 incremental */

static void
SHA3_shake256_x4_inc_init_avx512vl(OQS_SHA3_shake256_x4_inc_ctx *state) {
  state->ctx = OQS_MEM_aligned_alloc(KECCAK_X4_CTX_ALIGNMENT, KECCAK_X4_CTX_BYTES);
  OQS_EXIT_IF_NULLPTR(state->ctx, "SHA3x4");
  SHA3_shake256_x4_inc_ctx_reset_avx512vl(state);
}

static void
SHA3_shake256_x4_inc_ctx_clone_avx512vl(OQS_SHA3_shake256_x4_inc_ctx *dest,
                                        const OQS_SHA3_shake256_x4_inc_ctx *src) {
  memcpy(dest->ctx, src->ctx, KECCAK_X4_CTX_BYTES);
}

static void
SHA3_shake256_x4_inc_ctx_release_avx512vl(OQS_SHA3_shake256_x4_inc_ctx *state) {
  SHA3_shake256_x4_inc_ctx_reset_avx512vl(state);
  OQS_MEM_aligned_free(state->ctx);
}

const struct OQS_SHA3_x4_callbacks sha3_x4_avx512vl_callbacks = {
  SHA3_shake128_x4_avx512vl,
  SHA3_shake128_x4_inc_init_avx512vl,
  SHA3_shake128_x4_inc_absorb_avx512vl,
  SHA3_shake128_x4_inc_finalize_avx512vl,
  SHA3_shake128_x4_inc_squeeze_avx512vl,
  SHA3_shake128_x4_inc_ctx_release_avx512vl,
  SHA3_shake128_x4_inc_ctx_clone_avx512vl,
  SHA3_shake128_x4_inc_ctx_reset_avx512vl,
  SHA3_shake256_x4_avx512vl,
  SHA3_shake256_x4_inc_init_avx512vl,
  SHA3_shake256_x4_inc_absorb_avx512vl,
  SHA3_shake256_x4_inc_finalize_avx512vl,
  SHA3_shake256_x4_inc_squeeze_avx512vl,
  SHA3_shake256_x4_inc_ctx_release_avx512vl,
  SHA3_shake256_x4_inc_ctx_clone_avx512vl,
  SHA3_shake256_x4_inc_ctx_reset_avx512vl,
};

Line	Count	Source
1		/**
2		* \file avx512vl_sha3x4.c
3		* \brief Implementation of the OQS SHA3 times 4 API using the AVX512VL low interface.
4		*
5		* Copyright (c) 2025 Intel Corporation
6		*
7		* SPDX-License-Identifier: MIT
8		*/
9
10		#include "sha3x4.h"
11
12		#include <oqs/common.h>
13		#include <oqs/oqsconfig.h>
14
15		#include <stddef.h>
16		#include <stdint.h>
17		#include <stdlib.h>
18		#include <string.h>
19
20	0	#define KECCAK_X4_CTX_ALIGNMENT 32
21	0	#define _KECCAK_X4_CTX_BYTES (800 + sizeof(uint64_t))
22		#define KECCAK_X4_CTX_BYTES \
23	0	(KECCAK_X4_CTX_ALIGNMENT * \
24	0	((_KECCAK_X4_CTX_BYTES + KECCAK_X4_CTX_ALIGNMENT - 1) / KECCAK_X4_CTX_ALIGNMENT))
25
26		/******** SHAKE128 *********/
27
28		/* SHAKE128 external */
29
30		extern void
31		SHA3_shake128_x4_avx512vl(uint8_t out0, uint8_t out1, uint8_t out2, uint8_t out3, size_t outlen,
32		const uint8_t in0, const uint8_t in1, const uint8_t *in2,
33		const uint8_t *in3, size_t inlen);
34
35		extern void
36		SHA3_shake128_x4_inc_ctx_reset_avx512vl(OQS_SHA3_shake128_x4_inc_ctx *state);
37
38		extern void
39		SHA3_shake128_x4_inc_absorb_avx512vl(OQS_SHA3_shake128_x4_inc_ctx state, const uint8_t in0,
40		const uint8_t in1, const uint8_t in2, const uint8_t *in3,
41		size_t inlen);
42
43		extern void
44		SHA3_shake128_x4_inc_finalize_avx512vl(OQS_SHA3_shake128_x4_inc_ctx *state);
45
46		extern void
47		SHA3_shake128_x4_inc_squeeze_avx512vl(uint8_t out0, uint8_t out1, uint8_t out2, uint8_t out3,
48		size_t outlen, OQS_SHA3_shake128_x4_inc_ctx *state);
49
50		/* SHAKE128 incremental */
51
52		static void
53	0	SHA3_shake128_x4_inc_init_avx512vl(OQS_SHA3_shake128_x4_inc_ctx *state) {
54	0	state->ctx = OQS_MEM_aligned_alloc(KECCAK_X4_CTX_ALIGNMENT, KECCAK_X4_CTX_BYTES);
55	0	OQS_EXIT_IF_NULLPTR(state->ctx, "SHA3x4");
56	0	SHA3_shake128_x4_inc_ctx_reset_avx512vl(state);
57	0	}
58
59		static void
60		SHA3_shake128_x4_inc_ctx_clone_avx512vl(OQS_SHA3_shake128_x4_inc_ctx *dest,
61	0	const OQS_SHA3_shake128_x4_inc_ctx *src) {
62	0	memcpy(dest->ctx, src->ctx, KECCAK_X4_CTX_BYTES);
63	0	}
64
65		static void
66	0	SHA3_shake128_x4_inc_ctx_release_avx512vl(OQS_SHA3_shake128_x4_inc_ctx *state) {
67	0	SHA3_shake128_x4_inc_ctx_reset_avx512vl(state);
68	0	OQS_MEM_aligned_free(state->ctx);
69	0	}
70
71		/******** SHAKE256 *********/
72
73		/* SHAKE256 external */
74
75		extern void
76		SHA3_shake256_x4_avx512vl(uint8_t out0, uint8_t out1, uint8_t out2, uint8_t out3, size_t outlen,
77		const uint8_t in0, const uint8_t in1, const uint8_t *in2,
78		const uint8_t *in3, size_t inlen);
79
80		extern void
81		SHA3_shake256_x4_inc_ctx_reset_avx512vl(OQS_SHA3_shake256_x4_inc_ctx *state);
82
83		extern void
84		SHA3_shake256_x4_inc_absorb_avx512vl(OQS_SHA3_shake256_x4_inc_ctx state, const uint8_t in0,
85		const uint8_t in1, const uint8_t in2, const uint8_t *in3,
86		size_t inlen);
87
88		extern void
89		SHA3_shake256_x4_inc_finalize_avx512vl(OQS_SHA3_shake256_x4_inc_ctx *state);
90
91		extern void
92		SHA3_shake256_x4_inc_squeeze_avx512vl(uint8_t out0, uint8_t out1, uint8_t out2, uint8_t out3,
93		size_t outlen, OQS_SHA3_shake256_x4_inc_ctx *state);
94
95		/* SHAKE256 incremental */
96
97		static void
98	0	SHA3_shake256_x4_inc_init_avx512vl(OQS_SHA3_shake256_x4_inc_ctx *state) {
99	0	state->ctx = OQS_MEM_aligned_alloc(KECCAK_X4_CTX_ALIGNMENT, KECCAK_X4_CTX_BYTES);
100	0	OQS_EXIT_IF_NULLPTR(state->ctx, "SHA3x4");
101	0	SHA3_shake256_x4_inc_ctx_reset_avx512vl(state);
102	0	}
103
104		static void
105		SHA3_shake256_x4_inc_ctx_clone_avx512vl(OQS_SHA3_shake256_x4_inc_ctx *dest,
106	0	const OQS_SHA3_shake256_x4_inc_ctx *src) {
107	0	memcpy(dest->ctx, src->ctx, KECCAK_X4_CTX_BYTES);
108	0	}
109
110		static void
111	0	SHA3_shake256_x4_inc_ctx_release_avx512vl(OQS_SHA3_shake256_x4_inc_ctx *state) {
112	0	SHA3_shake256_x4_inc_ctx_reset_avx512vl(state);
113	0	OQS_MEM_aligned_free(state->ctx);
114	0	}
115
116		const struct OQS_SHA3_x4_callbacks sha3_x4_avx512vl_callbacks = {
117		SHA3_shake128_x4_avx512vl,
118		SHA3_shake128_x4_inc_init_avx512vl,
119		SHA3_shake128_x4_inc_absorb_avx512vl,
120		SHA3_shake128_x4_inc_finalize_avx512vl,
121		SHA3_shake128_x4_inc_squeeze_avx512vl,
122		SHA3_shake128_x4_inc_ctx_release_avx512vl,
123		SHA3_shake128_x4_inc_ctx_clone_avx512vl,
124		SHA3_shake128_x4_inc_ctx_reset_avx512vl,
125		SHA3_shake256_x4_avx512vl,
126		SHA3_shake256_x4_inc_init_avx512vl,
127		SHA3_shake256_x4_inc_absorb_avx512vl,
128		SHA3_shake256_x4_inc_finalize_avx512vl,
129		SHA3_shake256_x4_inc_squeeze_avx512vl,
130		SHA3_shake256_x4_inc_ctx_release_avx512vl,
131		SHA3_shake256_x4_inc_ctx_clone_avx512vl,
132		SHA3_shake256_x4_inc_ctx_reset_avx512vl,
133		};

Coverage Report

Created: 2026-02-14 07:23