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

Source
// SPDX-License-Identifier: MIT

#include <oqs/oqs.h>

#include "sha3.h"

extern struct OQS_SHA3_callbacks sha3_default_callbacks;

static struct OQS_SHA3_callbacks *callbacks = &sha3_default_callbacks;

OQS_API void OQS_SHA3_set_callbacks(struct OQS_SHA3_callbacks *new_callbacks) {
  callbacks = new_callbacks;
}

void OQS_SHA3_sha3_256(uint8_t *output, const uint8_t *input, size_t inplen) {
  callbacks->SHA3_sha3_256(output, input, inplen);
}

void OQS_SHA3_sha3_256_inc_init(OQS_SHA3_sha3_256_inc_ctx *state) {
  callbacks->SHA3_sha3_256_inc_init(state);
}

void OQS_SHA3_sha3_256_inc_absorb(OQS_SHA3_sha3_256_inc_ctx *state, const uint8_t *input, size_t inlen) {
  callbacks->SHA3_sha3_256_inc_absorb(state, input, inlen);
}

void OQS_SHA3_sha3_256_inc_finalize(uint8_t *output, OQS_SHA3_sha3_256_inc_ctx *state) {
  callbacks->SHA3_sha3_256_inc_finalize(output, state);
}

void OQS_SHA3_sha3_256_inc_ctx_release(OQS_SHA3_sha3_256_inc_ctx *state) {
  callbacks->SHA3_sha3_256_inc_ctx_release(state);
}

void OQS_SHA3_sha3_256_inc_ctx_reset(OQS_SHA3_sha3_256_inc_ctx *state) {
  callbacks->SHA3_sha3_256_inc_ctx_reset(state);
}

void OQS_SHA3_sha3_256_inc_ctx_clone(OQS_SHA3_sha3_256_inc_ctx *dest, const OQS_SHA3_sha3_256_inc_ctx *src) {
  callbacks->SHA3_sha3_256_inc_ctx_clone(dest, src);
}

void OQS_SHA3_sha3_384(uint8_t *output, const uint8_t *input, size_t inplen) {
  callbacks->SHA3_sha3_384(output, input, inplen);
}

void OQS_SHA3_sha3_384_inc_init(OQS_SHA3_sha3_384_inc_ctx *state) {
  callbacks->SHA3_sha3_384_inc_init(state);
}

void OQS_SHA3_sha3_384_inc_absorb(OQS_SHA3_sha3_384_inc_ctx *state, const uint8_t *input, size_t inlen) {
  callbacks->SHA3_sha3_384_inc_absorb(state, input, inlen);
}

void OQS_SHA3_sha3_384_inc_finalize(uint8_t *output, OQS_SHA3_sha3_384_inc_ctx *state) {
  callbacks->SHA3_sha3_384_inc_finalize(output, state);
}

void OQS_SHA3_sha3_384_inc_ctx_release(OQS_SHA3_sha3_384_inc_ctx *state) {
  callbacks->SHA3_sha3_384_inc_ctx_release(state);
}

void OQS_SHA3_sha3_384_inc_ctx_reset(OQS_SHA3_sha3_384_inc_ctx *state) {
  callbacks->SHA3_sha3_384_inc_ctx_reset(state);
}

void OQS_SHA3_sha3_384_inc_ctx_clone(OQS_SHA3_sha3_384_inc_ctx *dest, const OQS_SHA3_sha3_384_inc_ctx *src) {
  callbacks->SHA3_sha3_384_inc_ctx_clone(dest, src);
}

void OQS_SHA3_sha3_512(uint8_t *output, const uint8_t *input, size_t inplen) {
  callbacks->SHA3_sha3_512(output, input, inplen);
}

void OQS_SHA3_sha3_512_inc_init(OQS_SHA3_sha3_512_inc_ctx *state) {
  callbacks->SHA3_sha3_512_inc_init(state);
}

void OQS_SHA3_sha3_512_inc_absorb(OQS_SHA3_sha3_512_inc_ctx *state, const uint8_t *input, size_t inlen) {
  callbacks->SHA3_sha3_512_inc_absorb(state, input, inlen);
}

void OQS_SHA3_sha3_512_inc_finalize(uint8_t *output, OQS_SHA3_sha3_512_inc_ctx *state) {
  callbacks->SHA3_sha3_512_inc_finalize(output, state);
}

void OQS_SHA3_sha3_512_inc_ctx_release(OQS_SHA3_sha3_512_inc_ctx *state) {
  callbacks->SHA3_sha3_512_inc_ctx_release(state);
}

