Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2025 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "internal/libspdm_crypt_lib.h"
8 :
9 14 : uint32_t libspdm_get_kem_encap_key_size(uint32_t kem_alg)
10 : {
11 14 : switch (kem_alg) {
12 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512:
13 : #if LIBSPDM_ML_KEM_512_SUPPORT
14 : return 800;
15 : #else
16 0 : return 0;
17 : #endif
18 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768:
19 : #if LIBSPDM_ML_KEM_768_SUPPORT
20 : return 1184;
21 : #else
22 0 : return 0;
23 : #endif
24 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024:
25 : #if LIBSPDM_ML_KEM_1024_SUPPORT
26 : return 1568;
27 : #else
28 0 : return 0;
29 : #endif
30 14 : default:
31 14 : return 0;
32 : }
33 : }
34 :
35 0 : uint32_t libspdm_get_kem_cipher_text_size(uint32_t kem_alg)
36 : {
37 0 : switch (kem_alg) {
38 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512:
39 : #if LIBSPDM_ML_KEM_512_SUPPORT
40 : return 768;
41 : #else
42 0 : return 0;
43 : #endif
44 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768:
45 : #if LIBSPDM_ML_KEM_768_SUPPORT
46 : return 1088;
47 : #else
48 0 : return 0;
49 : #endif
50 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024:
51 : #if LIBSPDM_ML_KEM_1024_SUPPORT
52 : return 1568;
53 : #else
54 0 : return 0;
55 : #endif
56 0 : default:
57 0 : return 0;
58 : }
59 : }
60 :
61 0 : uint32_t libspdm_get_kem_shared_secret_size(uint32_t kem_alg)
62 : {
63 0 : switch (kem_alg) {
64 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512:
65 : #if LIBSPDM_ML_KEM_512_SUPPORT
66 : return 32;
67 : #else
68 0 : return 0;
69 : #endif
70 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768:
71 : #if LIBSPDM_ML_KEM_768_SUPPORT
72 : return 32;
73 : #else
74 0 : return 0;
75 : #endif
76 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024:
77 : #if LIBSPDM_ML_KEM_1024_SUPPORT
78 : return 32;
79 : #else
80 0 : return 0;
81 : #endif
82 0 : default:
83 0 : return 0;
84 : }
85 : }
86 :
87 0 : static size_t libspdm_get_kem_nid(uint32_t kem_alg)
88 : {
89 0 : switch (kem_alg) {
90 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512:
91 0 : return LIBSPDM_CRYPTO_NID_ML_KEM_512;
92 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768:
93 0 : return LIBSPDM_CRYPTO_NID_ML_KEM_768;
94 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024:
95 0 : return LIBSPDM_CRYPTO_NID_ML_KEM_1024;
96 0 : default:
97 0 : return LIBSPDM_CRYPTO_NID_NULL;
98 : }
99 : }
100 :
101 0 : void *libspdm_kem_new(spdm_version_number_t spdm_version,
102 : uint32_t kem_alg, bool is_initiator)
103 : {
104 : size_t nid;
105 :
106 0 : nid = libspdm_get_kem_nid(kem_alg);
107 0 : if (nid == LIBSPDM_CRYPTO_NID_NULL) {
108 0 : return NULL;
109 : }
110 :
111 0 : switch (kem_alg) {
112 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512:
113 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768:
114 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024:
115 : #if LIBSPDM_ML_KEM_SUPPORT
116 : #if !LIBSPDM_ML_KEM_512_SUPPORT
117 : LIBSPDM_ASSERT(kem_alg != SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512);
118 : #endif
119 : #if !LIBSPDM_ML_KEM_768_SUPPORT
120 : LIBSPDM_ASSERT(kem_alg != SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768);
121 : #endif
122 : #if !LIBSPDM_ML_KEM_1024_SUPPORT
123 : LIBSPDM_ASSERT(kem_alg != SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024);
124 : #endif
125 : return libspdm_mlkem_new_by_name(nid);
126 : #else
127 0 : LIBSPDM_ASSERT(false);
128 0 : return NULL;
129 : #endif
130 0 : default:
131 0 : LIBSPDM_ASSERT(false);
132 0 : return NULL;
133 : }
134 : }
135 :
136 0 : void libspdm_kem_free(uint32_t kem_alg, void *context)
137 : {
138 0 : if (context == NULL) {
139 0 : return;
140 : }
141 0 : switch (kem_alg) {
142 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512:
143 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768:
144 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024:
145 : #if LIBSPDM_ML_KEM_SUPPORT
146 : libspdm_mlkem_free(context);
147 : #else
148 0 : LIBSPDM_ASSERT(false);
149 : #endif
150 0 : break;
151 0 : default:
152 0 : LIBSPDM_ASSERT(false);
153 0 : break;
154 : }
155 : }
156 :
157 0 : bool libspdm_kem_generate_key(uint32_t kem_alg, void *context,
158 : uint8_t *encap_key,
159 : size_t *encap_key_size)
160 : {
161 0 : switch (kem_alg) {
162 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512:
163 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768:
164 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024:
165 : #if LIBSPDM_ML_KEM_SUPPORT
166 : #if !LIBSPDM_ML_KEM_512_SUPPORT
167 : LIBSPDM_ASSERT(kem_alg != SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512);
168 : #endif
169 : #if !LIBSPDM_ML_KEM_768_SUPPORT
170 : LIBSPDM_ASSERT(kem_alg != SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768);
171 : #endif
172 : #if !LIBSPDM_ML_KEM_1024_SUPPORT
173 : LIBSPDM_ASSERT(kem_alg != SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024);
174 : #endif
175 : return libspdm_mlkem_generate_key(context, encap_key, encap_key_size);
176 : #else
177 0 : LIBSPDM_ASSERT(false);
178 0 : return false;
179 : #endif
180 0 : default:
181 0 : LIBSPDM_ASSERT(false);
182 0 : return false;
183 : }
184 : }
185 :
186 0 : bool libspdm_kem_encapsulate(uint32_t kem_alg, void *context,
187 : const uint8_t *peer_encap_key,
188 : size_t peer_encap_key_size,
189 : uint8_t *cipher_text,
190 : size_t *cipher_text_size,
191 : uint8_t *shared_secret,
192 : size_t *shared_secret_size)
193 : {
194 0 : switch (kem_alg) {
195 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512:
196 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768:
197 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024:
198 : #if LIBSPDM_ML_KEM_SUPPORT
199 : #if !LIBSPDM_ML_KEM_512_SUPPORT
200 : LIBSPDM_ASSERT(kem_alg != SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512);
201 : #endif
202 : #if !LIBSPDM_ML_KEM_768_SUPPORT
203 : LIBSPDM_ASSERT(kem_alg != SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768);
204 : #endif
205 : #if !LIBSPDM_ML_KEM_1024_SUPPORT
206 : LIBSPDM_ASSERT(kem_alg != SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024);
207 : #endif
208 : return libspdm_mlkem_encapsulate (context, peer_encap_key, peer_encap_key_size,
209 : cipher_text, cipher_text_size,
210 : shared_secret, shared_secret_size);
211 : #else
212 0 : LIBSPDM_ASSERT(false);
213 0 : return false;
214 : #endif
215 0 : default:
216 0 : LIBSPDM_ASSERT(false);
217 0 : return false;
218 : }
219 : }
220 :
221 0 : bool libspdm_kem_decapsulate(uint32_t kem_alg, void *context,
222 : const uint8_t *peer_cipher_text,
223 : size_t peer_cipher_text_size,
224 : uint8_t *shared_secret,
225 : size_t *shared_secret_size)
226 : {
227 0 : switch (kem_alg) {
228 0 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512:
229 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768:
230 : case SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024:
231 : #if LIBSPDM_ML_KEM_SUPPORT
232 : #if !LIBSPDM_ML_KEM_512_SUPPORT
233 : LIBSPDM_ASSERT(kem_alg != SPDM_ALGORITHMS_KEM_ALG_ML_KEM_512);
234 : #endif
235 : #if !LIBSPDM_ML_KEM_768_SUPPORT
236 : LIBSPDM_ASSERT(kem_alg != SPDM_ALGORITHMS_KEM_ALG_ML_KEM_768);
237 : #endif
238 : #if !LIBSPDM_ML_KEM_1024_SUPPORT
239 : LIBSPDM_ASSERT(kem_alg != SPDM_ALGORITHMS_KEM_ALG_ML_KEM_1024);
240 : #endif
241 : return libspdm_mlkem_decapsulate (context, peer_cipher_text, peer_cipher_text_size,
242 : shared_secret, shared_secret_size);
243 : #else
244 0 : LIBSPDM_ASSERT(false);
245 0 : return false;
246 : #endif
247 0 : default:
248 0 : LIBSPDM_ASSERT(false);
249 0 : return false;
250 : }
251 : }
|
