27#if defined(__linux__) && !defined(_GNU_SOURCE)
30#if defined(__APPLE__) && !defined(__APPLE_USE_RFC_3542)
31#define __APPLE_USE_RFC_3542
37#include <winpr/wtypes.h>
39#include <winpr/stream.h>
40#include <winpr/winsock.h>
41#include <winpr/wlog.h>
48#include "../udpsocket.c"
51#include "../udpflow.c"
54#include "../udplistener.c"
57#include "../udplistener_relay.c"
60#include "../server_tunnel.c"
66static BOOL on_send(WINPR_ATTR_UNUSED
void* custom, WINPR_ATTR_UNUSED
const BYTE* data,
67 WINPR_ATTR_UNUSED
size_t length)
72static BOOL on_receive(WINPR_ATTR_UNUSED
void* custom, WINPR_ATTR_UNUSED
const BYTE* data,
73 WINPR_ATTR_UNUSED
size_t length)
78static void on_event(WINPR_ATTR_UNUSED
void* custom, WINPR_ATTR_UNUSED rdpEmt* emt,
79 WINPR_ATTR_UNUSED RDPEMT_EVENT event,
const BYTE* data,
size_t length)
82 volatile BYTE sum = 0;
83 for (
size_t x = 0; x < length; x++)
87static BOOL on_read_pdu(WINPR_ATTR_UNUSED rdpPeerChannel* channel,
wStream* s,
88 WINPR_ATTR_UNUSED UINT8 Cmd, WINPR_ATTR_UNUSED UINT8 Sp,
89 WINPR_ATTR_UNUSED UINT8 cbChId, WINPR_ATTR_UNUSED BOOL fromTunnel)
91 return Stream_GetRemainingLength(s) < 1000;
95static void make_syn(BYTE syn[1232])
98 wStream sbuffer = WINPR_C_ARRAY_INIT;
99 wStream* s = Stream_StaticInit(&sbuffer, syn, 1232);
100 Stream_Write_UINT32_BE(s, 0xFFFFFFFF);
101 Stream_Write_UINT16_BE(s, 64);
102 Stream_Write_UINT16_BE(s,
104 Stream_Write_UINT32_BE(s, 1000);
105 Stream_Write_UINT16_BE(s, 1232);
106 Stream_Write_UINT16_BE(s, 1232);
107 Stream_Write_UINT16_BE(s, 0x0001);
108 Stream_Write_UINT16_BE(s, RDPUDP_PROTOCOL_VERSION_3);
111static BOOL fuzz_init(
void)
116 WLog_SetLogLevel(WLog_GetRoot(), WLOG_OFF);
117 g_ctx = SSL_CTX_new(TLS_server_method());
118 g_udp = rdpudp_new(WLog_Get(
"com.freerdp.core.test.fuzz.rdpemt"),
nullptr, on_receive,
nullptr);
119 if (!g_ctx || !g_udp)
124 if (!rdpudp_accept(g_udp, on_send,
nullptr, syn,
sizeof(syn)))
126 g_log = WLog_Get(
"com.freerdp.core.test.fuzz.rdpemt");
130static void fuzz_tunnel(BYTE flags,
const uint8_t* data,
size_t size)
132 rdpEmt emt = WINPR_C_ARRAY_INIT;
135 emt.requestId = 0x01020304;
136 emt.callback = on_event;
138 emt.ready = (flags & 0x10) != 0;
139 emt.tlsStarted = TRUE;
140 emt.handshakeDone = TRUE;
141 emt.sendLimit = 1024ull * 1024ull;
142 emt.ssl = SSL_new(g_ctx);
143 emt.rbio = BIO_new(BIO_s_mem());
144 emt.wbio = BIO_new(BIO_s_mem());
145 emt.in = Stream_New(
nullptr, size + 1);
146 emt.out = Stream_New(
nullptr, 4096);
147 emt.sendQueue = Queue_New(FALSE, -1, -1);
148 if (!emt.ssl || !emt.rbio || !emt.wbio || !emt.in || !emt.out || !emt.sendQueue ||
149 !InitializeCriticalSectionAndSpinCount(&emt.lock, 4000))
151 SSL_set_bio(emt.ssl, emt.rbio, emt.wbio);
152 SSL_set_accept_state(emt.ssl);
156 Stream_Write(emt.in, data, size);
158 (void)emt_process_pdus(&emt);
160 (
void)emt_process_server_pdus(&emt);
163 while ((s = Queue_Dequeue(emt.sendQueue)))
164 Stream_Free(s, TRUE);
165 Queue_Free(emt.sendQueue);
167 Stream_Free(emt.in, TRUE);
168 Stream_Free(emt.out, TRUE);
169 Stream_Free(emt.batch, TRUE);
170 DeleteCriticalSection(&emt.lock);
173static void fuzz_listener(
const uint8_t* data,
size_t size)
175 static const BYTE hash[32] = WINPR_C_ARRAY_INIT;
176 static const BYTE other[32] = { 1 };
178 freerdp_udp_listener* listener = freerdp_udp_listener_new();
179 rdpUdpFlow* flow = freerdp_udp_flow_new(hash);
180 rdpUdpFlow* second = freerdp_udp_flow_new(other);
181 if (!listener || !flow || !second || !freerdp_udp_listener_add_flow(listener, flow) ||
182 !freerdp_udp_listener_add_flow(listener, second))
187 while (size - offset >= 3)
189 struct sockaddr_storage addr = WINPR_C_ARRAY_INIT;
190 struct sockaddr_in* in = (
struct sockaddr_in*)&addr;
191 in->sin_family = AF_INET;
192 in->sin_port = (u_short)(data[offset] % 3);
194 const size_t length = ((size_t)data[offset + 1] << 8) | data[offset + 2];
196 if (length > size - offset)
198 udplistener_dispatch(listener, &sock, &addr,
sizeof(*in), &local, &data[offset], length);
201 BYTE datagram[UDPFLOW_MAX_DATAGRAM];
203 while (udpflow_read(flow, datagram, &got) || udpflow_read(second, datagram, &got))
209 freerdp_udp_flow_free(flow);
210 freerdp_udp_flow_free(second);
214 freerdp_udp_listener_free(listener);
217static void fuzz_soft_sync(BYTE flags,
const uint8_t* data,
size_t size)
219 struct s_wts_tunnel tunnel = WINPR_C_ARRAY_INIT;
220 rdpPeerChannel channel = WINPR_C_ARRAY_INIT;
222 vcm.tunnel = &tunnel;
223 vcm.drdynvc_channel = &channel;
224 vcm.drdynvc_state = DRDYNVC_STATE_READY;
225 tunnel.readPdu = on_read_pdu;
226 tunnel.softSyncState = (flags & 0x10) ? SOFT_SYNC_STATE_SENT : SOFT_SYNC_STATE_ANSWERED;
227 tunnel.clientOnTunnel = (flags & 0x20) != 0;
228 tunnel.tunnelBacklog = Queue_New(FALSE, -1, -1);
230 vcm.dynamicVirtualChannels = HashTable_New(TRUE);
231 if (!tunnel.tunnelBacklog || !vcm.dynamicVirtualChannels)
233 HashTable_Free(vcm.dynamicVirtualChannels);
234 Queue_Free(tunnel.tunnelBacklog);
239 const size_t half = size / 2;
240 wStream* early = Stream_New(
nullptr, half + 1);
243 Stream_Write(early, data, half);
244 Stream_SealLength(early);
245 Stream_ResetPosition(early);
246 (void)wts_tunnel_data_received(&vcm, TUNNELTYPE_UDPFECR, early);
249 wStream sbuffer = WINPR_C_ARRAY_INIT;
250 wStream* s = Stream_StaticConstInit(&sbuffer, &data[half], size - half);
252 (void)wts_tunnel_read_soft_sync_response(&vcm, s);
255 while ((held = Queue_Dequeue(tunnel.tunnelBacklog)))
256 Stream_Release(held);
257 Queue_Free(tunnel.tunnelBacklog);
258 HashTable_Free(vcm.dynamicVirtualChannels);
261int LLVMFuzzerTestOneInput(
const uint8_t* Data,
size_t Size);
262int LLVMFuzzerTestOneInput(
const uint8_t* Data,
size_t Size)
264 if ((Size < 1) || !fuzz_init())
267 switch (Data[0] & 0x03)
270 fuzz_tunnel(Data[0], &Data[1], Size - 1);
273 fuzz_listener(&Data[1], Size - 1);
276 fuzz_soft_sync(Data[0], &Data[1], Size - 1);