quictestlib.c@ 108358

最後變更在這個檔案從108358是 108206,由 vboxsync 提交於 5 週前
openssl-3.3.2: Exported all files to OSE and removed .scm-settings bugref:10757
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 36.2 KB

行
1	/*
2	* Copyright 2022-2024 The OpenSSL Project Authors. All Rights Reserved.
3	*
4	* Licensed under the Apache License 2.0 (the "License"). You may not use
5	* this file except in compliance with the License. You can obtain a copy
6	* in the file LICENSE in the source distribution or at
7	* https://www.openssl.org/source/license.html
8	*/
9
10	#include <assert.h>
11	#include <openssl/configuration.h>
12	#include <openssl/bio.h>
13	#include "internal/e_os.h" /* For struct timeval */
14	#include "quictestlib.h"
15	#include "ssltestlib.h"
16	#include "../testutil.h"
17	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
18	# include "../threadstest.h"
19	#endif
20	#include "internal/quic_ssl.h"
21	#include "internal/quic_wire_pkt.h"
22	#include "internal/quic_record_tx.h"
23	#include "internal/quic_error.h"
24	#include "internal/packet.h"
25	#include "internal/tsan_assist.h"
26
27	#define GROWTH_ALLOWANCE 1024
28
29	struct noise_args_data_st {
30	BIO *cbio;
31	BIO *sbio;
32	BIO *tracebio;
33	int flags;
34	};
35
36	struct qtest_fault {
37	QUIC_TSERVER *qtserv;
38
39	/* Plain packet mutations */
40	/* Header for the plaintext packet */
41	QUIC_PKT_HDR pplainhdr;
42	/* iovec for the plaintext packet data buffer */
43	OSSL_QTX_IOVEC pplainio;
44	/* Allocated size of the plaintext packet data buffer */
45	size_t pplainbuf_alloc;
46	qtest_fault_on_packet_plain_cb pplaincb;
47	void *pplaincbarg;
48
49	/* Handshake message mutations */
50	/* Handshake message buffer */
51	unsigned char *handbuf;
52	/* Allocated size of the handshake message buffer */
53	size_t handbufalloc;
54	/* Actual length of the handshake message */
55	size_t handbuflen;
56	qtest_fault_on_handshake_cb handshakecb;
57	void *handshakecbarg;
58	qtest_fault_on_enc_ext_cb encextcb;
59	void *encextcbarg;
60
61	/* Cipher packet mutations */
62	qtest_fault_on_packet_cipher_cb pciphercb;
63	void *pciphercbarg;
64
65	/* Datagram mutations */
66	qtest_fault_on_datagram_cb datagramcb;
67	void *datagramcbarg;
68	/* The currently processed message */
69	BIO_MSG msg;
70	/* Allocated size of msg data buffer */
71	size_t msgalloc;
72	struct noise_args_data_st noiseargs;
73	};
74
75	static void packet_plain_finish(void *arg);
76	static void handshake_finish(void *arg);
77	static OSSL_TIME qtest_get_time(void);
78	static void qtest_reset_time(void);
79
80	static int using_fake_time = 0;
81	static OSSL_TIME fake_now;
82	static CRYPTO_RWLOCK *fake_now_lock = NULL;
83	static OSSL_TIME start_time;
84
85	static OSSL_TIME fake_now_cb(void *arg)
86	{
87	return qtest_get_time();
88	}
89
90	static void noise_msg_callback(int write_p, int version, int content_type,
91	const void buf, size_t len, SSL ssl,
92	void *arg)
93	{
94	struct noise_args_data_st noiseargs = (struct noise_args_data_st )arg;
95
96	if (content_type == SSL3_RT_QUIC_FRAME_FULL) {
97	PACKET pkt;
98	uint64_t frame_type;
99
100	if (!PACKET_buf_init(&pkt, buf, len))
101	return;
102
103	if (!ossl_quic_wire_peek_frame_header(&pkt, &frame_type, NULL))
104	return;
105
106	if (frame_type == OSSL_QUIC_FRAME_TYPE_PING) {
107	/*
108	* If either endpoint issues a ping frame then we are in danger
109	* of our noise being too much such that the connection itself
110	* fails. We back off on the noise for a bit to avoid that.
111	*/
112	(void)BIO_ctrl(noiseargs->cbio, BIO_CTRL_NOISE_BACK_OFF, 0, NULL);
113	(void)BIO_ctrl(noiseargs->sbio, BIO_CTRL_NOISE_BACK_OFF, 0, NULL);
114	}
115	}
116
117	#ifndef OPENSSL_NO_SSL_TRACE
118	if ((noiseargs->flags & QTEST_FLAG_CLIENT_TRACE) != 0
119	&& !SSL_is_server(ssl))
120	SSL_trace(write_p, version, content_type, buf, len, ssl,
121	noiseargs->tracebio);
122	#endif
123	}
124
125	int qtest_create_quic_objects(OSSL_LIB_CTX libctx, SSL_CTX clientctx,
126	SSL_CTX serverctx, char certfile, char *keyfile,
127	int flags, QUIC_TSERVER qtserv, SSL cssl,
128	QTEST_FAULT fault, BIO tracebio)
129	{
130	/* ALPN value as recognised by QUIC_TSERVER */
131	unsigned char alpn[] = { 8, 'o', 's', 's', 'l', 't', 'e', 's', 't' };
132	QUIC_TSERVER_ARGS tserver_args = {0};
133	BIO cbio = NULL, sbio = NULL, *fisbio = NULL;
134	BIO_ADDR *peeraddr = NULL;
135	struct in_addr ina = {0};
136	BIO *tmpbio = NULL;
137
138	*qtserv = NULL;
139	if (*cssl == NULL) {
140	*cssl = SSL_new(clientctx);
141	if (!TEST_ptr(*cssl))
142	return 0;
143	}
144
145	if (fault != NULL) {
146	fault = OPENSSL_zalloc(sizeof(*fault));
147	if (*fault == NULL)
148	goto err;
149	}
150
151	#ifndef OPENSSL_NO_SSL_TRACE
152	if ((flags & QTEST_FLAG_CLIENT_TRACE) != 0) {
153	tmpbio = BIO_new_fp(stdout, BIO_NOCLOSE);
154	if (!TEST_ptr(tmpbio))
155	goto err;
156
157	SSL_set_msg_callback(*cssl, SSL_trace);
158	SSL_set_msg_callback_arg(*cssl, tmpbio);
159	}
160	#endif
161	if (tracebio != NULL)
162	*tracebio = tmpbio;
163
164	/* SSL_set_alpn_protos returns 0 for success! */
165	if (!TEST_false(SSL_set_alpn_protos(*cssl, alpn, sizeof(alpn))))
166	goto err;
167
168	if (!TEST_ptr(peeraddr = BIO_ADDR_new()))
169	goto err;
170
171	if ((flags & QTEST_FLAG_BLOCK) != 0) {
172	#if !defined(OPENSSL_NO_POSIX_IO)
173	int cfd, sfd;
174
175	/*
176	* For blocking mode we need to create actual sockets rather than doing
177	* everything in memory
178	*/
179	if (!TEST_true(create_test_sockets(&cfd, &sfd, SOCK_DGRAM, peeraddr)))
180	goto err;
181	cbio = BIO_new_dgram(cfd, 1);
182	if (!TEST_ptr(cbio)) {
183	close(cfd);
184	close(sfd);
185	goto err;
186	}
187	sbio = BIO_new_dgram(sfd, 1);
188	if (!TEST_ptr(sbio)) {
189	close(sfd);
190	goto err;
191	}
192	#else
193	goto err;
194	#endif
195	} else {
196	if (!TEST_true(BIO_new_bio_dgram_pair(&cbio, 0, &sbio, 0)))
197	goto err;
198
199	if (!TEST_true(BIO_dgram_set_caps(cbio, BIO_DGRAM_CAP_HANDLES_DST_ADDR))
200	\|\| !TEST_true(BIO_dgram_set_caps(sbio, BIO_DGRAM_CAP_HANDLES_DST_ADDR)))
201	goto err;
202
203	/* Dummy server address */
204	if (!TEST_true(BIO_ADDR_rawmake(peeraddr, AF_INET, &ina, sizeof(ina),
205	htons(0))))
206	goto err;
207	}
208
209	if ((flags & QTEST_FLAG_PACKET_SPLIT) != 0) {
210	BIO *pktsplitbio = BIO_new(bio_f_pkt_split_dgram_filter());
211
212	if (!TEST_ptr(pktsplitbio))
213	goto err;
214	cbio = BIO_push(pktsplitbio, cbio);
215
216	pktsplitbio = BIO_new(bio_f_pkt_split_dgram_filter());
217	if (!TEST_ptr(pktsplitbio))
218	goto err;
219	sbio = BIO_push(pktsplitbio, sbio);
220	}
221
222	if ((flags & QTEST_FLAG_NOISE) != 0) {
223	BIO *noisebio;
224	struct bio_noise_now_cb_st now_cb = { fake_now_cb, NULL };
225
226	/*
227	* It is an error to not have a QTEST_FAULT object when introducing noise
228	*/
229	if (!TEST_ptr(fault))
230	goto err;
231
232	noisebio = BIO_new(bio_f_noisy_dgram_filter());
233
234	if (!TEST_ptr(noisebio))
235	goto err;
236	cbio = BIO_push(noisebio, cbio);
237	if ((flags & QTEST_FLAG_FAKE_TIME) != 0) {
238	if (!TEST_int_eq(BIO_ctrl(cbio, BIO_CTRL_NOISE_SET_NOW_CB,
239	0, &now_cb), 1))
240	goto err;
241	}
242
243	noisebio = BIO_new(bio_f_noisy_dgram_filter());
244
245	if (!TEST_ptr(noisebio))
246	goto err;
247	sbio = BIO_push(noisebio, sbio);
248	if ((flags & QTEST_FLAG_FAKE_TIME) != 0) {
249	if (!TEST_int_eq(BIO_ctrl(sbio, BIO_CTRL_NOISE_SET_NOW_CB,
250	0, &now_cb), 1))
251	goto err;
252	}
253	/*
254	* TODO(QUIC SERVER):
255	* Currently the simplistic handler of the quic tserver cannot cope
256	* with noise introduced in the first packet received from the
257	* client. This needs to be removed once we have proper server side
258	* handling.
259	*/
260	(void)BIO_ctrl(sbio, BIO_CTRL_NOISE_BACK_OFF, 0, NULL);
261
262	(*fault)->noiseargs.cbio = cbio;
263	(*fault)->noiseargs.sbio = sbio;
264	(*fault)->noiseargs.tracebio = tmpbio;
265	(*fault)->noiseargs.flags = flags;
266
267	SSL_set_msg_callback(*cssl, noise_msg_callback);
268	SSL_set_msg_callback_arg(cssl, &(fault)->noiseargs);
269	}
270
271	SSL_set_bio(*cssl, cbio, cbio);
272
273	if (!TEST_true(SSL_set_blocking_mode(*cssl,
274	(flags & QTEST_FLAG_BLOCK) != 0 ? 1 : 0)))
275	goto err;
276
277	if (!TEST_true(SSL_set1_initial_peer_addr(*cssl, peeraddr)))
278	goto err;
279
280	fisbio = BIO_new(qtest_get_bio_method());
281	if (!TEST_ptr(fisbio))
282	goto err;
283
284	BIO_set_data(fisbio, fault == NULL ? NULL : *fault);
285
286	if (!BIO_up_ref(sbio))
287	goto err;
288	if (!TEST_ptr(BIO_push(fisbio, sbio))) {
289	BIO_free(sbio);
290	goto err;
291	}
292
293	tserver_args.libctx = libctx;
294	tserver_args.net_rbio = sbio;
295	tserver_args.net_wbio = fisbio;
296	tserver_args.alpn = NULL;
297	if (serverctx != NULL && !TEST_true(SSL_CTX_up_ref(serverctx)))
298	goto err;
299	tserver_args.ctx = serverctx;
300	if (fake_now_lock == NULL) {
301	fake_now_lock = CRYPTO_THREAD_lock_new();
302	if (fake_now_lock == NULL)
303	goto err;
304	}
305	if ((flags & QTEST_FLAG_FAKE_TIME) != 0) {
306	using_fake_time = 1;
307	qtest_reset_time();
308	tserver_args.now_cb = fake_now_cb;
309	(void)ossl_quic_conn_set_override_now_cb(*cssl, fake_now_cb, NULL);
310	} else {
311	using_fake_time = 0;
312	}
313
314	if (!TEST_ptr(*qtserv = ossl_quic_tserver_new(&tserver_args, certfile,
315	keyfile)))
316	goto err;
317
318	/* Ownership of fisbio and sbio is now held by qtserv /
319	sbio = NULL;
320	fisbio = NULL;
321
322	if ((flags & QTEST_FLAG_NOISE) != 0)
323	ossl_quic_tserver_set_msg_callback(*qtserv, noise_msg_callback,
324	&(*fault)->noiseargs);
325
326	if (fault != NULL)
327	(fault)->qtserv = qtserv;
328
329	BIO_ADDR_free(peeraddr);
330
331	return 1;
332	err:
333	SSL_CTX_free(tserver_args.ctx);
334	BIO_ADDR_free(peeraddr);
335	BIO_free_all(cbio);
336	BIO_free_all(fisbio);
337	BIO_free_all(sbio);
338	SSL_free(*cssl);
339	*cssl = NULL;
340	ossl_quic_tserver_free(*qtserv);
341	if (fault != NULL)
342	OPENSSL_free(*fault);
343	BIO_free(tmpbio);
344	if (tracebio != NULL)
345	*tracebio = NULL;
346
347	return 0;
348	}
349
350	void qtest_add_time(uint64_t millis)
351	{
352	if (!CRYPTO_THREAD_write_lock(fake_now_lock))
353	return;
354	fake_now = ossl_time_add(fake_now, ossl_ms2time(millis));
355	CRYPTO_THREAD_unlock(fake_now_lock);
356	}
357
358	static OSSL_TIME qtest_get_time(void)
359	{
360	OSSL_TIME ret;
361
362	if (!CRYPTO_THREAD_read_lock(fake_now_lock))
363	return ossl_time_zero();
364	ret = fake_now;
365	CRYPTO_THREAD_unlock(fake_now_lock);
366	return ret;
367	}
368
369	static void qtest_reset_time(void)
370	{
371	if (!CRYPTO_THREAD_write_lock(fake_now_lock))
372	return;
373	fake_now = ossl_time_zero();
374	CRYPTO_THREAD_unlock(fake_now_lock);
375	/* zero time can have a special meaning, bump it */
376	qtest_add_time(1);
377	}
378
379	void qtest_start_stopwatch(void)
380	{
381	start_time = qtest_get_time();
382	}
383
384	uint64_t qtest_get_stopwatch_time(void)
385	{
386	return ossl_time2ms(ossl_time_subtract(qtest_get_time(), start_time));
387	}
388
389	QTEST_FAULT qtest_create_injector(QUIC_TSERVER ts)
390	{
391	QTEST_FAULT *f;
392
393	f = OPENSSL_zalloc(sizeof(*f));
394	if (f == NULL)
395	return NULL;
396
397	f->qtserv = ts;
398	return f;
399
400	}
401
402	int qtest_supports_blocking(void)
403	{
404	#if !defined(OPENSSL_NO_POSIX_IO) && defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
405	return 1;
406	#else
407	return 0;
408	#endif
409	}
410
411	#define MAXLOOPS 1000
412
413	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
414	static int globserverret = 0;
415	static TSAN_QUALIFIER int abortserverthread = 0;
416	static QUIC_TSERVER *globtserv;
417	static const thread_t thread_zero;
418
419	static void run_server_thread(void)
420	{
421	/*
422	* This will operate in a busy loop because the server does not block,
423	* but should be acceptable because it is local and we expect this to be
424	* fast
425	*/
426	globserverret = qtest_create_quic_connection(globtserv, NULL);
427	}
428	#endif
429
430	int qtest_wait_for_timeout(SSL s, QUIC_TSERVER qtserv)
431	{
432	struct timeval tv;
433	OSSL_TIME ctimeout, stimeout, mintimeout, now;
434	int cinf;
435
436	/* We don't need to wait in blocking mode */
437	if (s == NULL \|\| SSL_get_blocking_mode(s))
438	return 1;
439
440	/* Don't wait if either BIO has data waiting */
441	if (BIO_pending(SSL_get_rbio(s)) > 0
442	\|\| BIO_pending(ossl_quic_tserver_get0_rbio(qtserv)) > 0)
443	return 1;
444
445	/*
446	* Neither endpoint has data waiting to be read. We assume data transmission
447	* is instantaneous due to using mem based BIOs, so there is no data "in
448	* flight" and no more data will be sent by either endpoint until some time
449	* based event has occurred. Therefore, wait for a timeout to occur. This
450	* might happen if we are using the noisy BIO and datagrams have been lost.
451	*/
452	if (!SSL_get_event_timeout(s, &tv, &cinf))
453	return 0;
454
455	if (using_fake_time)
456	now = qtest_get_time();
457	else
458	now = ossl_time_now();
459
460	ctimeout = cinf ? ossl_time_infinite() : ossl_time_from_timeval(tv);
461	stimeout = ossl_time_subtract(ossl_quic_tserver_get_deadline(qtserv), now);
462	mintimeout = ossl_time_min(ctimeout, stimeout);
463	if (ossl_time_is_infinite(mintimeout))
464	return 0;
465
466	if (using_fake_time)
467	qtest_add_time(ossl_time2ms(mintimeout));
468	else
469	OSSL_sleep(ossl_time2ms(mintimeout));
470
471	return 1;
472	}
473
474	int qtest_create_quic_connection_ex(QUIC_TSERVER qtserv, SSL clientssl,
475	int wanterr)
476	{
477	int retc = -1, rets = 0, abortctr = 0, ret = 0;
478	int clienterr = 0, servererr = 0;
479	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
480	/*
481	* Pointless initialisation to avoid bogus compiler warnings about using
482	* t uninitialised
483	*/
484	thread_t t = thread_zero;
485
486	if (clientssl != NULL)
487	abortserverthread = 0;
488	#endif
489
490	if (!TEST_ptr(qtserv)) {
491	goto err;
492	} else if (clientssl == NULL) {
493	retc = 1;
494	} else if (SSL_get_blocking_mode(clientssl) > 0) {
495	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
496	/*
497	* clientssl is blocking. We will need a thread to complete the
498	* connection
499	*/
500	globtserv = qtserv;
501	if (!TEST_true(run_thread(&t, run_server_thread)))
502	goto err;
503
504	qtserv = NULL;
505	rets = 1;
506	#else
507	TEST_error("No thread support in this build");
508	goto err;
509	#endif
510	}
511
512	do {
513	if (!clienterr && retc <= 0) {
514	int err;
515
516	retc = SSL_connect(clientssl);
517	if (retc <= 0) {
518	err = SSL_get_error(clientssl, retc);
519
520	if (err == wanterr) {
521	retc = 1;
522	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
523	if (qtserv == NULL && rets > 0)
524	tsan_store(&abortserverthread, 1);
525	else
526	#endif
527	rets = 1;
528	} else {
529	if (err != SSL_ERROR_WANT_READ
530	&& err != SSL_ERROR_WANT_WRITE) {
531	TEST_info("SSL_connect() failed %d, %d", retc, err);
532	TEST_openssl_errors();
533	clienterr = 1;
534	}
535	}
536	}
537	}
538
539	qtest_add_time(1);
540	if (clientssl != NULL)
541	SSL_handle_events(clientssl);
542	if (qtserv != NULL)
543	ossl_quic_tserver_tick(qtserv);
544
545	if (!servererr && rets <= 0) {
546	servererr = ossl_quic_tserver_is_term_any(qtserv);
547	if (!servererr)
548	rets = ossl_quic_tserver_is_handshake_confirmed(qtserv);
549	}
550
551	if (clienterr && servererr)
552	goto err;
553
554	if (clientssl != NULL && ++abortctr == MAXLOOPS) {
555	TEST_info("No progress made");
556	goto err;
557	}
558
559	if ((retc <= 0 && !clienterr) \|\| (rets <= 0 && !servererr)) {
560	if (!qtest_wait_for_timeout(clientssl, qtserv))
561	goto err;
562	}
563	} while ((retc <= 0 && !clienterr)
564	\|\| (rets <= 0 && !servererr
565	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
566	&& !tsan_load(&abortserverthread)
567	#endif
568	));
569
570	if (qtserv == NULL && rets > 0) {
571	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
572	if (!TEST_true(wait_for_thread(t)) \|\| !TEST_true(globserverret))
573	goto err;
574	#else
575	TEST_error("Should not happen");
576	goto err;
577	#endif
578	}
579
580	if (!clienterr && !servererr)
581	ret = 1;
582	err:
583	return ret;
584	}
585
586	int qtest_create_quic_connection(QUIC_TSERVER qtserv, SSL clientssl)
587	{
588	return qtest_create_quic_connection_ex(qtserv, clientssl, SSL_ERROR_NONE);
589	}
590
591	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
592	static TSAN_QUALIFIER int shutdowndone;
593
594	static void run_server_shutdown_thread(void)
595	{
596	/*
597	* This will operate in a busy loop because the server does not block,
598	* but should be acceptable because it is local and we expect this to be
599	* fast
600	*/
601	do {
602	ossl_quic_tserver_tick(globtserv);
603	} while(!tsan_load(&shutdowndone));
604	}
605	#endif
606
607	int qtest_shutdown(QUIC_TSERVER qtserv, SSL clientssl)
608	{
609	int tickserver = 1;
610	int ret = 0;
611	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
612	/*
613	* Pointless initialisation to avoid bogus compiler warnings about using
614	* t uninitialised
615	*/
616	thread_t t = thread_zero;
617	#endif
618
619	if (SSL_get_blocking_mode(clientssl) > 0) {
620	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
621	/*
622	* clientssl is blocking. We will need a thread to complete the
623	* connection
624	*/
625	globtserv = qtserv;
626	shutdowndone = 0;
627	if (!TEST_true(run_thread(&t, run_server_shutdown_thread)))
628	return 0;
629
630	tickserver = 0;
631	#else
632	TEST_error("No thread support in this build");
633	return 0;
634	#endif
635	}
636
637	/* Busy loop in non-blocking mode. It should be quick because its local */
638	for (;;) {
639	int rc = SSL_shutdown(clientssl);
640
641	if (rc == 1) {
642	ret = 1;
643	break;
644	}
645
646	if (rc < 0)
647	break;
648
649	if (tickserver)
650	ossl_quic_tserver_tick(qtserv);
651	}
652
653	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
654	tsan_store(&shutdowndone, 1);
655	if (!tickserver) {
656	if (!TEST_true(wait_for_thread(t)))
657	ret = 0;
658	}
659	#endif
660
661	return ret;
662	}
663
664	int qtest_check_server_transport_err(QUIC_TSERVER *qtserv, uint64_t code)
665	{
666	const QUIC_TERMINATE_CAUSE *cause;
667
668	ossl_quic_tserver_tick(qtserv);
669
670	/*
671	* Check that the server has closed with the specified code from the client
672	*/
673	if (!TEST_true(ossl_quic_tserver_is_term_any(qtserv)))
674	return 0;
675
676	cause = ossl_quic_tserver_get_terminate_cause(qtserv);
677	if (!TEST_ptr(cause)
678	\|\| !TEST_true(cause->remote)
679	\|\| !TEST_false(cause->app)
680	\|\| !TEST_uint64_t_eq(cause->error_code, code))
681	return 0;
682
683	return 1;
684	}
685
686	int qtest_check_server_protocol_err(QUIC_TSERVER *qtserv)
687	{
688	return qtest_check_server_transport_err(qtserv, OSSL_QUIC_ERR_PROTOCOL_VIOLATION);
689	}
690
691	int qtest_check_server_frame_encoding_err(QUIC_TSERVER *qtserv)
692	{
693	return qtest_check_server_transport_err(qtserv, OSSL_QUIC_ERR_FRAME_ENCODING_ERROR);
694	}
695
696	void qtest_fault_free(QTEST_FAULT *fault)
697	{
698	if (fault == NULL)
699	return;
700
701	packet_plain_finish(fault);
702	handshake_finish(fault);
703
704	OPENSSL_free(fault);
705	}
706
707	static int packet_plain_mutate(const QUIC_PKT_HDR *hdrin,
708	const OSSL_QTX_IOVEC *iovecin, size_t numin,
709	QUIC_PKT_HDR **hdrout,
710	const OSSL_QTX_IOVEC **iovecout,
711	size_t *numout,
712	void *arg)
713	{
714	QTEST_FAULT *fault = arg;
715	size_t i, bufsz = 0;
716	unsigned char *cur;
717
718	/* Coalesce our data into a single buffer */
719
720	/* First calculate required buffer size */
721	for (i = 0; i < numin; i++)
722	bufsz += iovecin[i].buf_len;
723
724	fault->pplainio.buf_len = bufsz;
725
726	/* Add an allowance for possible growth */
727	bufsz += GROWTH_ALLOWANCE;
728
729	fault->pplainio.buf = cur = OPENSSL_malloc(bufsz);
730	if (cur == NULL) {
731	fault->pplainio.buf_len = 0;
732	return 0;
733	}
734
735	fault->pplainbuf_alloc = bufsz;
736
737	/* Copy in the data from the input buffers */
738	for (i = 0; i < numin; i++) {
739	memcpy(cur, iovecin[i].buf, iovecin[i].buf_len);
740	cur += iovecin[i].buf_len;
741	}
742
743	fault->pplainhdr = *hdrin;
744
745	/* Cast below is safe because we allocated the buffer */
746	if (fault->pplaincb != NULL
747	&& !fault->pplaincb(fault, &fault->pplainhdr,
748	(unsigned char *)fault->pplainio.buf,
749	fault->pplainio.buf_len, fault->pplaincbarg))
750	return 0;
751
752	*hdrout = &fault->pplainhdr;
753	*iovecout = &fault->pplainio;
754	*numout = 1;
755
756	return 1;
757	}
758
759	static void packet_plain_finish(void *arg)
760	{
761	QTEST_FAULT *fault = arg;
762
763	/* Cast below is safe because we allocated the buffer */
764	OPENSSL_free((unsigned char *)fault->pplainio.buf);
765	fault->pplainio.buf_len = 0;
766	fault->pplainbuf_alloc = 0;
767	fault->pplainio.buf = NULL;
768	}
769
770	int qtest_fault_set_packet_plain_listener(QTEST_FAULT *fault,
771	qtest_fault_on_packet_plain_cb pplaincb,
772	void *pplaincbarg)
773	{
774	fault->pplaincb = pplaincb;
775	fault->pplaincbarg = pplaincbarg;
776
777	return ossl_quic_tserver_set_plain_packet_mutator(fault->qtserv,
778	packet_plain_mutate,
779	packet_plain_finish,
780	fault);
781	}
782
783	/* To be called from a packet_plain_listener callback */
784	int qtest_fault_resize_plain_packet(QTEST_FAULT *fault, size_t newlen)
785	{
786	unsigned char *buf;
787	size_t oldlen = fault->pplainio.buf_len;
788
789	/*
790	* Alloc'd size should always be non-zero, so if this fails we've been
791	* incorrectly called
792	*/
793	if (fault->pplainbuf_alloc == 0)
794	return 0;
795
796	if (newlen > fault->pplainbuf_alloc) {
797	/* This exceeds our growth allowance. Fail */
798	return 0;
799	}
800
801	/* Cast below is safe because we allocated the buffer */
802	buf = (unsigned char *)fault->pplainio.buf;
803
804	if (newlen > oldlen) {
805	/* Extend packet with 0 bytes */
806	memset(buf + oldlen, 0, newlen - oldlen);
807	} /* else we're truncating or staying the same */
808
809	fault->pplainio.buf_len = newlen;
810	fault->pplainhdr.len = newlen;
811
812	return 1;
813	}
814
815	/*
816	* Prepend frame data into a packet. To be called from a packet_plain_listener
817	* callback
818	*/
819	int qtest_fault_prepend_frame(QTEST_FAULT fault, const unsigned char frame,
820	size_t frame_len)
821	{
822	unsigned char *buf;
823	size_t old_len;
824
825	/*
826	* Alloc'd size should always be non-zero, so if this fails we've been
827	* incorrectly called
828	*/
829	if (fault->pplainbuf_alloc == 0)
830	return 0;
831
832	/* Cast below is safe because we allocated the buffer */
833	buf = (unsigned char *)fault->pplainio.buf;
834	old_len = fault->pplainio.buf_len;
835
836	/* Extend the size of the packet by the size of the new frame */
837	if (!TEST_true(qtest_fault_resize_plain_packet(fault,
838	old_len + frame_len)))
839	return 0;
840
841	memmove(buf + frame_len, buf, old_len);
842	memcpy(buf, frame, frame_len);
843
844	return 1;
845	}
846
847	static int handshake_mutate(const unsigned char *msgin, size_t msginlen,
848	unsigned char *msgout, size_t msgoutlen,
849	void *arg)
850	{
851	QTEST_FAULT *fault = arg;
852	unsigned char *buf;
853	unsigned long payloadlen;
854	unsigned int msgtype;
855	PACKET pkt;
856
857	buf = OPENSSL_malloc(msginlen + GROWTH_ALLOWANCE);
858	if (buf == NULL)
859	return 0;
860
861	fault->handbuf = buf;
862	fault->handbuflen = msginlen;
863	fault->handbufalloc = msginlen + GROWTH_ALLOWANCE;
864	memcpy(buf, msgin, msginlen);
865
866	if (!PACKET_buf_init(&pkt, buf, msginlen)
867	\|\| !PACKET_get_1(&pkt, &msgtype)
868	\|\| !PACKET_get_net_3(&pkt, &payloadlen)
869	\|\| PACKET_remaining(&pkt) != payloadlen)
870	return 0;
871
872	/* Parse specific message types */
873	switch (msgtype) {
874	case SSL3_MT_ENCRYPTED_EXTENSIONS:
875	{
876	QTEST_ENCRYPTED_EXTENSIONS ee;
877
878	if (fault->encextcb == NULL)
879	break;
880
881	/*
882	* The EncryptedExtensions message is very simple. It just has an
883	* extensions block in it and nothing else.
884	*/
885	ee.extensions = (unsigned char *)PACKET_data(&pkt);
886	ee.extensionslen = payloadlen;
887	if (!fault->encextcb(fault, &ee, payloadlen, fault->encextcbarg))
888	return 0;
889	}
890
891	default:
892	/* No specific handlers for these message types yet */
893	break;
894	}
895
896	if (fault->handshakecb != NULL
897	&& !fault->handshakecb(fault, buf, fault->handbuflen,
898	fault->handshakecbarg))
899	return 0;
900
901	*msgout = buf;
902	*msgoutlen = fault->handbuflen;
903
904	return 1;
905	}
906
907	static void handshake_finish(void *arg)
908	{
909	QTEST_FAULT *fault = arg;
910
911	OPENSSL_free(fault->handbuf);
912	fault->handbuf = NULL;
913	}
914
915	int qtest_fault_set_handshake_listener(QTEST_FAULT *fault,
916	qtest_fault_on_handshake_cb handshakecb,
917	void *handshakecbarg)
918	{
919	fault->handshakecb = handshakecb;
920	fault->handshakecbarg = handshakecbarg;
921
922	return ossl_quic_tserver_set_handshake_mutator(fault->qtserv,
923	handshake_mutate,
924	handshake_finish,
925	fault);
926	}
927
928	int qtest_fault_set_hand_enc_ext_listener(QTEST_FAULT *fault,
929	qtest_fault_on_enc_ext_cb encextcb,
930	void *encextcbarg)
931	{
932	fault->encextcb = encextcb;
933	fault->encextcbarg = encextcbarg;
934
935	return ossl_quic_tserver_set_handshake_mutator(fault->qtserv,
936	handshake_mutate,
937	handshake_finish,
938	fault);
939	}
940
941	/* To be called from a handshake_listener callback */
942	int qtest_fault_resize_handshake(QTEST_FAULT *fault, size_t newlen)
943	{
944	unsigned char *buf;
945	size_t oldlen = fault->handbuflen;
946
947	/*
948	* Alloc'd size should always be non-zero, so if this fails we've been
949	* incorrectly called
950	*/
951	if (fault->handbufalloc == 0)
952	return 0;
953
954	if (newlen > fault->handbufalloc) {
955	/* This exceeds our growth allowance. Fail */
956	return 0;
957	}
958
959	buf = (unsigned char *)fault->handbuf;
960
961	if (newlen > oldlen) {
962	/* Extend packet with 0 bytes */
963	memset(buf + oldlen, 0, newlen - oldlen);
964	} /* else we're truncating or staying the same */
965
966	fault->handbuflen = newlen;
967	return 1;
968	}
969
970	/* To be called from message specific listener callbacks */
971	int qtest_fault_resize_message(QTEST_FAULT *fault, size_t newlen)
972	{
973	/* First resize the underlying message */
974	if (!qtest_fault_resize_handshake(fault, newlen + SSL3_HM_HEADER_LENGTH))
975	return 0;
976
977	/* Fixup the handshake message header */
978	fault->handbuf[1] = (unsigned char)((newlen >> 16) & 0xff);
979	fault->handbuf[2] = (unsigned char)((newlen >> 8) & 0xff);
980	fault->handbuf[3] = (unsigned char)((newlen ) & 0xff);
981
982	return 1;
983	}
984
985	int qtest_fault_delete_extension(QTEST_FAULT *fault,
986	unsigned int exttype, unsigned char *ext,
987	size_t *extlen,
988	BUF_MEM *old_ext)
989	{
990	PACKET pkt, sub, subext;
991	WPACKET old_ext_wpkt;
992	unsigned int type;
993	const unsigned char start, end;
994	size_t newlen, w;
995	size_t msglen = fault->handbuflen;
996
997	if (!PACKET_buf_init(&pkt, ext, *extlen))
998	return 0;
999
1000	/* Extension block starts with 2 bytes for extension block length */
1001	if (!PACKET_as_length_prefixed_2(&pkt, &sub))
1002	return 0;
1003
1004	do {
1005	start = PACKET_data(&sub);
1006	if (!PACKET_get_net_2(&sub, &type)
1007	\|\| !PACKET_get_length_prefixed_2(&sub, &subext))
1008	return 0;
1009	} while (type != exttype);
1010
1011	/* Found it */
1012	end = PACKET_data(&sub);
1013
1014	if (old_ext != NULL) {
1015	if (!WPACKET_init(&old_ext_wpkt, old_ext))
1016	return 0;
1017
1018	if (!WPACKET_memcpy(&old_ext_wpkt, PACKET_data(&subext),
1019	PACKET_remaining(&subext))
1020	\|\| !WPACKET_get_total_written(&old_ext_wpkt, &w)) {
1021	WPACKET_cleanup(&old_ext_wpkt);
1022	return 0;
1023	}
1024
1025	WPACKET_finish(&old_ext_wpkt);
1026	old_ext->length = w;
1027	}
1028
1029	/*
1030	* If we're not the last extension we need to move the rest earlier. The
1031	* cast below is safe because we own the underlying buffer and we're no
1032	* longer making PACKET calls.
1033	*/
1034	if (end < ext + *extlen)
1035	memmove((unsigned char *)start, end, end - start);
1036
1037	/*
1038	* Calculate new extensions payload length =
1039	* Original length
1040	* - 2 extension block length bytes
1041	* - length of removed extension
1042	*/
1043	newlen = *extlen - 2 - (end - start);
1044
1045	/* Fixup the length bytes for the extension block */
1046	ext[0] = (unsigned char)((newlen >> 8) & 0xff);
1047	ext[1] = (unsigned char)((newlen ) & 0xff);
1048
1049	/*
1050	* Length of the whole extension block is the new payload length plus the
1051	* 2 bytes for the length
1052	*/
1053	*extlen = newlen + 2;
1054
1055	/* We can now resize the message */
1056	if ((size_t)(end - start) + SSL3_HM_HEADER_LENGTH > msglen)
1057	return 0; /* Should not happen */
1058	msglen -= (end - start) + SSL3_HM_HEADER_LENGTH;
1059	if (!qtest_fault_resize_message(fault, msglen))
1060	return 0;
1061
1062	return 1;
1063	}
1064
1065	#define BIO_TYPE_CIPHER_PACKET_FILTER (0x80 \| BIO_TYPE_FILTER)
1066
1067	static BIO_METHOD *pcipherbiometh = NULL;
1068
1069	# define BIO_MSG_N(array, stride, n) ((BIO_MSG )((char )(array) + (n)(stride)))
1070
1071	static int pcipher_sendmmsg(BIO b, BIO_MSG msg, size_t stride,
1072	size_t num_msg, uint64_t flags,
1073	size_t *num_processed)
1074	{
1075	QTEST_FAULT *fault;
1076	BIO *next = BIO_next(b);
1077	ossl_ssize_t ret = 0;
1078	size_t i = 0, tmpnump;
1079	QUIC_PKT_HDR hdr;
1080	PACKET pkt;
1081	unsigned char *tmpdata;
1082
1083	if (next == NULL)
1084	return 0;
1085
1086	fault = BIO_get_data(b);
1087	if (fault == NULL
1088	\|\| (fault->pciphercb == NULL && fault->datagramcb == NULL))
1089	return BIO_sendmmsg(next, msg, stride, num_msg, flags, num_processed);
1090
1091	if (num_msg == 0) {
1092	*num_processed = 0;
1093	return 1;
1094	}
1095
1096	for (i = 0; i < num_msg; ++i) {
1097	fault->msg = BIO_MSG_N(msg, stride, i);
1098
1099	/* Take a copy of the data so that callbacks can modify it */
1100	tmpdata = OPENSSL_malloc(fault->msg.data_len + GROWTH_ALLOWANCE);
1101	if (tmpdata == NULL)
1102	return 0;
1103	memcpy(tmpdata, fault->msg.data, fault->msg.data_len);
1104	fault->msg.data = tmpdata;
1105	fault->msgalloc = fault->msg.data_len + GROWTH_ALLOWANCE;
1106
1107	if (fault->pciphercb != NULL) {
1108	if (!PACKET_buf_init(&pkt, fault->msg.data, fault->msg.data_len))
1109	return 0;
1110
1111	do {
1112	if (!ossl_quic_wire_decode_pkt_hdr(&pkt,
1113	/*
1114	* TODO(QUIC SERVER):
1115	* Needs to be set to the actual short header CID length
1116	* when testing the server implementation.
1117	*/
1118	0,
1119	1,
1120	0, &hdr, NULL))
1121	goto out;
1122
1123	/*
1124	* hdr.data is const - but its our buffer so casting away the
1125	* const is safe
1126	*/
1127	if (!fault->pciphercb(fault, &hdr, (unsigned char *)hdr.data,
1128	hdr.len, fault->pciphercbarg))
1129	goto out;
1130
1131	/*
1132	* At the moment modifications to hdr by the callback
1133	* are ignored. We might need to rewrite the QUIC header to
1134	* enable tests to change this. We also don't yet have a
1135	* mechanism for the callback to change the encrypted data
1136	* length. It's not clear if that's needed or not.
1137	*/
1138	} while (PACKET_remaining(&pkt) > 0);
1139	}
1140
1141	if (fault->datagramcb != NULL
1142	&& !fault->datagramcb(fault, &fault->msg, stride,
1143	fault->datagramcbarg))
1144	goto out;
1145
1146	if (!BIO_sendmmsg(next, &fault->msg, stride, 1, flags, &tmpnump)) {
1147	*num_processed = i;
1148	goto out;
1149	}
1150
1151	OPENSSL_free(fault->msg.data);
1152	fault->msg.data = NULL;
1153	fault->msgalloc = 0;
1154	}
1155
1156	*num_processed = i;
1157	out:
1158	ret = i > 0;
1159	OPENSSL_free(fault->msg.data);
1160	fault->msg.data = NULL;
1161	return ret;
1162	}
1163
1164	static long pcipher_ctrl(BIO b, int cmd, long larg, void parg)
1165	{
1166	BIO *next = BIO_next(b);
1167
1168	if (next == NULL)
1169	return -1;
1170
1171	return BIO_ctrl(next, cmd, larg, parg);
1172	}
1173
1174	BIO_METHOD *qtest_get_bio_method(void)
1175	{
1176	BIO_METHOD *tmp;
1177
1178	if (pcipherbiometh != NULL)
1179	return pcipherbiometh;
1180
1181	tmp = BIO_meth_new(BIO_TYPE_CIPHER_PACKET_FILTER, "Cipher Packet Filter");
1182
1183	if (!TEST_ptr(tmp))
1184	return NULL;
1185
1186	if (!TEST_true(BIO_meth_set_sendmmsg(tmp, pcipher_sendmmsg))
1187	\|\| !TEST_true(BIO_meth_set_ctrl(tmp, pcipher_ctrl)))
1188	goto err;
1189
1190	pcipherbiometh = tmp;
1191	tmp = NULL;
1192	err:
1193	BIO_meth_free(tmp);
1194	return pcipherbiometh;
1195	}
1196
1197	int qtest_fault_set_packet_cipher_listener(QTEST_FAULT *fault,
1198	qtest_fault_on_packet_cipher_cb pciphercb,
1199	void *pciphercbarg)
1200	{
1201	fault->pciphercb = pciphercb;
1202	fault->pciphercbarg = pciphercbarg;
1203
1204	return 1;
1205	}
1206
1207	int qtest_fault_set_datagram_listener(QTEST_FAULT *fault,
1208	qtest_fault_on_datagram_cb datagramcb,
1209	void *datagramcbarg)
1210	{
1211	fault->datagramcb = datagramcb;
1212	fault->datagramcbarg = datagramcbarg;
1213
1214	return 1;
1215	}
1216
1217	/* To be called from a datagram_listener callback */
1218	int qtest_fault_resize_datagram(QTEST_FAULT *fault, size_t newlen)
1219	{
1220	if (newlen > fault->msgalloc)
1221	return 0;
1222
1223	if (newlen > fault->msg.data_len)
1224	memset((unsigned char *)fault->msg.data + fault->msg.data_len, 0,
1225	newlen - fault->msg.data_len);
1226
1227	fault->msg.data_len = newlen;
1228
1229	return 1;
1230	}
1231
1232	int qtest_fault_set_bw_limit(QTEST_FAULT *fault,
1233	size_t ctos_bw, size_t stoc_bw,
1234	int noise_rate)
1235	{
1236	BIO *sbio = fault->noiseargs.sbio;
1237	BIO *cbio = fault->noiseargs.cbio;
1238
1239	if (!TEST_ptr(sbio) \|\| !TEST_ptr(cbio))
1240	return 0;
1241	if (!TEST_int_eq(BIO_ctrl(sbio, BIO_CTRL_NOISE_RATE, noise_rate, NULL), 1))
1242	return 0;
1243	if (!TEST_int_eq(BIO_ctrl(cbio, BIO_CTRL_NOISE_RATE, noise_rate, NULL), 1))
1244	return 0;
1245	/* We set the bandwidth limit on the sending side */
1246	if (!TEST_int_eq(BIO_ctrl(cbio, BIO_CTRL_NOISE_SEND_BANDWIDTH,
1247	(long)ctos_bw, NULL), 1))
1248	return 0;
1249	if (!TEST_int_eq(BIO_ctrl(sbio, BIO_CTRL_NOISE_SEND_BANDWIDTH,
1250	(long)stoc_bw, NULL), 1))
1251	return 0;
1252	return 1;
1253	}
1254
1255
1256	int bio_msg_copy(BIO_MSG dst, BIO_MSG src)
1257	{
1258	/*
1259	* Note it is assumed that the originally allocated data sizes for dst and
1260	* src are the same
1261	*/
1262	memcpy(dst->data, src->data, src->data_len);
1263	dst->data_len = src->data_len;
1264	dst->flags = src->flags;
1265	if (dst->local != NULL) {
1266	if (src->local != NULL) {
1267	if (!TEST_true(BIO_ADDR_copy(dst->local, src->local)))
1268	return 0;
1269	} else {
1270	BIO_ADDR_clear(dst->local);
1271	}
1272	}
1273	if (!TEST_true(BIO_ADDR_copy(dst->peer, src->peer)))
1274	return 0;
1275
1276	return 1;
1277	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/openssl-3.3.2/test/helpers/quictestlib.c@ 108358

以其他格式下載: