/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	0	void OQS_SHA3_sha3_256(uint8_t output, const uint8_t input, size_t inplen) {
16	0	callbacks->SHA3_sha3_256(output, input, inplen);
17	0	}
18
19	0	void OQS_SHA3_sha3_256_inc_init(OQS_SHA3_sha3_256_inc_ctx *state) {
20	0	callbacks->SHA3_sha3_256_inc_init(state);
21	0	}
22
23	0	void OQS_SHA3_sha3_256_inc_absorb(OQS_SHA3_sha3_256_inc_ctx state, const uint8_t input, size_t inlen) {
24	0	callbacks->SHA3_sha3_256_inc_absorb(state, input, inlen);
25	0	}
26
27	0	void OQS_SHA3_sha3_256_inc_finalize(uint8_t output, OQS_SHA3_sha3_256_inc_ctx state) {
28	0	callbacks->SHA3_sha3_256_inc_finalize(output, state);
29	0	}
30
31	0	void OQS_SHA3_sha3_256_inc_ctx_release(OQS_SHA3_sha3_256_inc_ctx *state) {
32	0	callbacks->SHA3_sha3_256_inc_ctx_release(state);
33	0	}
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	0	void OQS_SHA3_sha3_384(uint8_t output, const uint8_t input, size_t inplen) {
44	0	callbacks->SHA3_sha3_384(output, input, inplen);
45	0	}
46
47	0	void OQS_SHA3_sha3_384_inc_init(OQS_SHA3_sha3_384_inc_ctx *state) {
48	0	callbacks->SHA3_sha3_384_inc_init(state);
49	0	}
50
51	0	void OQS_SHA3_sha3_384_inc_absorb(OQS_SHA3_sha3_384_inc_ctx state, const uint8_t input, size_t inlen) {
52	0	callbacks->SHA3_sha3_384_inc_absorb(state, input, inlen);
53	0	}
54
55	0	void OQS_SHA3_sha3_384_inc_finalize(uint8_t output, OQS_SHA3_sha3_384_inc_ctx state) {
56	0	callbacks->SHA3_sha3_384_inc_finalize(output, state);
57	0	}
58
59	0	void OQS_SHA3_sha3_384_inc_ctx_release(OQS_SHA3_sha3_384_inc_ctx *state) {
60	0	callbacks->SHA3_sha3_384_inc_ctx_release(state);
61	0	}
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	0	void OQS_SHA3_sha3_512(uint8_t output, const uint8_t input, size_t inplen) {
72	0	callbacks->SHA3_sha3_512(output, input, inplen);
73	0	}
74
75	0	void OQS_SHA3_sha3_512_inc_init(OQS_SHA3_sha3_512_inc_ctx *state) {
76	0	callbacks->SHA3_sha3_512_inc_init(state);
77	0	}
78
79	0	void OQS_SHA3_sha3_512_inc_absorb(OQS_SHA3_sha3_512_inc_ctx state, const uint8_t input, size_t inlen) {
80	0	callbacks->SHA3_sha3_512_inc_absorb(state, input, inlen);
81	0	}
82
83	0	void OQS_SHA3_sha3_512_inc_finalize(uint8_t output, OQS_SHA3_sha3_512_inc_ctx state) {
84	0	callbacks->SHA3_sha3_512_inc_finalize(output, state);
85	0	}
86
87	0	void OQS_SHA3_sha3_512_inc_ctx_release(OQS_SHA3_sha3_512_inc_ctx *state) {
88	0	callbacks->SHA3_sha3_512_inc_ctx_release(state);
89	0	}
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	0	void OQS_SHA3_shake128(uint8_t output, size_t outlen, const uint8_t input, size_t inplen) {
100	0	callbacks->SHA3_shake128(output, outlen, input, inplen);
101	0	}
102
103	0	void OQS_SHA3_shake128_inc_init(OQS_SHA3_shake128_inc_ctx *state) {
104	0	callbacks->SHA3_shake128_inc_init(state);
105	0	}
106
107	0	void OQS_SHA3_shake128_inc_absorb(OQS_SHA3_shake128_inc_ctx state, const uint8_t input, size_t inlen) {
108	0	callbacks->SHA3_shake128_inc_absorb(state, input, inlen);
109	0	}
110
111	0	void OQS_SHA3_shake128_inc_finalize(OQS_SHA3_shake128_inc_ctx *state) {
112	0	callbacks->SHA3_shake128_inc_finalize(state);
113	0	}
114
115	0	void OQS_SHA3_shake128_inc_squeeze(uint8_t output, size_t outlen, OQS_SHA3_shake128_inc_ctx state) {
116	0	callbacks->SHA3_shake128_inc_squeeze(output, outlen, state);
117	0	}
118
119	0	void OQS_SHA3_shake128_inc_ctx_release(OQS_SHA3_shake128_inc_ctx *state) {
120	0	callbacks->SHA3_shake128_inc_ctx_release(state);
121	0	}
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	0	void OQS_SHA3_shake128_inc_ctx_reset(OQS_SHA3_shake128_inc_ctx *state) {
128	0	callbacks->SHA3_shake128_inc_ctx_reset(state);
129	0	}
130
131	0	void OQS_SHA3_shake256(uint8_t output, size_t outlen, const uint8_t input, size_t inplen) {
132	0	callbacks->SHA3_shake256(output, outlen, input, inplen);
133	0	}
134
135	0	void OQS_SHA3_shake256_inc_init(OQS_SHA3_shake256_inc_ctx *state) {
136	0	callbacks->SHA3_shake256_inc_init(state);
137	0	}
138
139	0	void OQS_SHA3_shake256_inc_absorb(OQS_SHA3_shake256_inc_ctx state, const uint8_t input, size_t inlen) {
140	0	callbacks->SHA3_shake256_inc_absorb(state, input, inlen);
141	0	}
142
143	0	void OQS_SHA3_shake256_inc_finalize(OQS_SHA3_shake256_inc_ctx *state) {
144	0	callbacks->SHA3_shake256_inc_finalize(state);
145	0	}
146
147	0	void OQS_SHA3_shake256_inc_squeeze(uint8_t output, size_t outlen, OQS_SHA3_shake256_inc_ctx state) {
148	0	callbacks->SHA3_shake256_inc_squeeze(output, outlen, state);
149	0	}
150
151	0	void OQS_SHA3_shake256_inc_ctx_release(OQS_SHA3_shake256_inc_ctx *state) {
152	0	callbacks->SHA3_shake256_inc_ctx_release(state);
153	0	}
154
155	0	void OQS_SHA3_shake256_inc_ctx_clone(OQS_SHA3_shake256_inc_ctx dest, const OQS_SHA3_shake256_inc_ctx src) {
156	0	callbacks->SHA3_shake256_inc_ctx_clone(dest, src);
157	0	}
158
159	0	void OQS_SHA3_shake256_inc_ctx_reset(OQS_SHA3_shake256_inc_ctx *state) {
160	0	callbacks->SHA3_shake256_inc_ctx_reset(state);
161	0	}

Coverage Report

Created: 2025-12-31 07:45