Branch data Line data Source code
1 : : /*
2 : : * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 : : *
4 : : * Licensed under the Apache License, Version 2.0 (the "License").
5 : : * You may not use this file except in compliance with the License.
6 : : * A copy of the License is located at
7 : : *
8 : : * http://aws.amazon.com/apache2.0
9 : : *
10 : : * or in the "license" file accompanying this file. This file is distributed
11 : : * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
12 : : * express or implied. See the License for the specific language governing
13 : : * permissions and limitations under the License.
14 : : */
15 : :
16 : : #include "api/s2n.h"
17 : : #include "crypto/s2n_dhe.h"
18 : : #include "crypto/s2n_fips.h"
19 : : #include "error/s2n_errno.h"
20 : : #include "stuffer/s2n_stuffer.h"
21 : : #include "tls/s2n_async_pkey.h"
22 : : #include "tls/s2n_cipher_preferences.h"
23 : : #include "tls/s2n_cipher_suites.h"
24 : : #include "tls/s2n_connection.h"
25 : : #include "tls/s2n_kem.h"
26 : : #include "tls/s2n_kex.h"
27 : : #include "tls/s2n_security_policies.h"
28 : : #include "tls/s2n_signature_algorithms.h"
29 : : #include "utils/s2n_random.h"
30 : : #include "utils/s2n_safety.h"
31 : :
32 : : static int s2n_server_key_send_write_signature(struct s2n_connection *conn, struct s2n_blob *signature);
33 : :
34 : : int s2n_server_key_recv(struct s2n_connection *conn)
35 : 824 : {
36 [ - + ][ # # ]: 824 : POSIX_ENSURE_REF(conn);
37 [ # # ][ - + ]: 824 : POSIX_ENSURE_REF(conn->secure);
38 [ - + ][ # # ]: 824 : POSIX_ENSURE_REF(conn->secure->cipher_suite);
39 [ - + ][ # # ]: 824 : POSIX_ENSURE_REF(conn->secure->cipher_suite->key_exchange_alg);
40 [ # # ][ - + ]: 824 : POSIX_ENSURE_REF(conn->handshake.hashes);
41 : :
42 : 824 : struct s2n_hash_state *signature_hash = &conn->handshake.hashes->hash_workspace;
43 : 824 : const struct s2n_kex *key_exchange = conn->secure->cipher_suite->key_exchange_alg;
44 : 824 : struct s2n_stuffer *in = &conn->handshake.io;
45 : 824 : struct s2n_blob data_to_verify = { 0 };
46 : :
47 [ - + ][ - + ]: 1638 : S2N_ASYNC_OFFLOAD_POSIX_GUARD(conn, {
[ - + ][ - + ]
[ - + ][ + + ]
[ - + ][ # # ]
[ - + ][ # # ]
[ - + ][ + + ]
[ + + ][ - + ]
[ - + ][ + + ]
[ # # ][ - + ]
[ + - ][ - + ]
[ # # ][ - + ]
[ + + ][ + - ]
48 : : /* Read the KEX data */
49 : 814 : struct s2n_kex_raw_server_data kex_data = { 0 };
50 : 814 : POSIX_GUARD_RESULT(s2n_kex_server_key_recv_read_data(key_exchange, conn, &data_to_verify, &kex_data));
51 : :
52 : : /* Parse the KEX data into whatever form needed and save it to the connection object */
53 : 814 : POSIX_GUARD_RESULT(s2n_kex_server_key_recv_parse_data(key_exchange, conn, &kex_data));
54 : :
55 : 814 : POSIX_GUARD_RESULT(s2n_signature_algorithm_recv(conn, in));
56 : 814 : const struct s2n_signature_scheme *active_sig_scheme = conn->handshake_params.server_cert_sig_scheme;
57 : 814 : POSIX_ENSURE_REF(active_sig_scheme);
58 : :
59 : 814 : struct s2n_pkey *pkey = &conn->handshake_params.server_public_key;
60 : :
61 : 814 : POSIX_ENSURE(s2n_result_is_ok(s2n_signature_scheme_params_match(conn, pkey, active_sig_scheme)), S2N_ERR_INVALID_SIGNATURE_ALGORITHM);
62 : :
63 : 814 : POSIX_GUARD(s2n_hash_init(signature_hash, active_sig_scheme->hash_alg));
64 : 814 : POSIX_GUARD(s2n_hash_update(signature_hash, conn->client_hello.random, S2N_TLS_RANDOM_DATA_LEN));
65 : 814 : POSIX_GUARD(s2n_hash_update(signature_hash, conn->handshake_params.server_random, S2N_TLS_RANDOM_DATA_LEN));
66 : :
67 : : /* Add KEX specific data */
68 : 814 : POSIX_GUARD(s2n_hash_update(signature_hash, data_to_verify.data, data_to_verify.size));
69 : :
70 : : /* Verify the signature */
71 : 814 : uint16_t signature_length = 0;
72 : 814 : POSIX_GUARD(s2n_stuffer_read_uint16(in, &signature_length));
73 : :
74 : 814 : struct s2n_blob signature = { 0 };
75 : 814 : POSIX_GUARD(s2n_blob_init(&signature, s2n_stuffer_raw_read(in, signature_length), signature_length));
76 : :
77 : 814 : POSIX_ENSURE_REF(signature.data);
78 : 814 : POSIX_ENSURE_GT(signature_length, 0);
79 : :
80 : 814 : POSIX_GUARD(s2n_async_pkey_verify(conn, active_sig_scheme->sig_alg, signature_hash, &signature));
81 : 814 : });
82 : :
83 : : /* We don't need the key any more, so free it */
84 [ - + ]: 814 : POSIX_GUARD(s2n_pkey_free(&conn->handshake_params.server_public_key));
85 : :
86 : 814 : return 0;
87 : 814 : }
88 : :
89 : : int s2n_ecdhe_server_key_recv_read_data(struct s2n_connection *conn, struct s2n_blob *data_to_verify,
90 : : struct s2n_kex_raw_server_data *raw_server_data)
91 : 796 : {
92 : 796 : struct s2n_stuffer *in = &conn->handshake.io;
93 : :
94 [ - + ]: 796 : POSIX_GUARD(s2n_ecc_evp_read_params(in, data_to_verify, &raw_server_data->ecdhe_data));
95 : 796 : return 0;
96 : 796 : }
97 : :
98 : : int s2n_ecdhe_server_key_recv_parse_data(struct s2n_connection *conn, struct s2n_kex_raw_server_data *raw_server_data)
99 : 796 : {
100 [ - + ]: 796 : POSIX_GUARD(s2n_ecc_evp_parse_params(conn, &raw_server_data->ecdhe_data, &conn->kex_params.server_ecc_evp_params));
101 : :
102 : 796 : return 0;
103 : 796 : }
104 : :
105 : : int s2n_dhe_server_key_recv_read_data(struct s2n_connection *conn, struct s2n_blob *data_to_verify,
106 : : struct s2n_kex_raw_server_data *raw_server_data)
107 : 24 : {
108 : 24 : struct s2n_stuffer *in = &conn->handshake.io;
109 : 24 : struct s2n_dhe_raw_server_points *dhe_data = &raw_server_data->dhe_data;
110 : :
111 : 24 : uint16_t p_length = 0;
112 : 24 : uint16_t g_length = 0;
113 : 24 : uint16_t Ys_length = 0;
114 : :
115 : : /* Keep a copy to the start of the whole structure for the signature check */
116 : 24 : data_to_verify->data = s2n_stuffer_raw_read(in, 0);
117 [ - + ][ # # ]: 24 : POSIX_ENSURE_REF(data_to_verify->data);
118 : :
119 : : /* Read each of the three elements in */
120 [ - + ]: 24 : POSIX_GUARD(s2n_stuffer_read_uint16(in, &p_length));
121 : 24 : dhe_data->p.size = p_length;
122 : 24 : dhe_data->p.data = s2n_stuffer_raw_read(in, p_length);
123 [ - + ][ # # ]: 24 : POSIX_ENSURE_REF(dhe_data->p.data);
124 : :
125 [ - + ]: 24 : POSIX_GUARD(s2n_stuffer_read_uint16(in, &g_length));
126 : 24 : dhe_data->g.size = g_length;
127 : 24 : dhe_data->g.data = s2n_stuffer_raw_read(in, g_length);
128 [ - + ][ # # ]: 24 : POSIX_ENSURE_REF(dhe_data->g.data);
129 : :
130 [ - + ]: 24 : POSIX_GUARD(s2n_stuffer_read_uint16(in, &Ys_length));
131 : 24 : dhe_data->Ys.size = Ys_length;
132 : 24 : dhe_data->Ys.data = s2n_stuffer_raw_read(in, Ys_length);
133 [ # # ][ - + ]: 24 : POSIX_ENSURE_REF(dhe_data->Ys.data);
134 : :
135 : : /* Now we know the total size of the structure */
136 : 24 : data_to_verify->size = 2 + p_length + 2 + g_length + 2 + Ys_length;
137 : 24 : return 0;
138 : 24 : }
139 : :
140 : : int s2n_dhe_server_key_recv_parse_data(struct s2n_connection *conn, struct s2n_kex_raw_server_data *raw_server_data)
141 : 24 : {
142 : 24 : struct s2n_dhe_raw_server_points dhe_data = raw_server_data->dhe_data;
143 : :
144 : : /* Copy the DH details */
145 [ - + ]: 24 : POSIX_GUARD(s2n_dh_p_g_Ys_to_dh_params(&conn->kex_params.server_dh_params, &dhe_data.p, &dhe_data.g, &dhe_data.Ys));
146 : 24 : return 0;
147 : 24 : }
148 : :
149 : : int s2n_kem_server_key_recv_read_data(struct s2n_connection *conn, struct s2n_blob *data_to_verify,
150 : : struct s2n_kex_raw_server_data *raw_server_data)
151 : 0 : {
152 : 0 : struct s2n_kem_raw_server_params *kem_data = &raw_server_data->kem_data;
153 : 0 : struct s2n_stuffer *in = &conn->handshake.io;
154 : :
155 : : /* Keep a copy to the start of the whole structure for the signature check */
156 : 0 : data_to_verify->data = s2n_stuffer_raw_read(in, 0);
157 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(data_to_verify->data);
158 : :
159 : : /* the server sends the KEM ID */
160 : 0 : kem_data->kem_name.data = s2n_stuffer_raw_read(in, 2);
161 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(kem_data->kem_name.data);
162 : 0 : kem_data->kem_name.size = 2;
163 : :
164 : 0 : struct s2n_stuffer kem_id_stuffer = { 0 };
165 : 0 : uint8_t kem_id_arr[2] = { 0 };
166 : 0 : kem_extension_size kem_id = 0;
167 : 0 : struct s2n_blob kem_id_blob = { 0 };
168 [ # # ]: 0 : POSIX_GUARD(s2n_blob_init(&kem_id_blob, kem_id_arr, s2n_array_len(kem_id_arr)));
169 [ # # ]: 0 : POSIX_GUARD(s2n_stuffer_init(&kem_id_stuffer, &kem_id_blob));
170 [ # # ]: 0 : POSIX_GUARD(s2n_stuffer_write(&kem_id_stuffer, &(kem_data->kem_name)));
171 [ # # ]: 0 : POSIX_GUARD(s2n_stuffer_read_uint16(&kem_id_stuffer, &kem_id));
172 : :
173 [ # # ]: 0 : POSIX_GUARD(s2n_get_kem_from_extension_id(kem_id, &(conn->kex_params.kem_params.kem)));
174 : 0 : kem_public_key_size public_key_length = 0;
175 [ # # ]: 0 : POSIX_GUARD(s2n_stuffer_read_uint16(in, &public_key_length));
176 [ # # ][ # # ]: 0 : POSIX_ENSURE(public_key_length == conn->kex_params.kem_params.kem->public_key_length, S2N_ERR_BAD_MESSAGE);
177 [ # # ]: 0 : POSIX_GUARD(s2n_kem_recv_public_key(in, &(conn->kex_params.kem_params)));
178 : :
179 : 0 : kem_data->raw_public_key.data = conn->kex_params.kem_params.public_key.data;
180 : 0 : kem_data->raw_public_key.size = conn->kex_params.kem_params.public_key.size;
181 : :
182 : 0 : data_to_verify->size = sizeof(kem_extension_size) + sizeof(kem_public_key_size) + kem_data->raw_public_key.size;
183 : :
184 : 0 : return 0;
185 : 0 : }
186 : :
187 : : int s2n_kem_server_key_recv_parse_data(struct s2n_connection *conn, struct s2n_kex_raw_server_data *raw_server_data)
188 : 0 : {
189 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(conn);
190 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(conn->secure);
191 : :
192 : 0 : struct s2n_kem_raw_server_params *kem_data = &raw_server_data->kem_data;
193 : :
194 : : /* Check that the server's requested kem is supported by the client */
195 : 0 : const struct s2n_kem_preferences *kem_preferences = NULL;
196 [ # # ]: 0 : POSIX_GUARD(s2n_connection_get_kem_preferences(conn, &kem_preferences));
197 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(kem_preferences);
198 : :
199 : 0 : const struct s2n_cipher_suite *cipher_suite = conn->secure->cipher_suite;
200 : 0 : const struct s2n_kem *match = NULL;
201 [ # # ][ # # ]: 0 : S2N_ERROR_IF(s2n_choose_kem_with_peer_pref_list(cipher_suite->iana_value, &kem_data->kem_name,
202 : 0 : kem_preferences->kems, kem_preferences->kem_count, &match)
203 : 0 : != 0,
204 : 0 : S2N_ERR_KEM_UNSUPPORTED_PARAMS);
205 : 0 : conn->kex_params.kem_params.kem = match;
206 : :
207 [ # # ][ # # ]: 0 : S2N_ERROR_IF(kem_data->raw_public_key.size != conn->kex_params.kem_params.kem->public_key_length,
208 : 0 : S2N_ERR_BAD_MESSAGE);
209 : :
210 : 0 : return 0;
211 : 0 : }
212 : :
213 : : int s2n_hybrid_server_key_recv_read_data(struct s2n_connection *conn, struct s2n_blob *total_data_to_verify,
214 : : struct s2n_kex_raw_server_data *raw_server_data)
215 : 0 : {
216 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(conn);
217 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(conn->secure);
218 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(conn->secure->cipher_suite);
219 : 0 : const struct s2n_kex *kex = conn->secure->cipher_suite->key_exchange_alg;
220 : 0 : const struct s2n_kex *hybrid_kex_0 = kex->hybrid[0];
221 : 0 : const struct s2n_kex *hybrid_kex_1 = kex->hybrid[1];
222 : :
223 : : /* Keep a copy to the start of the whole structure for the signature check */
224 : 0 : total_data_to_verify->data = s2n_stuffer_raw_read(&conn->handshake.io, 0);
225 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(total_data_to_verify->data);
226 : :
227 : 0 : struct s2n_blob data_to_verify_0 = { 0 };
228 [ # # ]: 0 : POSIX_GUARD_RESULT(s2n_kex_server_key_recv_read_data(hybrid_kex_0, conn, &data_to_verify_0, raw_server_data));
229 : :
230 : 0 : struct s2n_blob data_to_verify_1 = { 0 };
231 [ # # ]: 0 : POSIX_GUARD_RESULT(s2n_kex_server_key_recv_read_data(hybrid_kex_1, conn, &data_to_verify_1, raw_server_data));
232 : :
233 [ # # ]: 0 : POSIX_GUARD(s2n_add_overflow(data_to_verify_0.size, data_to_verify_1.size, &total_data_to_verify->size));
234 : 0 : return 0;
235 : 0 : }
236 : :
237 : : int s2n_hybrid_server_key_recv_parse_data(struct s2n_connection *conn, struct s2n_kex_raw_server_data *raw_server_data)
238 : 0 : {
239 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(conn);
240 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(conn->secure);
241 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(conn->secure->cipher_suite);
242 : 0 : const struct s2n_kex *kex = conn->secure->cipher_suite->key_exchange_alg;
243 : 0 : const struct s2n_kex *hybrid_kex_0 = kex->hybrid[0];
244 : 0 : const struct s2n_kex *hybrid_kex_1 = kex->hybrid[1];
245 : :
246 [ # # ]: 0 : POSIX_GUARD_RESULT(s2n_kex_server_key_recv_parse_data(hybrid_kex_0, conn, raw_server_data));
247 [ # # ]: 0 : POSIX_GUARD_RESULT(s2n_kex_server_key_recv_parse_data(hybrid_kex_1, conn, raw_server_data));
248 : 0 : return 0;
249 : 0 : }
250 : :
251 : : int s2n_server_key_send(struct s2n_connection *conn)
252 : 971 : {
253 [ - + ][ # # ]: 971 : POSIX_ENSURE_REF(conn);
254 [ - + ][ # # ]: 971 : POSIX_ENSURE_REF(conn->handshake.hashes);
255 : :
256 [ + + ][ + + ]: 971 : S2N_ASYNC_PKEY_GUARD(conn);
[ + + ][ - + ]
[ - + ][ + - ]
257 : :
258 : 888 : struct s2n_hash_state *signature_hash = &conn->handshake.hashes->hash_workspace;
259 : 888 : const struct s2n_kex *key_exchange = conn->secure->cipher_suite->key_exchange_alg;
260 : 888 : const struct s2n_signature_scheme *sig_scheme = conn->handshake_params.server_cert_sig_scheme;
261 [ - + ][ # # ]: 888 : POSIX_ENSURE_REF(sig_scheme);
262 : 888 : struct s2n_stuffer *out = &conn->handshake.io;
263 : 888 : struct s2n_blob data_to_sign = { 0 };
264 : :
265 : : /* Call the negotiated key exchange method to send it's data */
266 [ - + ]: 888 : POSIX_GUARD_RESULT(s2n_kex_server_key_send(key_exchange, conn, &data_to_sign));
267 : :
268 : : /* Add common signature data */
269 [ + + ]: 888 : if (conn->actual_protocol_version == S2N_TLS12) {
270 [ - + ]: 716 : POSIX_GUARD(s2n_stuffer_write_uint16(out, sig_scheme->iana_value));
271 : 716 : }
272 : :
273 : : /* Add the random data to the hash */
274 [ - + ]: 888 : POSIX_GUARD(s2n_hash_init(signature_hash, sig_scheme->hash_alg));
275 [ - + ]: 888 : POSIX_GUARD(s2n_hash_update(signature_hash, conn->client_hello.random, S2N_TLS_RANDOM_DATA_LEN));
276 [ - + ]: 888 : POSIX_GUARD(s2n_hash_update(signature_hash, conn->handshake_params.server_random, S2N_TLS_RANDOM_DATA_LEN));
277 : :
278 : : /* Add KEX specific data to the hash */
279 [ - + ]: 888 : POSIX_GUARD(s2n_hash_update(signature_hash, data_to_sign.data, data_to_sign.size));
280 : :
281 [ + + ]: 888 : S2N_ASYNC_PKEY_SIGN(conn, sig_scheme->sig_alg, signature_hash,
282 : 0 : s2n_server_key_send_write_signature);
283 : 0 : }
284 : :
285 : : int s2n_ecdhe_server_key_send(struct s2n_connection *conn, struct s2n_blob *data_to_sign)
286 : 864 : {
287 : 864 : struct s2n_stuffer *out = &conn->handshake.io;
288 : :
289 : : /* Generate an ephemeral key and */
290 [ - + ]: 864 : POSIX_GUARD(s2n_ecc_evp_generate_ephemeral_key(&conn->kex_params.server_ecc_evp_params));
291 : :
292 : : /* Write it out and calculate the data to sign later */
293 [ - + ]: 864 : POSIX_GUARD(s2n_ecc_evp_write_params(&conn->kex_params.server_ecc_evp_params, out, data_to_sign));
294 : 864 : return 0;
295 : 864 : }
296 : :
297 : : int s2n_dhe_server_key_send(struct s2n_connection *conn, struct s2n_blob *data_to_sign)
298 : 24 : {
299 : 24 : struct s2n_stuffer *out = &conn->handshake.io;
300 : :
301 : : /* Duplicate the DH key from the config */
302 [ - + ]: 24 : POSIX_GUARD(s2n_dh_params_copy(&conn->config->dhparams, &conn->kex_params.server_dh_params));
303 : :
304 : : /* Generate an ephemeral key */
305 [ - + ]: 24 : POSIX_GUARD(s2n_dh_generate_ephemeral_key(&conn->kex_params.server_dh_params));
306 : :
307 : : /* Write it out and calculate the data to sign later */
308 [ - + ]: 24 : POSIX_GUARD(s2n_dh_params_to_p_g_Ys(&conn->kex_params.server_dh_params, out, data_to_sign));
309 : 24 : return 0;
310 : 24 : }
311 : :
312 : : int s2n_kem_server_key_send(struct s2n_connection *conn, struct s2n_blob *data_to_sign)
313 : 0 : {
314 : 0 : struct s2n_stuffer *out = &conn->handshake.io;
315 : 0 : const struct s2n_kem *kem = conn->kex_params.kem_params.kem;
316 : :
317 : 0 : data_to_sign->data = s2n_stuffer_raw_write(out, 0);
318 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(data_to_sign->data);
319 : :
320 [ # # ]: 0 : POSIX_GUARD(s2n_stuffer_write_uint16(out, kem->kem_extension_id));
321 [ # # ]: 0 : POSIX_GUARD(s2n_stuffer_write_uint16(out, conn->kex_params.kem_params.kem->public_key_length));
322 [ # # ]: 0 : POSIX_GUARD(s2n_kem_send_public_key(out, &(conn->kex_params.kem_params)));
323 : :
324 : 0 : data_to_sign->size = sizeof(kem_extension_size) + sizeof(kem_public_key_size) + kem->public_key_length;
325 : :
326 : 0 : return 0;
327 : 0 : }
328 : :
329 : : int s2n_hybrid_server_key_send(struct s2n_connection *conn, struct s2n_blob *total_data_to_sign)
330 : 0 : {
331 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(conn);
332 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(conn->secure);
333 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(conn->secure->cipher_suite);
334 : 0 : const struct s2n_kex *kex = conn->secure->cipher_suite->key_exchange_alg;
335 : 0 : const struct s2n_kex *hybrid_kex_0 = kex->hybrid[0];
336 : 0 : const struct s2n_kex *hybrid_kex_1 = kex->hybrid[1];
337 : :
338 : : /* Keep a copy to the start of the whole structure for the signature check */
339 : 0 : total_data_to_sign->data = s2n_stuffer_raw_write(&conn->handshake.io, 0);
340 [ # # ][ # # ]: 0 : POSIX_ENSURE_REF(total_data_to_sign->data);
341 : :
342 : 0 : struct s2n_blob data_to_verify_0 = { 0 };
343 [ # # ]: 0 : POSIX_GUARD_RESULT(s2n_kex_server_key_send(hybrid_kex_0, conn, &data_to_verify_0));
344 : :
345 : 0 : struct s2n_blob data_to_verify_1 = { 0 };
346 [ # # ]: 0 : POSIX_GUARD_RESULT(s2n_kex_server_key_send(hybrid_kex_1, conn, &data_to_verify_1));
347 : :
348 [ # # ]: 0 : POSIX_GUARD(s2n_add_overflow(data_to_verify_0.size, data_to_verify_1.size, &total_data_to_sign->size));
349 : 0 : return 0;
350 : 0 : }
351 : :
352 : : int s2n_server_key_send_write_signature(struct s2n_connection *conn, struct s2n_blob *signature)
353 : 886 : {
354 : 886 : struct s2n_stuffer *out = &conn->handshake.io;
355 : :
356 [ - + ]: 886 : POSIX_GUARD(s2n_stuffer_write_uint16(out, signature->size));
357 [ - + ]: 886 : POSIX_GUARD(s2n_stuffer_write_bytes(out, signature->data, signature->size));
358 : :
359 : 886 : return 0;
360 : 886 : }
|