void OQS_SHA3_sha3_512_inc_ctx_reset(OQS_SHA3_sha3_512_inc_ctx *state) {
  callbacks->SHA3_sha3_512_inc_ctx_reset(state);
}

void OQS_SHA3_sha3_512_inc_ctx_clone(OQS_SHA3_sha3_512_inc_ctx *dest, const OQS_SHA3_sha3_512_inc_ctx *src) {
  callbacks->SHA3_sha3_512_inc_ctx_clone(dest, src);
}

void OQS_SHA3_shake128(uint8_t *output, size_t outlen, const uint8_t *input, size_t inplen) {
  callbacks->SHA3_shake128(output, outlen, input, inplen);
}

void OQS_SHA3_shake128_inc_init(OQS_SHA3_shake128_inc_ctx *state) {
  callbacks->SHA3_shake128_inc_init(state);
}

void OQS_SHA3_shake128_inc_absorb(OQS_SHA3_shake128_inc_ctx *state, const uint8_t *input, size_t inlen) {
  callbacks->SHA3_shake128_inc_absorb(state, input, inlen);
}

void OQS_SHA3_shake128_inc_finalize(OQS_SHA3_shake128_inc_ctx *state) {
  callbacks->SHA3_shake128_inc_finalize(state);
}

void OQS_SHA3_shake128_inc_squeeze(uint8_t *output, size_t outlen, OQS_SHA3_shake128_inc_ctx *state) {
  callbacks->SHA3_shake128_inc_squeeze(output, outlen, state);
}

void OQS_SHA3_shake128_inc_ctx_release(OQS_SHA3_shake128_inc_ctx *state) {
  callbacks->SHA3_shake128_inc_ctx_release(state);
}

void OQS_SHA3_shake128_inc_ctx_clone(OQS_SHA3_shake128_inc_ctx *dest, const OQS_SHA3_shake128_inc_ctx *src) {
  callbacks->SHA3_shake128_inc_ctx_clone(dest, src);
}

void OQS_SHA3_shake128_inc_ctx_reset(OQS_SHA3_shake128_inc_ctx *state) {
  callbacks->SHA3_shake128_inc_ctx_reset(state);
}

void OQS_SHA3_shake256(uint8_t *output, size_t outlen, const uint8_t *input, size_t inplen) {
  callbacks->SHA3_shake256(output, outlen, input, inplen);
}

void OQS_SHA3_shake256_inc_init(OQS_SHA3_shake256_inc_ctx *state) {
  callbacks->SHA3_shake256_inc_init(state);
}

void OQS_SHA3_shake256_inc_absorb(OQS_SHA3_shake256_inc_ctx *state, const uint8_t *input, size_t inlen) {
  callbacks->SHA3_shake256_inc_absorb(state, input, inlen);
}

void OQS_SHA3_shake256_inc_finalize(OQS_SHA3_shake256_inc_ctx *state) {
  callbacks->SHA3_shake256_inc_finalize(state);
}

void OQS_SHA3_shake256_inc_squeeze(uint8_t *output, size_t outlen, OQS_SHA3_shake256_inc_ctx *state) {
  callbacks->SHA3_shake256_inc_squeeze(output, outlen, state);
}

void OQS_SHA3_shake256_inc_ctx_release(OQS_SHA3_shake256_inc_ctx *state) {
  callbacks->SHA3_shake256_inc_ctx_release(state);
}

void OQS_SHA3_shake256_inc_ctx_clone(OQS_SHA3_shake256_inc_ctx *dest, const OQS_SHA3_shake256_inc_ctx *src) {
  callbacks->SHA3_shake256_inc_ctx_clone(dest, src);
}

void OQS_SHA3_shake256_inc_ctx_reset(OQS_SHA3_shake256_inc_ctx *state) {
  callbacks->SHA3_shake256_inc_ctx_reset(state);
}

Line	Count	Source
1		// SPDX-License-Identifier: MIT
2
3		#include <oqs/oqs.h>
4
5		#include "sha3.h"
6
7		extern struct OQS_SHA3_callbacks sha3_default_callbacks;
8
9		static struct OQS_SHA3_callbacks *callbacks = &sha3_default_callbacks;
10
11	0	OQS_API void OQS_SHA3_set_callbacks(struct OQS_SHA3_callbacks *new_callbacks) {
12	0	callbacks = new_callbacks;
13	0	}
14
15	2.58k	void OQS_SHA3_sha3_256(uint8_t output, const uint8_t input, size_t inplen) {
16	2.58k	callbacks->SHA3_sha3_256(output, input, inplen);
17	2.58k	}
18
19	2.58k	void OQS_SHA3_sha3_256_inc_init(OQS_SHA3_sha3_256_inc_ctx *state) {
20	2.58k	callbacks->SHA3_sha3_256_inc_init(state);
21	2.58k	}
22
23	2.58k	void OQS_SHA3_sha3_256_inc_absorb(OQS_SHA3_sha3_256_inc_ctx state, const uint8_t input, size_t inlen) {
24	2.58k	callbacks->SHA3_sha3_256_inc_absorb(state, input, inlen);
25	2.58k	}
26
27	2.58k	void OQS_SHA3_sha3_256_inc_finalize(uint8_t output, OQS_SHA3_sha3_256_inc_ctx state) {
28	2.58k	callbacks->SHA3_sha3_256_inc_finalize(output, state);
29	2.58k	}
30
31	2.58k	void OQS_SHA3_sha3_256_inc_ctx_release(OQS_SHA3_sha3_256_inc_ctx *state) {
32	2.58k	callbacks->SHA3_sha3_256_inc_ctx_release(state);
33	2.58k	}
34
35	0	void OQS_SHA3_sha3_256_inc_ctx_reset(OQS_SHA3_sha3_256_inc_ctx *state) {
36	0	callbacks->SHA3_sha3_256_inc_ctx_reset(state);
37	0	}
38
39	0	void OQS_SHA3_sha3_256_inc_ctx_clone(OQS_SHA3_sha3_256_inc_ctx dest, const OQS_SHA3_sha3_256_inc_ctx src) {
40	0	callbacks->SHA3_sha3_256_inc_ctx_clone(dest, src);
41	0	}
42
43	28	void OQS_SHA3_sha3_384(uint8_t output, const uint8_t input, size_t inplen) {
44	28	callbacks->SHA3_sha3_384(output, input, inplen);
45	28	}
46
47	28	void OQS_SHA3_sha3_384_inc_init(OQS_SHA3_sha3_384_inc_ctx *state) {
48	28	callbacks->SHA3_sha3_384_inc_init(state);
49	28	}
50
51	28	void OQS_SHA3_sha3_384_inc_absorb(OQS_SHA3_sha3_384_inc_ctx state, const uint8_t input, size_t inlen) {
52	28	callbacks->SHA3_sha3_384_inc_absorb(state, input, inlen);
53	28	}
54
55	28	void OQS_SHA3_sha3_384_inc_finalize(uint8_t output, OQS_SHA3_sha3_384_inc_ctx state) {
56	28	callbacks->SHA3_sha3_384_inc_finalize(output, state);
57	28	}
58
59	28	void OQS_SHA3_sha3_384_inc_ctx_release(OQS_SHA3_sha3_384_inc_ctx *state) {
60	28	callbacks->SHA3_sha3_384_inc_ctx_release(state);
61	28	}
62
63	0	void OQS_SHA3_sha3_384_inc_ctx_reset(OQS_SHA3_sha3_384_inc_ctx *state) {
64	0	callbacks->SHA3_sha3_384_inc_ctx_reset(state);
65	0	}
66
67	0	void OQS_SHA3_sha3_384_inc_ctx_clone(OQS_SHA3_sha3_384_inc_ctx dest, const OQS_SHA3_sha3_384_inc_ctx src) {
68	0	callbacks->SHA3_sha3_384_inc_ctx_clone(dest, src);
69	0	}
70
71	1.04k	void OQS_SHA3_sha3_512(uint8_t output, const uint8_t input, size_t inplen) {
72	1.04k	callbacks->SHA3_sha3_512(output, input, inplen);
73	1.04k	}
74
75	1.04k	void OQS_SHA3_sha3_512_inc_init(OQS_SHA3_sha3_512_inc_ctx *state) {
76	1.04k	callbacks->SHA3_sha3_512_inc_init(state);
77	1.04k	}
78
79	1.04k	void OQS_SHA3_sha3_512_inc_absorb(OQS_SHA3_sha3_512_inc_ctx state, const uint8_t input, size_t inlen) {
80	1.04k	callbacks->SHA3_sha3_512_inc_absorb(state, input, inlen);
81	1.04k	}
82
83	1.04k	void OQS_SHA3_sha3_512_inc_finalize(uint8_t output, OQS_SHA3_sha3_512_inc_ctx state) {
84	1.04k	callbacks->SHA3_sha3_512_inc_finalize(output, state);
85	1.04k	}
86
87	1.04k	void OQS_SHA3_sha3_512_inc_ctx_release(OQS_SHA3_sha3_512_inc_ctx *state) {
88	1.04k	callbacks->SHA3_sha3_512_inc_ctx_release(state);
89	1.04k	}
90
91	0	void OQS_SHA3_sha3_512_inc_ctx_reset(OQS_SHA3_sha3_512_inc_ctx *state) {
92	0	callbacks->SHA3_sha3_512_inc_ctx_reset(state);
93	0	}
94
95	0	void OQS_SHA3_sha3_512_inc_ctx_clone(OQS_SHA3_sha3_512_inc_ctx dest, const OQS_SHA3_sha3_512_inc_ctx src) {
96	0	callbacks->SHA3_sha3_512_inc_ctx_clone(dest, src);
97	0	}
98
99	80	void OQS_SHA3_shake128(uint8_t output, size_t outlen, const uint8_t input, size_t inplen) {
100	80	callbacks->SHA3_shake128(output, outlen, input, inplen);
101	80	}
102
103	397k	void OQS_SHA3_shake128_inc_init(OQS_SHA3_shake128_inc_ctx *state) {
104	397k	callbacks->SHA3_shake128_inc_init(state);
105	397k	}
106
107	824k	void OQS_SHA3_shake128_inc_absorb(OQS_SHA3_shake128_inc_ctx state, const uint8_t input, size_t inlen) {
108	824k	callbacks->SHA3_shake128_inc_absorb(state, input, inlen);
109	824k	}
110
111	399k	void OQS_SHA3_shake128_inc_finalize(OQS_SHA3_shake128_inc_ctx *state) {
112	399k	callbacks->SHA3_shake128_inc_finalize(state);
113	399k	}
114
115	771k	void OQS_SHA3_shake128_inc_squeeze(uint8_t output, size_t outlen, OQS_SHA3_shake128_inc_ctx state) {
116	771k	callbacks->SHA3_shake128_inc_squeeze(output, outlen, state);
117	771k	}
118
119	397k	void OQS_SHA3_shake128_inc_ctx_release(OQS_SHA3_shake128_inc_ctx *state) {
120	397k	callbacks->SHA3_shake128_inc_ctx_release(state);
121	397k	}
122
123	0	void OQS_SHA3_shake128_inc_ctx_clone(OQS_SHA3_shake128_inc_ctx dest, const OQS_SHA3_shake128_inc_ctx src) {
124	0	callbacks->SHA3_shake128_inc_ctx_clone(dest, src);
125	0	}
126
127	1.96k	void OQS_SHA3_shake128_inc_ctx_reset(OQS_SHA3_shake128_inc_ctx *state) {
128	1.96k	callbacks->SHA3_shake128_inc_ctx_reset(state);
129	1.96k	}
130
131	9.20k	void OQS_SHA3_shake256(uint8_t output, size_t outlen, const uint8_t input, size_t inplen) {
132	9.20k	callbacks->SHA3_shake256(output, outlen, input, inplen);
133	9.20k	}
134
135	1.40M	void OQS_SHA3_shake256_inc_init(OQS_SHA3_shake256_inc_ctx *state) {
136	1.40M	callbacks->SHA3_shake256_inc_init(state);
137	1.40M	}
138
139	2.87M	void OQS_SHA3_shake256_inc_absorb(OQS_SHA3_shake256_inc_ctx state, const uint8_t input, size_t inlen) {
140	2.87M	callbacks->SHA3_shake256_inc_absorb(state, input, inlen);
141	2.87M	}
142
143	1.41M	void OQS_SHA3_shake256_inc_finalize(OQS_SHA3_shake256_inc_ctx *state) {
144	1.41M	callbacks->SHA3_shake256_inc_finalize(state);
145	1.41M	}
146
147	175M	void OQS_SHA3_shake256_inc_squeeze(uint8_t output, size_t outlen, OQS_SHA3_shake256_inc_ctx state) {
148	175M	callbacks->SHA3_shake256_inc_squeeze(output, outlen, state);
149	175M	}
150
151	1.40M	void OQS_SHA3_shake256_inc_ctx_release(OQS_SHA3_shake256_inc_ctx *state) {
152	1.40M	callbacks->SHA3_shake256_inc_ctx_release(state);
153	1.40M	}
154
155	246	void OQS_SHA3_shake256_inc_ctx_clone(OQS_SHA3_shake256_inc_ctx dest, const OQS_SHA3_shake256_inc_ctx src) {
156	246	callbacks->SHA3_shake256_inc_ctx_clone(dest, src);
157	246	}
158
159	2.81k	void OQS_SHA3_shake256_inc_ctx_reset(OQS_SHA3_shake256_inc_ctx *state) {
160	2.81k	callbacks->SHA3_shake256_inc_ctx_reset(state);
161	2.81k	}

Coverage Report

Created: 2026-05-16 06:25