FreeRDP
Loading...
Searching...
No Matches
tsg.c
1
23#include <freerdp/config.h>
24
25#include "../settings.h"
26
27#include <winpr/assert.h>
28#include <winpr/crt.h>
29#include <winpr/error.h>
30#include <winpr/print.h>
31#include <winpr/stream.h>
32
33#include <freerdp/log.h>
34
35#include "rpc_bind.h"
36#include "rpc_client.h"
37#include "tsg.h"
38#include "../utils.h"
39#include "../../crypto/opensslcompat.h"
40
41#define TAG FREERDP_TAG("core.gateway.tsg")
42
43#define TSG_CAPABILITY_TYPE_NAP 0x00000001
44
45#define TSG_PACKET_TYPE_HEADER 0x00004844
46#define TSG_PACKET_TYPE_VERSIONCAPS 0x00005643
47#define TSG_PACKET_TYPE_QUARCONFIGREQUEST 0x00005143
48#define TSG_PACKET_TYPE_QUARREQUEST 0x00005152
49#define TSG_PACKET_TYPE_RESPONSE 0x00005052
50#define TSG_PACKET_TYPE_QUARENC_RESPONSE 0x00004552
51#define TSG_PACKET_TYPE_CAPS_RESPONSE 0x00004350
52#define TSG_PACKET_TYPE_MSGREQUEST_PACKET 0x00004752
53#define TSG_PACKET_TYPE_MESSAGE_PACKET 0x00004750
54#define TSG_PACKET_TYPE_AUTH 0x00004054
55#define TSG_PACKET_TYPE_REAUTH 0x00005250
56
57typedef WCHAR* RESOURCENAME;
58
59typedef struct
60{
61 RESOURCENAME* resourceName;
62 UINT32 numResourceNames;
63 RESOURCENAME* alternateResourceNames;
64 UINT16 numAlternateResourceNames;
65 UINT32 Port;
66} TSENDPOINTINFO;
67
68typedef struct
69{
70 UINT16 ComponentId;
71 UINT16 PacketId;
72} TSG_PACKET_HEADER;
73
74typedef struct
75{
76 UINT32 capabilities;
77} TSG_CAPABILITY_NAP;
78
79typedef union
80{
81 TSG_CAPABILITY_NAP tsgCapNap;
82} TSG_CAPABILITIES_UNION;
83
84typedef struct
85{
86 UINT32 capabilityType;
87 TSG_CAPABILITIES_UNION tsgPacket;
88} TSG_PACKET_CAPABILITIES;
89
90typedef struct
91{
92 TSG_PACKET_HEADER tsgHeader;
93 TSG_PACKET_CAPABILITIES tsgCaps;
94 UINT32 numCapabilities;
95 UINT16 majorVersion;
96 UINT16 minorVersion;
97 UINT16 quarantineCapabilities;
98} TSG_PACKET_VERSIONCAPS;
99
100typedef struct
101{
102 UINT32 flags;
103} TSG_PACKET_QUARCONFIGREQUEST;
104
105typedef struct
106{
107 UINT32 flags;
108 WCHAR* machineName;
109 UINT32 nameLength;
110 BYTE* data;
111 UINT32 dataLen;
112} TSG_PACKET_QUARREQUEST;
113
114typedef struct
115{
116 BOOL enableAllRedirections;
117 BOOL disableAllRedirections;
118 BOOL driveRedirectionDisabled;
119 BOOL printerRedirectionDisabled;
120 BOOL portRedirectionDisabled;
121 BOOL reserved;
122 BOOL clipboardRedirectionDisabled;
123 BOOL pnpRedirectionDisabled;
124} TSG_REDIRECTION_FLAGS;
125
126typedef struct
127{
128 UINT32 flags;
129 UINT32 reserved;
130 const BYTE* responseData;
131 UINT32 responseDataLen;
132 TSG_REDIRECTION_FLAGS redirectionFlags;
133} TSG_PACKET_RESPONSE;
134
135typedef struct
136{
137 UINT32 flags;
138 UINT32 certChainLen;
139 WCHAR* certChainData;
140 GUID nonce;
141 TSG_PACKET_VERSIONCAPS versionCaps;
142} TSG_PACKET_QUARENC_RESPONSE;
143
144typedef struct
145{
146 INT32 isDisplayMandatory;
147 INT32 isConsentMandatory;
148 UINT32 msgBytes;
149 WCHAR* msgBuffer;
150} TSG_PACKET_STRING_MESSAGE;
151
152typedef struct
153{
154 UINT64 tunnelContext;
155} TSG_PACKET_REAUTH_MESSAGE;
156
157typedef struct
158{
159 UINT32 msgID;
160 UINT32 msgType;
161 INT32 isMsgPresent;
162} TSG_PACKET_MSG_RESPONSE;
163
164typedef struct
165{
166 TSG_PACKET_QUARENC_RESPONSE pktQuarEncResponse;
167 TSG_PACKET_MSG_RESPONSE pktConsentMessage;
168} TSG_PACKET_CAPS_RESPONSE;
169
170typedef struct
171{
172 UINT32 maxMessagesPerBatch;
173} TSG_PACKET_MSG_REQUEST;
174
175typedef struct
176{
177 TSG_PACKET_VERSIONCAPS tsgVersionCaps;
178 UINT32 cookieLen;
179 BYTE* cookie;
180} TSG_PACKET_AUTH;
181
182typedef union
183{
184 TSG_PACKET_VERSIONCAPS packetVersionCaps;
185 TSG_PACKET_AUTH packetAuth;
186} TSG_INITIAL_PACKET_TYPE_UNION;
187
188typedef struct
189{
190 UINT64 tunnelContext;
191 UINT32 packetId;
192 TSG_INITIAL_PACKET_TYPE_UNION tsgInitialPacket;
193} TSG_PACKET_REAUTH;
194
195typedef union
196{
197 TSG_PACKET_HEADER packetHeader;
198 TSG_PACKET_VERSIONCAPS packetVersionCaps;
199 TSG_PACKET_QUARCONFIGREQUEST packetQuarConfigRequest;
200 TSG_PACKET_QUARREQUEST packetQuarRequest;
201 TSG_PACKET_RESPONSE packetResponse;
202 TSG_PACKET_QUARENC_RESPONSE packetQuarEncResponse;
203 TSG_PACKET_CAPS_RESPONSE packetCapsResponse;
204 TSG_PACKET_MSG_REQUEST packetMsgRequest;
205 TSG_PACKET_MSG_RESPONSE packetMsgResponse;
206 TSG_PACKET_AUTH packetAuth;
207 TSG_PACKET_REAUTH packetReauth;
208} TSG_PACKET_TYPE_UNION;
209
210typedef struct
211{
212 UINT32 packetId;
213 TSG_PACKET_TYPE_UNION tsgPacket;
214} TSG_PACKET;
215
216struct rdp_tsg
217{
218 BIO* bio;
219 rdpRpc* rpc;
220 UINT16 Port;
221 LPWSTR Hostname;
222 TSG_STATE state;
223 UINT32 TunnelId;
224 UINT32 ChannelId;
225 BOOL reauthSequence;
226 rdpTransport* transport;
227 UINT64 ReauthTunnelContext;
228 CONTEXT_HANDLE TunnelContext;
229 CONTEXT_HANDLE ChannelContext;
230 CONTEXT_HANDLE NewTunnelContext;
231 CONTEXT_HANDLE NewChannelContext;
232 wLog* log;
233 TSG_PACKET_QUARENC_RESPONSE CapsResponse;
234 TSG_PACKET_QUARREQUEST QuarreQuest;
235};
236
237WINPR_ATTR_NODISCARD
238static BOOL TsProxyReadPacketSTringMessage(wLog* log, wStream* s, uint32_t* index,
239 TSG_PACKET_STRING_MESSAGE* msg);
240
241WINPR_ATTR_NODISCARD
242static BOOL tsg_stream_align(wLog* log, wStream* s, size_t align);
243
244WINPR_ATTR_NODISCARD
245static const char* tsg_caps_to_string(UINT32 caps, char* buffer, size_t len)
246{
247 const UINT32 mask = ~(TSG_NAP_CAPABILITY_QUAR_SOH | TSG_NAP_CAPABILITY_IDLE_TIMEOUT |
248 TSG_MESSAGING_CAP_CONSENT_SIGN | TSG_MESSAGING_CAP_SERVICE_MSG |
249 TSG_MESSAGING_CAP_REAUTH);
250 const UINT32 val = caps & mask;
251
252 if ((caps & TSG_NAP_CAPABILITY_QUAR_SOH) != 0)
253 (void)winpr_str_append("TSG_NAP_CAPABILITY_QUAR_SOH", buffer, len, "|");
254 if ((caps & TSG_NAP_CAPABILITY_IDLE_TIMEOUT) != 0)
255 (void)winpr_str_append("TSG_NAP_CAPABILITY_IDLE_TIMEOUT", buffer, len, "|");
256 if ((caps & TSG_MESSAGING_CAP_CONSENT_SIGN) != 0)
257 (void)winpr_str_append("TSG_MESSAGING_CAP_CONSENT_SIGN", buffer, len, "|");
258 if ((caps & TSG_MESSAGING_CAP_SERVICE_MSG) != 0)
259 (void)winpr_str_append("TSG_MESSAGING_CAP_SERVICE_MSG", buffer, len, "|");
260 if ((caps & TSG_MESSAGING_CAP_REAUTH) != 0)
261 (void)winpr_str_append("TSG_MESSAGING_CAP_REAUTH", buffer, len, "|");
262
263 if (val != 0)
264 {
265 char number[32] = WINPR_C_ARRAY_INIT;
266 (void)_snprintf(number, sizeof(number), "TSG_UNKNOWN{0x%08" PRIx32 "}", val);
267 (void)winpr_str_append(number, buffer, len, "|");
268 }
269
270 return buffer;
271}
272
273WINPR_ATTR_NODISCARD
274static const char* tsg_packet_id_to_string(UINT32 packetId)
275{
276 switch (packetId)
277 {
278 case TSG_PACKET_TYPE_HEADER:
279 return "TSG_PACKET_TYPE_HEADER";
280 case TSG_PACKET_TYPE_VERSIONCAPS:
281 return "TSG_PACKET_TYPE_VERSIONCAPS";
282 case TSG_PACKET_TYPE_QUARCONFIGREQUEST:
283 return "TSG_PACKET_TYPE_QUARCONFIGREQUEST";
284 case TSG_PACKET_TYPE_QUARREQUEST:
285 return "TSG_PACKET_TYPE_QUARREQUEST";
286 case TSG_PACKET_TYPE_RESPONSE:
287 return "TSG_PACKET_TYPE_RESPONSE";
288 case TSG_PACKET_TYPE_QUARENC_RESPONSE:
289 return "TSG_PACKET_TYPE_QUARENC_RESPONSE";
290 case TSG_CAPABILITY_TYPE_NAP:
291 return "TSG_CAPABILITY_TYPE_NAP";
292 case TSG_PACKET_TYPE_CAPS_RESPONSE:
293 return "TSG_PACKET_TYPE_CAPS_RESPONSE";
294 case TSG_PACKET_TYPE_MSGREQUEST_PACKET:
295 return "TSG_PACKET_TYPE_MSGREQUEST_PACKET";
296 case TSG_PACKET_TYPE_MESSAGE_PACKET:
297 return "TSG_PACKET_TYPE_MESSAGE_PACKET";
298 case TSG_PACKET_TYPE_AUTH:
299 return "TSG_PACKET_TYPE_AUTH";
300 case TSG_PACKET_TYPE_REAUTH:
301 return "TSG_PACKET_TYPE_REAUTH";
302 default:
303 return "UNKNOWN";
304 }
305}
306
307WINPR_ATTR_NODISCARD
308static const char* tsg_component_id_to_string(UINT16 ComponentId, char* buffer, size_t bytelen)
309{
310 const char* str = nullptr;
311
312#define ENTRY(x) \
313 case x: \
314 str = #x; \
315 break
316 switch (ComponentId)
317 {
318 ENTRY(TS_GATEWAY_TRANSPORT);
319 default:
320 str = "TS_UNKNOWN";
321 break;
322 }
323#undef ENTRY
324
325 (void)_snprintf(buffer, bytelen, "%s [0x%04" PRIx16 "]", str, ComponentId);
326 return buffer;
327}
328
329WINPR_ATTR_NODISCARD
330static const char* tsg_state_to_string(TSG_STATE state)
331{
332 switch (state)
333 {
334 case TSG_STATE_INITIAL:
335 return "TSG_STATE_INITIAL";
336 case TSG_STATE_CONNECTED:
337 return "TSG_STATE_CONNECTED";
338 case TSG_STATE_AUTHORIZED:
339 return "TSG_STATE_AUTHORIZED";
340 case TSG_STATE_CHANNEL_CREATED:
341 return "TSG_STATE_CHANNEL_CREATED";
342 case TSG_STATE_PIPE_CREATED:
343 return "TSG_STATE_PIPE_CREATED";
344 case TSG_STATE_TUNNEL_CLOSE_PENDING:
345 return "TSG_STATE_TUNNEL_CLOSE_PENDING";
346 case TSG_STATE_CHANNEL_CLOSE_PENDING:
347 return "TSG_STATE_CHANNEL_CLOSE_PENDING";
348 case TSG_STATE_FINAL:
349 return "TSG_STATE_FINAL";
350 default:
351 return "TSG_STATE_UNKNOWN";
352 }
353}
354
355WINPR_ATTR_NODISCARD
356static BOOL TsProxyReadTunnelContext(wLog* log, wStream* s, CONTEXT_HANDLE* tunnelContext)
357{
358 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 20))
359 return FALSE;
360
361 WINPR_ASSERT(tunnelContext);
362 Stream_Read_UINT32(s, tunnelContext->ContextType); /* ContextType (4 bytes) */
363 Stream_Read(s, &tunnelContext->ContextUuid,
364 sizeof(tunnelContext->ContextUuid)); /* ContextUuid (16 bytes) */
365 return TRUE;
366}
367
368WINPR_ATTR_NODISCARD
369static BOOL TsProxyWriteTunnelContext(WINPR_ATTR_UNUSED wLog* log, wStream* s,
370 const CONTEXT_HANDLE* tunnelContext)
371{
372 if (!Stream_EnsureRemainingCapacity(s, 20))
373 return FALSE;
374
375 Stream_Write_UINT32(s, tunnelContext->ContextType); /* ContextType (4 bytes) */
376 Stream_Write(s, &tunnelContext->ContextUuid,
377 sizeof(tunnelContext->ContextUuid)); /* ContextUuid (16 bytes) */
378 return TRUE;
379}
380
381WINPR_ATTR_NODISCARD
382static BOOL tsg_ndr_pointer_write(WINPR_ATTR_UNUSED wLog* log, wStream* s, UINT32* index,
383 DWORD length)
384{
385 WINPR_ASSERT(index);
386 const UINT32 ndrPtr = 0x20000 + (*index) * 4;
387
388 if (!s)
389 return FALSE;
390 if (!Stream_EnsureRemainingCapacity(s, 4))
391 return FALSE;
392
393 if (length > 0)
394 {
395 Stream_Write_UINT32(s, ndrPtr); /* mszGroupsNdrPtr (4 bytes) */
396 (*index) = (*index) + 1;
397 }
398 else
399 Stream_Write_UINT32(s, 0);
400 return TRUE;
401}
402
403WINPR_ATTR_NODISCARD
404static BOOL tsg_ndr_pointer_read(wLog* log, wStream* s, UINT32* index, UINT32* ptrval,
405 BOOL required)
406{
407 WINPR_ASSERT(index);
408 const UINT32 ndrPtr = 0x20000 + (*index) * 4;
409
410 if (!s)
411 return FALSE;
412 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 4))
413 return FALSE;
414
415 const DWORD val = Stream_Get_UINT32(s);
416 if (ptrval)
417 *ptrval = val;
418
419 if (val != 0)
420 {
421 if (val != ndrPtr)
422 {
423 WLog_Print(log, WLOG_WARN, "Read NDR pointer 0x%04" PRIx32 " but expected 0x%04" PRIx32,
424 val, ndrPtr);
425 if ((val & 0xFFFF0000) != (ndrPtr & 0xFFFF0000))
426 return FALSE;
427 }
428 (*index)++;
429 }
430 else if (required)
431 {
432 WLog_Print(log, WLOG_ERROR, "NDR pointer == 0, but the field is required");
433 return FALSE;
434 }
435
436 return TRUE;
437}
438
439WINPR_ATTR_NODISCARD
440static BOOL tsg_ndr_write_conformant_array(WINPR_ATTR_UNUSED wLog* log, wStream* s,
441 const void* data, size_t length)
442{
443 const size_t pad = length % 4;
444 if ((length > UINT32_MAX) || !Stream_EnsureRemainingCapacity(s, 4ull + length))
445 return FALSE;
446
447 Stream_Write_UINT32(s, WINPR_ASSERTING_INT_CAST(uint32_t, length)); /* MaxCount (4 bytes) */
448 Stream_Write(s, data, length);
449 if (pad != 0)
450 Stream_Zero(s, 4 - pad);
451
452 return TRUE;
453}
454
455WINPR_ATTR_NODISCARD
456static BOOL tsg_ndr_write_string(WINPR_ATTR_UNUSED wLog* log, wStream* s, const WCHAR* str,
457 size_t length)
458{
459 const size_t pad = (length % 2) * sizeof(WCHAR);
460 if ((length > UINT32_MAX) ||
461 !Stream_EnsureRemainingCapacity(s, 12ull + length * sizeof(WCHAR) + pad))
462 return FALSE;
463
464 Stream_Write_UINT32(s, (UINT32)length); /* MaxCount (4 bytes) */
465 Stream_Write_UINT32(s, 0); /* Offset (4 bytes) */
466 Stream_Write_UINT32(s, (UINT32)length); /* ActualCount (4 bytes) */
467 if (!Stream_Write_UTF16_String(s, str, length)) /* Array */
468 return FALSE;
469 Stream_Zero(s, pad);
470 return TRUE;
471}
472
473WINPR_ATTR_NODISCARD
474static BOOL tsg_ndr_read_string(wLog* log, wStream* s, WCHAR** str, UINT32* pLengthInBytes)
475{
476 UINT32 MaxCount = 0;
477 UINT32 Offset = 0;
478 UINT32 ActualCount = 0;
479 WINPR_ASSERT(pLengthInBytes);
480 const UINT32 lengthInBytes = *pLengthInBytes;
481
482 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 12))
483 return FALSE;
484
485 Stream_Read_UINT32(s, MaxCount); /* MaxCount (4 bytes) */
486 Stream_Read_UINT32(s, Offset); /* Offset (4 bytes) */
487 Stream_Read_UINT32(s, ActualCount); /* ActualCount (4 bytes) */
488 if (ActualCount > MaxCount)
489 {
490 WLog_Print(log, WLOG_ERROR,
491 "failed to read string, ActualCount (%" PRIu32 ") > MaxCount (%" PRIu32 ")",
492 ActualCount, MaxCount);
493 return FALSE;
494 }
495 if (Offset != 0)
496 {
497 WLog_Print(log, WLOG_ERROR, "Unsupported Offset (%" PRIu32 "), expected 0", Offset);
498 return FALSE;
499 }
500 if (ActualCount > lengthInBytes / sizeof(WCHAR))
501 {
502 WLog_Print(log, WLOG_ERROR,
503 "failed to read string, ActualCount (%" PRIu32
504 ") * sizeof(WCHAR) > lengthInBytes (%" PRIu32 ")",
505 ActualCount, lengthInBytes);
506 return FALSE;
507 }
508
509 const size_t start = Stream_GetPosition(s);
510 if (str)
511 *str = Stream_PointerAs(s, WCHAR);
512
513 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, ActualCount * sizeof(WCHAR)))
514 return FALSE;
515 Stream_Seek(s, ActualCount * sizeof(WCHAR));
516 const size_t end = Stream_GetPosition(s);
517 if ((start > end) || ((end - start) > UINT32_MAX))
518 return FALSE;
519 *pLengthInBytes = WINPR_ASSERTING_INT_CAST(UINT32, end - start);
520 const size_t pad = (ActualCount % 2);
521 return Stream_SafeSeek(s, pad * sizeof(WCHAR));
522}
523
524WINPR_ATTR_NODISCARD
525static BOOL tsg_ndr_read_packet_header(wLog* log, wStream* s, TSG_PACKET_HEADER* header)
526{
527 const UINT32 ComponentId = TS_GATEWAY_TRANSPORT;
528
529 WINPR_ASSERT(header);
530 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(log, s, 2, sizeof(UINT16)))
531 return FALSE;
532 Stream_Read_UINT16(s, header->ComponentId);
533 Stream_Read_UINT16(s, header->PacketId);
534
535 if (ComponentId != header->ComponentId)
536 {
537 char buffer[64] = WINPR_C_ARRAY_INIT;
538 char buffer2[64] = WINPR_C_ARRAY_INIT;
539 WLog_Print(log, WLOG_ERROR, "Unexpected ComponentId: %s, Expected %s",
540 tsg_component_id_to_string(header->ComponentId, buffer, sizeof(buffer)),
541 tsg_component_id_to_string(ComponentId, buffer2, sizeof(buffer2)));
542 return FALSE;
543 }
544
545 return TRUE;
546}
547
548WINPR_ATTR_NODISCARD
549static BOOL tsg_ndr_write_packet_header(WINPR_ATTR_UNUSED wLog* log, wStream* s,
550 const TSG_PACKET_HEADER* header)
551{
552 WINPR_ASSERT(header);
553 if (!Stream_EnsureRemainingCapacity(s, 2 * sizeof(UINT16)))
554 return FALSE;
555 Stream_Write_UINT16(s, header->ComponentId);
556 Stream_Write_UINT16(s, header->PacketId);
557 return TRUE;
558}
559
560WINPR_ATTR_NODISCARD
561static BOOL tsg_ndr_read_nap(wLog* log, wStream* s, TSG_CAPABILITY_NAP* nap)
562{
563 WINPR_ASSERT(nap);
564
565 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(log, s, 1, sizeof(UINT32)))
566 return FALSE;
567 Stream_Read_UINT32(s, nap->capabilities);
568 {
569 char buffer[256] = WINPR_C_ARRAY_INIT;
570 WLog_Print(log, WLOG_DEBUG, "Received version caps %s",
571 tsg_caps_to_string(nap->capabilities, buffer, sizeof(buffer)));
572 }
573 return TRUE;
574}
575
576WINPR_ATTR_NODISCARD
577static BOOL tsg_ndr_write_nap(wLog* log, wStream* s, const TSG_CAPABILITY_NAP* nap)
578{
579 WINPR_ASSERT(nap);
580
581 if (!Stream_EnsureRemainingCapacity(s, 1 * sizeof(UINT32)))
582 return FALSE;
583
584 {
585 char buffer[256] = WINPR_C_ARRAY_INIT;
586 WLog_Print(log, WLOG_DEBUG, "Sending version caps %s",
587 tsg_caps_to_string(nap->capabilities, buffer, sizeof(buffer)));
588 }
589 Stream_Write_UINT32(s, nap->capabilities);
590 return TRUE;
591}
592
593WINPR_ATTR_NODISCARD
594static BOOL tsg_ndr_read_tsg_caps(wLog* log, wStream* s, TSG_PACKET_CAPABILITIES* caps)
595{
596 UINT32 capabilityType = 0;
597 UINT32 count = 0;
598 WINPR_ASSERT(caps);
599
600 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(log, s, 3, sizeof(UINT32)))
601 return FALSE;
602 Stream_Read_UINT32(s, count);
603 Stream_Read_UINT32(s, capabilityType);
604 Stream_Read_UINT32(s, caps->capabilityType);
605 if (capabilityType != caps->capabilityType)
606 {
607 WLog_Print(log, WLOG_ERROR,
608 "Inconsistent data, capabilityType 0x%08" PRIx32 " != 0x%08" PRIx32,
609 capabilityType, caps->capabilityType);
610 return FALSE;
611 }
612 switch (caps->capabilityType)
613 {
614 case TSG_CAPABILITY_TYPE_NAP:
615 if (count < 1)
616 {
617 WLog_Print(log, WLOG_ERROR, "Inconsistent data, capabilityType %s count=%" PRIu32,
618 tsg_packet_id_to_string(capabilityType), count);
619 return FALSE;
620 }
621 return tsg_ndr_read_nap(log, s, &caps->tsgPacket.tsgCapNap);
622 default:
623 WLog_Print(log, WLOG_ERROR,
624 "unknown TSG_PACKET_CAPABILITIES::capabilityType 0x%04" PRIx32
625 " [count=%" PRIu32 "]",
626 caps->capabilityType, count);
627 return FALSE;
628 }
629}
630
631WINPR_ATTR_NODISCARD
632static BOOL tsg_ndr_write_tsg_caps(wLog* log, wStream* s, const TSG_PACKET_CAPABILITIES* caps)
633{
634 WINPR_ASSERT(caps);
635
636 if (!Stream_EnsureRemainingCapacity(s, 2 * sizeof(UINT32)))
637 return FALSE;
638 Stream_Write_UINT32(s, caps->capabilityType);
639 Stream_Write_UINT32(s, caps->capabilityType);
640
641 switch (caps->capabilityType)
642 {
643 case TSG_CAPABILITY_TYPE_NAP:
644 return tsg_ndr_write_nap(log, s, &caps->tsgPacket.tsgCapNap);
645 default:
646 WLog_Print(log, WLOG_ERROR,
647 "unknown TSG_PACKET_CAPABILITIES::capabilityType 0x%04" PRIx32,
648 caps->capabilityType);
649 return FALSE;
650 }
651}
652
653WINPR_ATTR_NODISCARD
654static BOOL tsg_ndr_read_version_caps(wLog* log, wStream* s, UINT32* index,
655 TSG_PACKET_VERSIONCAPS* caps)
656{
657 WINPR_ASSERT(caps);
658 if (!tsg_ndr_read_packet_header(log, s, &caps->tsgHeader))
659 return FALSE;
660
661 UINT32 TSGCapsPtr = 0;
662 if (!tsg_ndr_pointer_read(log, s, index, &TSGCapsPtr, TRUE))
663 return FALSE;
664
665 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 10))
666 return FALSE;
667 Stream_Read_UINT32(s, caps->numCapabilities);
668 Stream_Read_UINT16(s, caps->majorVersion);
669 Stream_Read_UINT16(s, caps->minorVersion);
670 Stream_Read_UINT16(s, caps->quarantineCapabilities);
671 /* 4-byte alignment */
672 if (!tsg_stream_align(log, s, 4))
673 return FALSE;
674
675 if (caps->numCapabilities > 1)
676 {
677 WLog_ERR(TAG, "TSG_PACKET_VERSIONCAPS::numCapabilities > 1 (%" PRIu32 "), not supported!",
678 caps->numCapabilities);
679 return FALSE;
680 }
681
682 return tsg_ndr_read_tsg_caps(log, s, &caps->tsgCaps);
683}
684
685WINPR_ATTR_NODISCARD
686static BOOL tsg_ndr_write_version_caps(wLog* log, wStream* s, UINT32* index,
687 const TSG_PACKET_VERSIONCAPS* caps)
688{
689 WINPR_ASSERT(caps);
690 if (!tsg_ndr_write_packet_header(log, s, &caps->tsgHeader))
691 return FALSE;
692
693 if (!tsg_ndr_pointer_write(log, s, index, 1)) /* TsgCapsPtr (4 bytes) */
694 return FALSE;
695
696 if (!Stream_EnsureRemainingCapacity(s, 10))
697 return FALSE;
698
699 if (caps->numCapabilities > 1)
700 {
701 WLog_ERR(TAG, "TSG_PACKET_VERSIONCAPS::numCapabilities > 1 (%" PRIu32 "), not supported!",
702 caps->numCapabilities);
703 return FALSE;
704 }
705 Stream_Write_UINT32(s, caps->numCapabilities);
706 Stream_Write_UINT16(s, caps->majorVersion);
707 Stream_Write_UINT16(s, caps->minorVersion);
708 Stream_Write_UINT16(s, caps->quarantineCapabilities);
709
710 /* 4-byte alignment (30 + 2) */
711 Stream_Write_UINT16(s, 0x0000); /* pad (2 bytes) */
712 Stream_Write_UINT32(s, caps->numCapabilities); /* MaxCount (4 bytes) */
713 return tsg_ndr_write_tsg_caps(log, s, &caps->tsgCaps);
714}
715
716WINPR_ATTR_NODISCARD
717static BOOL tsg_ndr_read_quarenc_response(wLog* log, wStream* s, UINT32* index,
718 TSG_PACKET_QUARENC_RESPONSE* quarenc)
719{
720 WINPR_ASSERT(quarenc);
721 UINT32 CertChainDataPtr = 0;
722 UINT32 VersionCapsPtr = 0;
723
724 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 8))
725 return FALSE;
726 Stream_Read_UINT32(s, quarenc->flags);
727 Stream_Read_UINT32(s, quarenc->certChainLen);
728
729 if (!tsg_ndr_pointer_read(log, s, index, &CertChainDataPtr, quarenc->certChainLen != 0))
730 return FALSE;
731
732 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(log, s, 1, sizeof(quarenc->nonce)))
733 return FALSE;
734 Stream_Read(s, &quarenc->nonce, sizeof(quarenc->nonce));
735
736 return (tsg_ndr_pointer_read(log, s, index, &VersionCapsPtr, TRUE));
737}
738
739WINPR_ATTR_NODISCARD
740static BOOL tsg_ndr_read_quarenc_data(wLog* log, wStream* s, UINT32* index,
741 TSG_PACKET_QUARENC_RESPONSE* quarenc)
742{
743 WINPR_ASSERT(quarenc);
744
745 if (quarenc->certChainLen > 0)
746 {
747 /* [MS-TSGU] 2.2.9.2.1.6 TSG_PACKET_QUARENC_RESPONSE::certChainLen number of WCHAR */
748 UINT32 lengthInBytes = quarenc->certChainLen * sizeof(WCHAR);
749 if (!tsg_ndr_read_string(log, s, &quarenc->certChainData, &lengthInBytes))
750 return FALSE;
751 quarenc->certChainLen = lengthInBytes / sizeof(WCHAR);
752
753 /* 4-byte alignment */
754 if (!tsg_stream_align(log, s, 4))
755 return FALSE;
756 }
757
758 return tsg_ndr_read_version_caps(log, s, index, &quarenc->versionCaps);
759}
760
761WINPR_ATTR_NODISCARD
762static BOOL tsg_ndr_write_auth(wLog* log, wStream* s, UINT32* index, const TSG_PACKET_AUTH* auth)
763{
764 WINPR_ASSERT(auth);
765
766 if (!tsg_ndr_write_version_caps(log, s, index, &auth->tsgVersionCaps))
767 return FALSE;
768
769 if (!Stream_EnsureRemainingCapacity(s, 4))
770 return FALSE;
771
772 Stream_Write_UINT32(s, auth->cookieLen);
773 if (!tsg_ndr_pointer_write(log, s, index, auth->cookieLen))
774 return FALSE;
775
776 if (!Stream_EnsureRemainingCapacity(s, auth->cookieLen))
777 return FALSE;
778 Stream_Write(s, auth->cookie, auth->cookieLen);
779 return TRUE;
780}
781
782WINPR_ATTR_NODISCARD
783static BOOL tsg_ndr_write_reauth(wLog* log, wStream* s, UINT32* index,
784 const TSG_PACKET_REAUTH* auth)
785{
786 WINPR_ASSERT(auth);
787
788 if (!Stream_EnsureRemainingCapacity(s, 12))
789 return FALSE;
790
791 Stream_Write_UINT64(s, auth->tunnelContext); /* TunnelContext (8 bytes) */
792 Stream_Write_UINT32(s, auth->packetId); /* PacketId (4 bytes) */
793
794 switch (auth->packetId)
795 {
796 case TSG_PACKET_TYPE_VERSIONCAPS:
797 return tsg_ndr_write_version_caps(log, s, index,
798 &auth->tsgInitialPacket.packetVersionCaps);
799 case TSG_PACKET_TYPE_AUTH:
800 return tsg_ndr_write_auth(log, s, index, &auth->tsgInitialPacket.packetAuth);
801 default:
802 WLog_Print(log, WLOG_ERROR, "unexpected packetId %s",
803 tsg_packet_id_to_string(auth->packetId));
804 return FALSE;
805 }
806}
807
808WINPR_ATTR_NODISCARD
809static BOOL tsg_ndr_read_packet_redirection_flags(wLog* log, wStream* s,
810 TSG_REDIRECTION_FLAGS* redirectionFlags)
811{
812 WINPR_ASSERT(redirectionFlags);
813
814 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(log, s, 8, sizeof(UINT32)))
815 return FALSE;
816
817 redirectionFlags->enableAllRedirections =
818 Stream_Get_INT32(s); /* EnableAllRedirections (4 bytes) */
819 redirectionFlags->disableAllRedirections =
820 Stream_Get_INT32(s); /* DisableAllRedirections (4 bytes) */
821 redirectionFlags->driveRedirectionDisabled =
822 Stream_Get_INT32(s); /* DriveRedirectionDisabled (4 bytes) */
823 redirectionFlags->printerRedirectionDisabled =
824 Stream_Get_INT32(s); /* PrinterRedirectionDisabled (4 bytes) */
825 redirectionFlags->portRedirectionDisabled =
826 Stream_Get_INT32(s); /* PortRedirectionDisabled (4 bytes) */
827 redirectionFlags->reserved = Stream_Get_INT32(s); /* Reserved (4 bytes) */
828 redirectionFlags->clipboardRedirectionDisabled =
829 Stream_Get_INT32(s); /* ClipboardRedirectionDisabled (4 bytes) */
830 redirectionFlags->pnpRedirectionDisabled =
831 Stream_Get_INT32(s); /* PnpRedirectionDisabled (4 bytes) */
832 return TRUE;
833}
834
835WINPR_ATTR_FORMAT_ARG(3, 4)
836static BOOL tsg_print(char** buffer, size_t* len, WINPR_FORMAT_ARG const char* fmt, ...)
837{
838 int rc = 0;
839 va_list ap = WINPR_C_ARRAY_INIT;
840 if (!buffer || !len || !fmt)
841 return FALSE;
842 va_start(ap, fmt);
843 rc = vsnprintf(*buffer, *len, fmt, ap);
844 va_end(ap);
845 if ((rc < 0) || ((size_t)rc > *len))
846 return FALSE;
847 *len -= (size_t)rc;
848 *buffer += (size_t)rc;
849 return TRUE;
850}
851
852WINPR_ATTR_NODISCARD
853static BOOL tsg_packet_header_to_string(char** buffer, size_t* length,
854 const TSG_PACKET_HEADER* header)
855{
856 WINPR_ASSERT(buffer);
857 WINPR_ASSERT(length);
858 WINPR_ASSERT(header);
859
860 return tsg_print(buffer, length,
861 "header { ComponentId=0x%04" PRIx16 ", PacketId=0x%04" PRIx16 " }",
862 header->ComponentId, header->PacketId);
863}
864
865WINPR_ATTR_NODISCARD
866static BOOL tsg_type_capability_nap_to_string(char** buffer, size_t* length,
867 const TSG_CAPABILITY_NAP* cur)
868{
869 WINPR_ASSERT(buffer);
870 WINPR_ASSERT(length);
871 WINPR_ASSERT(cur);
872
873 return tsg_print(buffer, length, "%s { capabilities=0x%08" PRIx32 " }",
874 tsg_packet_id_to_string(TSG_CAPABILITY_TYPE_NAP), cur->capabilities);
875}
876
877WINPR_ATTR_NODISCARD
878static BOOL tsg_packet_capabilities_to_string(char** buffer, size_t* length,
879 const TSG_PACKET_CAPABILITIES* caps, UINT32 numCaps)
880{
881 WINPR_ASSERT(buffer);
882 WINPR_ASSERT(length);
883 WINPR_ASSERT(caps);
884
885 if (!tsg_print(buffer, length, "capabilities { "))
886 return FALSE;
887
888 for (UINT32 x = 0; x < numCaps; x++)
889 {
890 const TSG_PACKET_CAPABILITIES* cur = &caps[x];
891 switch (cur->capabilityType)
892 {
893 case TSG_CAPABILITY_TYPE_NAP:
894 if (!tsg_type_capability_nap_to_string(buffer, length, &cur->tsgPacket.tsgCapNap))
895 return FALSE;
896 break;
897 default:
898 if (!tsg_print(buffer, length, "TSG_UNKNOWN_CAPABILITY"))
899 return FALSE;
900 break;
901 }
902 }
903 return tsg_print(buffer, length, " }");
904}
905
906static BOOL tsg_packet_versioncaps_to_string(char** buffer, size_t* length,
907 const TSG_PACKET_VERSIONCAPS* caps)
908{
909 WINPR_ASSERT(buffer);
910 WINPR_ASSERT(length);
911 WINPR_ASSERT(caps);
912
913 if (!tsg_print(buffer, length, "versioncaps { "))
914 return FALSE;
915 if (!tsg_packet_header_to_string(buffer, length, &caps->tsgHeader))
916 return FALSE;
917
918 if (!tsg_print(buffer, length, " "))
919 return FALSE;
920
921 if (caps->numCapabilities > 1)
922 {
923 WLog_ERR(TAG, "TSG_PACKET_VERSIONCAPS::numCapabilities > 1 (%" PRIu32 "), not supported!",
924 caps->numCapabilities);
925 return FALSE;
926 }
927
928 if (!tsg_packet_capabilities_to_string(buffer, length, &caps->tsgCaps, caps->numCapabilities))
929 return FALSE;
930
931 if (!tsg_print(buffer, length,
932 " numCapabilities=0x%08" PRIx32 ", majorVersion=0x%04" PRIx16
933 ", minorVersion=0x%04" PRIx16 ", quarantineCapabilities=0x%04" PRIx16,
934 caps->numCapabilities, caps->majorVersion, caps->minorVersion,
935 caps->quarantineCapabilities))
936 return FALSE;
937
938 return tsg_print(buffer, length, " }");
939}
940
941WINPR_ATTR_NODISCARD
942static BOOL tsg_packet_quarconfigrequest_to_string(char** buffer, size_t* length,
943 const TSG_PACKET_QUARCONFIGREQUEST* caps)
944{
945 WINPR_ASSERT(buffer);
946 WINPR_ASSERT(length);
947 WINPR_ASSERT(caps);
948
949 if (!tsg_print(buffer, length, "quarconfigrequest { "))
950 return FALSE;
951
952 if (!tsg_print(buffer, length, " "))
953 return FALSE;
954
955 if (!tsg_print(buffer, length, " flags=0x%08" PRIx32, caps->flags))
956 return FALSE;
957
958 return tsg_print(buffer, length, " }");
959}
960
961WINPR_ATTR_NODISCARD
962static BOOL tsg_packet_quarrequest_to_string(char** buffer, size_t* length,
963 const TSG_PACKET_QUARREQUEST* caps)
964{
965 BOOL rc = FALSE;
966 char* name = nullptr;
967 char* strdata = nullptr;
968
969 WINPR_ASSERT(buffer);
970 WINPR_ASSERT(length);
971 WINPR_ASSERT(caps);
972
973 if (!tsg_print(buffer, length, "quarrequest { "))
974 return FALSE;
975
976 if (!tsg_print(buffer, length, " "))
977 return FALSE;
978
979 if (caps->nameLength > 0)
980 {
981 if (caps->nameLength > INT_MAX)
982 return FALSE;
983 name = ConvertWCharNToUtf8Alloc(caps->machineName, caps->nameLength, nullptr);
984 if (!name)
985 return FALSE;
986 }
987
988 strdata = winpr_BinToHexString(caps->data, caps->dataLen, TRUE);
989 if (strdata || (caps->dataLen == 0))
990 rc = tsg_print(buffer, length,
991 " flags=0x%08" PRIx32 ", machineName=%s [%" PRIu32 "], data[%" PRIu32 "]=%s",
992 caps->flags, name, caps->nameLength, caps->dataLen, strdata);
993 free(name);
994 free(strdata);
995 if (!rc)
996 return FALSE;
997
998 return tsg_print(buffer, length, " }");
999}
1000
1001WINPR_ATTR_NODISCARD
1002static const char* tsg_bool_to_string(BOOL val)
1003{
1004 if (val)
1005 return "true";
1006 return "false";
1007}
1008
1009WINPR_ATTR_NODISCARD
1010static const char* tsg_redirection_flags_to_string(char* buffer, size_t size,
1011 const TSG_REDIRECTION_FLAGS* flags)
1012{
1013 WINPR_ASSERT(buffer || (size == 0));
1014 WINPR_ASSERT(flags);
1015
1016 (void)_snprintf(
1017 buffer, size,
1018 "enableAllRedirections=%s, disableAllRedirections=%s, driveRedirectionDisabled=%s, "
1019 "printerRedirectionDisabled=%s, portRedirectionDisabled=%s, reserved=%s, "
1020 "clipboardRedirectionDisabled=%s, pnpRedirectionDisabled=%s",
1021 tsg_bool_to_string(flags->enableAllRedirections),
1022 tsg_bool_to_string(flags->disableAllRedirections),
1023 tsg_bool_to_string(flags->driveRedirectionDisabled),
1024 tsg_bool_to_string(flags->printerRedirectionDisabled),
1025 tsg_bool_to_string(flags->portRedirectionDisabled), tsg_bool_to_string(flags->reserved),
1026 tsg_bool_to_string(flags->clipboardRedirectionDisabled),
1027 tsg_bool_to_string(flags->pnpRedirectionDisabled));
1028 return buffer;
1029}
1030
1031WINPR_ATTR_NODISCARD
1032static BOOL tsg_packet_response_to_string(char** buffer, size_t* length,
1033 const TSG_PACKET_RESPONSE* caps)
1034{
1035 BOOL rc = FALSE;
1036 char* strdata = nullptr;
1037 char tbuffer[8192] = WINPR_C_ARRAY_INIT;
1038
1039 WINPR_ASSERT(buffer);
1040 WINPR_ASSERT(length);
1041 WINPR_ASSERT(caps);
1042
1043 if (!tsg_print(buffer, length, "response { "))
1044 return FALSE;
1045
1046 if (!tsg_print(buffer, length, " "))
1047 return FALSE;
1048
1049 strdata = winpr_BinToHexString(caps->responseData, caps->responseDataLen, TRUE);
1050 if (strdata || (caps->responseDataLen == 0))
1051 rc = tsg_print(
1052 buffer, length,
1053 " flags=0x%08" PRIx32 ", reserved=0x%08" PRIx32 ", responseData[%" PRIu32
1054 "]=%s, redirectionFlags={ %s }",
1055 caps->flags, caps->reserved, caps->responseDataLen, strdata,
1056 tsg_redirection_flags_to_string(tbuffer, ARRAYSIZE(tbuffer), &caps->redirectionFlags));
1057 free(strdata);
1058 if (!rc)
1059 return FALSE;
1060
1061 return tsg_print(buffer, length, " }");
1062}
1063
1064WINPR_ATTR_NODISCARD
1065static BOOL tsg_packet_quarenc_response_to_string(char** buffer, size_t* length,
1066 const TSG_PACKET_QUARENC_RESPONSE* caps)
1067{
1068 BOOL rc = FALSE;
1069 char* strdata = nullptr;
1070 char tbuffer[8192] = WINPR_C_ARRAY_INIT;
1071 size_t size = ARRAYSIZE(tbuffer);
1072 char* ptbuffer = tbuffer;
1073
1074 WINPR_ASSERT(buffer);
1075 WINPR_ASSERT(length);
1076 WINPR_ASSERT(caps);
1077
1078 if (!tsg_print(buffer, length, "quarenc_response { "))
1079 return FALSE;
1080
1081 if (!tsg_print(buffer, length, " "))
1082 return FALSE;
1083
1084 char uuid[64] = WINPR_C_ARRAY_INIT;
1085 guid2str(&caps->nonce, uuid, sizeof(uuid));
1086
1087 if (caps->certChainLen > 0)
1088 {
1089 if (caps->certChainLen > INT_MAX)
1090 goto fail;
1091 strdata = ConvertWCharNToUtf8Alloc(caps->certChainData, caps->certChainLen, nullptr);
1092 if (!strdata)
1093 goto fail;
1094 }
1095
1096 tsg_packet_versioncaps_to_string(&ptbuffer, &size, &caps->versionCaps);
1097 if (strdata || (caps->certChainLen == 0))
1098 rc =
1099 tsg_print(buffer, length,
1100 " flags=0x%08" PRIx32 ", certChain[%" PRIu32 "]=%s, nonce=%s, versionCaps=%s",
1101 caps->flags, caps->certChainLen, strdata, uuid, tbuffer);
1102
1103fail:
1104 free(strdata);
1105 if (!rc)
1106 return FALSE;
1107
1108 return tsg_print(buffer, length, " }");
1109}
1110
1111WINPR_ATTR_NODISCARD
1112static BOOL tsg_packet_message_response_to_string(char** buffer, size_t* length,
1113 const TSG_PACKET_MSG_RESPONSE* caps)
1114{
1115 WINPR_ASSERT(buffer);
1116 WINPR_ASSERT(length);
1117 WINPR_ASSERT(caps);
1118
1119 if (!tsg_print(buffer, length, "msg_response { "))
1120 return FALSE;
1121
1122 if (!tsg_print(buffer, length,
1123 " msgID=0x%08" PRIx32 ", msgType=0x%08" PRIx32 ", isMsgPresent=%" PRId32,
1124 caps->msgID, caps->msgType, caps->isMsgPresent))
1125 return FALSE;
1126
1127 return tsg_print(buffer, length, " }");
1128}
1129
1130WINPR_ATTR_NODISCARD
1131static BOOL tsg_packet_caps_response_to_string(char** buffer, size_t* length,
1132 const TSG_PACKET_CAPS_RESPONSE* caps)
1133{
1134 WINPR_ASSERT(buffer);
1135 WINPR_ASSERT(length);
1136 WINPR_ASSERT(caps);
1137
1138 if (!tsg_print(buffer, length, "caps_response { "))
1139 return FALSE;
1140
1141 if (!tsg_packet_quarenc_response_to_string(buffer, length, &caps->pktQuarEncResponse))
1142 return FALSE;
1143
1144 if (!tsg_packet_message_response_to_string(buffer, length, &caps->pktConsentMessage))
1145 return FALSE;
1146
1147 return tsg_print(buffer, length, " }");
1148}
1149
1150WINPR_ATTR_NODISCARD
1151static BOOL tsg_packet_message_request_to_string(char** buffer, size_t* length,
1152 const TSG_PACKET_MSG_REQUEST* caps)
1153{
1154 WINPR_ASSERT(buffer);
1155 WINPR_ASSERT(length);
1156 WINPR_ASSERT(caps);
1157
1158 if (!tsg_print(buffer, length, "caps_message_request { "))
1159 return FALSE;
1160
1161 if (!tsg_print(buffer, length, " maxMessagesPerBatch=%" PRIu32, caps->maxMessagesPerBatch))
1162 return FALSE;
1163
1164 return tsg_print(buffer, length, " }");
1165}
1166
1167WINPR_ATTR_NODISCARD
1168static BOOL tsg_packet_auth_to_string(char** buffer, size_t* length, const TSG_PACKET_AUTH* caps)
1169{
1170 BOOL rc = FALSE;
1171 char* strdata = nullptr;
1172 WINPR_ASSERT(buffer);
1173 WINPR_ASSERT(length);
1174 WINPR_ASSERT(caps);
1175
1176 if (!tsg_print(buffer, length, "caps_message_request { "))
1177 return FALSE;
1178
1179 if (!tsg_packet_versioncaps_to_string(buffer, length, &caps->tsgVersionCaps))
1180 return FALSE;
1181
1182 strdata = winpr_BinToHexString(caps->cookie, caps->cookieLen, TRUE);
1183 if (strdata || (caps->cookieLen == 0))
1184 rc = tsg_print(buffer, length, " cookie[%" PRIu32 "]=%s", caps->cookieLen, strdata);
1185 free(strdata);
1186 if (!rc)
1187 return FALSE;
1188
1189 return tsg_print(buffer, length, " }");
1190}
1191
1192WINPR_ATTR_NODISCARD
1193static BOOL tsg_packet_reauth_to_string(char** buffer, size_t* length,
1194 const TSG_PACKET_REAUTH* caps)
1195{
1196 BOOL rc = FALSE;
1197 WINPR_ASSERT(buffer);
1198 WINPR_ASSERT(length);
1199 WINPR_ASSERT(caps);
1200
1201 if (!tsg_print(buffer, length, "caps_message_request { "))
1202 return FALSE;
1203
1204 if (!tsg_print(buffer, length, " tunnelContext=0x%016" PRIx64 ", packetId=%s [0x%08" PRIx32 "]",
1205 caps->tunnelContext, tsg_packet_id_to_string(caps->packetId), caps->packetId))
1206 return FALSE;
1207
1208 switch (caps->packetId)
1209 {
1210 case TSG_PACKET_TYPE_VERSIONCAPS:
1211 rc = tsg_packet_versioncaps_to_string(buffer, length,
1212 &caps->tsgInitialPacket.packetVersionCaps);
1213 break;
1214 case TSG_PACKET_TYPE_AUTH:
1215 rc = tsg_packet_auth_to_string(buffer, length, &caps->tsgInitialPacket.packetAuth);
1216 break;
1217 default:
1218 rc = tsg_print(buffer, length, "TODO: Unhandled packet type %s [0x%08" PRIx32 "]",
1219 tsg_packet_id_to_string(caps->packetId), caps->packetId);
1220 break;
1221 }
1222
1223 if (!rc)
1224 return FALSE;
1225
1226 return tsg_print(buffer, length, " }");
1227}
1228
1229WINPR_ATTR_NODISCARD
1230static const char* tsg_packet_to_string(const TSG_PACKET* packet)
1231{
1232 size_t len = 8192;
1233 static char sbuffer[8193] = WINPR_C_ARRAY_INIT;
1234 char* buffer = sbuffer;
1235
1236 if (!tsg_print(&buffer, &len, "TSG_PACKET { packetId=%s [0x%08" PRIx32 "], ",
1237 tsg_packet_id_to_string(packet->packetId), packet->packetId))
1238 goto fail;
1239
1240 switch (packet->packetId)
1241 {
1242 case TSG_PACKET_TYPE_HEADER:
1243 if (!tsg_packet_header_to_string(&buffer, &len, &packet->tsgPacket.packetHeader))
1244 goto fail;
1245 break;
1246 case TSG_PACKET_TYPE_VERSIONCAPS:
1247 if (!tsg_packet_versioncaps_to_string(&buffer, &len,
1248 &packet->tsgPacket.packetVersionCaps))
1249 goto fail;
1250 break;
1251 case TSG_PACKET_TYPE_QUARCONFIGREQUEST:
1252 if (!tsg_packet_quarconfigrequest_to_string(&buffer, &len,
1253 &packet->tsgPacket.packetQuarConfigRequest))
1254 goto fail;
1255 break;
1256 case TSG_PACKET_TYPE_QUARREQUEST:
1257 if (!tsg_packet_quarrequest_to_string(&buffer, &len,
1258 &packet->tsgPacket.packetQuarRequest))
1259 goto fail;
1260 break;
1261 case TSG_PACKET_TYPE_RESPONSE:
1262 if (!tsg_packet_response_to_string(&buffer, &len, &packet->tsgPacket.packetResponse))
1263 goto fail;
1264 break;
1265 case TSG_PACKET_TYPE_QUARENC_RESPONSE:
1266 if (!tsg_packet_quarenc_response_to_string(&buffer, &len,
1267 &packet->tsgPacket.packetQuarEncResponse))
1268 goto fail;
1269 break;
1270 case TSG_PACKET_TYPE_CAPS_RESPONSE:
1271 if (!tsg_packet_caps_response_to_string(&buffer, &len,
1272 &packet->tsgPacket.packetCapsResponse))
1273 goto fail;
1274 break;
1275 case TSG_PACKET_TYPE_MSGREQUEST_PACKET:
1276 if (!tsg_packet_message_request_to_string(&buffer, &len,
1277 &packet->tsgPacket.packetMsgRequest))
1278 goto fail;
1279 break;
1280 case TSG_PACKET_TYPE_MESSAGE_PACKET:
1281 if (!tsg_packet_message_response_to_string(&buffer, &len,
1282 &packet->tsgPacket.packetMsgResponse))
1283 goto fail;
1284 break;
1285 case TSG_PACKET_TYPE_AUTH:
1286 if (!tsg_packet_auth_to_string(&buffer, &len, &packet->tsgPacket.packetAuth))
1287 goto fail;
1288 break;
1289 case TSG_PACKET_TYPE_REAUTH:
1290 if (!tsg_packet_reauth_to_string(&buffer, &len, &packet->tsgPacket.packetReauth))
1291 goto fail;
1292 break;
1293 default:
1294 if (!tsg_print(&buffer, &len, "INVALID"))
1295 goto fail;
1296 break;
1297 }
1298
1299 if (!tsg_print(&buffer, &len, " }"))
1300 goto fail;
1301
1302fail:
1303 return sbuffer;
1304}
1305
1306WINPR_ATTR_NODISCARD
1307static BOOL tsg_stream_align(wLog* log, wStream* s, size_t align)
1308{
1309 size_t pos = 0;
1310 size_t offset = 0;
1311
1312 if (!s)
1313 return FALSE;
1314
1315 pos = Stream_GetPosition(s);
1316
1317 if ((pos % align) != 0)
1318 offset = align - pos % align;
1319
1320 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, offset))
1321 return FALSE;
1322 Stream_Seek(s, offset);
1323 return TRUE;
1324}
1325
1326WINPR_ATTR_NODISCARD
1327static BIO_METHOD* BIO_s_tsg(void);
1363WINPR_ATTR_NODISCARD
1364static int TsProxySendToServer(handle_t IDL_handle, const byte pRpcMessage[], UINT32 count,
1365 const UINT32* lengths)
1366{
1367 wStream* s = nullptr;
1368 rdpTsg* tsg = nullptr;
1369 size_t length = 0;
1370 const byte* buffer1 = nullptr;
1371 const byte* buffer2 = nullptr;
1372 const byte* buffer3 = nullptr;
1373 UINT32 buffer1Length = 0;
1374 UINT32 buffer2Length = 0;
1375 UINT32 buffer3Length = 0;
1376 UINT32 numBuffers = 0;
1377 UINT32 totalDataBytes = 0;
1378 tsg = (rdpTsg*)IDL_handle;
1379 buffer1Length = buffer2Length = buffer3Length = 0;
1380
1381 if (count > 0)
1382 {
1383 numBuffers++;
1384 buffer1 = &pRpcMessage[0];
1385 buffer1Length = lengths[0];
1386 totalDataBytes += lengths[0] + 4;
1387 }
1388
1389 if (count > 1)
1390 {
1391 numBuffers++;
1392 buffer2 = &pRpcMessage[1];
1393 buffer2Length = lengths[1];
1394 totalDataBytes += lengths[1] + 4;
1395 }
1396
1397 if (count > 2)
1398 {
1399 numBuffers++;
1400 buffer3 = &pRpcMessage[2];
1401 buffer3Length = lengths[2];
1402 totalDataBytes += lengths[2] + 4;
1403 }
1404
1405 length = 28ull + totalDataBytes;
1406 if (length > INT_MAX)
1407 return -1;
1408 s = Stream_New(nullptr, length);
1409
1410 if (!s)
1411 {
1412 WLog_Print(tsg->log, WLOG_ERROR, "Stream_New failed!");
1413 return -1;
1414 }
1415
1416 /* PCHANNEL_CONTEXT_HANDLE_NOSERIALIZE_NR (20 bytes) */
1417 if (!TsProxyWriteTunnelContext(tsg->log, s, &tsg->ChannelContext))
1418 goto fail;
1419 Stream_Write_UINT32_BE(s, totalDataBytes); /* totalDataBytes (4 bytes) */
1420 Stream_Write_UINT32_BE(s, numBuffers); /* numBuffers (4 bytes) */
1421
1422 if (buffer1Length > 0)
1423 Stream_Write_UINT32_BE(s, buffer1Length); /* buffer1Length (4 bytes) */
1424
1425 if (buffer2Length > 0)
1426 Stream_Write_UINT32_BE(s, buffer2Length); /* buffer2Length (4 bytes) */
1427
1428 if (buffer3Length > 0)
1429 Stream_Write_UINT32_BE(s, buffer3Length); /* buffer3Length (4 bytes) */
1430
1431 if (buffer1Length > 0)
1432 Stream_Write(s, buffer1, buffer1Length); /* buffer1 (variable) */
1433
1434 if (buffer2Length > 0)
1435 Stream_Write(s, buffer2, buffer2Length); /* buffer2 (variable) */
1436
1437 if (buffer3Length > 0)
1438 Stream_Write(s, buffer3, buffer3Length); /* buffer3 (variable) */
1439
1440 if (!rpc_client_write_call(tsg->rpc, s, TsProxySendToServerOpnum))
1441 return -1;
1442
1443 return (int)length;
1444fail:
1445 Stream_Free(s, TRUE);
1446 return -1;
1447}
1448
1459WINPR_ATTR_NODISCARD
1460static BOOL TsProxyCreateTunnelWriteRequest(rdpTsg* tsg, const TSG_PACKET* tsgPacket)
1461{
1462 BOOL rc = FALSE;
1463 BOOL write = TRUE;
1464 UINT16 opnum = 0;
1465 wStream* s = nullptr;
1466 rdpRpc* rpc = nullptr;
1467
1468 if (!tsg || !tsg->rpc)
1469 return FALSE;
1470
1471 rpc = tsg->rpc;
1472 WLog_Print(tsg->log, WLOG_DEBUG, "%s", tsg_packet_to_string(tsgPacket));
1473 s = Stream_New(nullptr, 108);
1474
1475 if (!s)
1476 return FALSE;
1477
1478 switch (tsgPacket->packetId)
1479 {
1480 case TSG_PACKET_TYPE_VERSIONCAPS:
1481 {
1482 UINT32 index = 0;
1483 const TSG_PACKET_VERSIONCAPS* packetVersionCaps =
1484 &tsgPacket->tsgPacket.packetVersionCaps;
1485
1486 Stream_Write_UINT32(s, tsgPacket->packetId); /* PacketId (4 bytes) */
1487 Stream_Write_UINT32(s, tsgPacket->packetId); /* SwitchValue (4 bytes) */
1488 if (!tsg_ndr_pointer_write(tsg->log, s, &index, 1)) /* PacketVersionCapsPtr (4 bytes) */
1489 goto fail;
1490
1491 if (!tsg_ndr_write_version_caps(tsg->log, s, &index, packetVersionCaps))
1492 goto fail;
1497 /*
1498 * 8-byte constant (8A E3 13 71 02 F4 36 71) also observed here:
1499 * http://lists.samba.org/archive/cifs-protocol/2010-July/001543.html
1500 */
1501 Stream_Write_UINT8(s, 0x8A);
1502 Stream_Write_UINT8(s, 0xE3);
1503 Stream_Write_UINT8(s, 0x13);
1504 Stream_Write_UINT8(s, 0x71);
1505 Stream_Write_UINT8(s, 0x02);
1506 Stream_Write_UINT8(s, 0xF4);
1507 Stream_Write_UINT8(s, 0x36);
1508 Stream_Write_UINT8(s, 0x71);
1509 Stream_Write_UINT32(s, 0x00040001); /* 1.4 (version?) */
1510 Stream_Write_UINT32(s, 0x00000001); /* 1 (element count?) */
1511 /* p_cont_list_t */
1512 Stream_Write_UINT8(s, 2); /* ncontext_elem */
1513 Stream_Write_UINT8(s, 0x40); /* reserved1 */
1514 Stream_Write_UINT16(s, 0x0028); /* reserved2 */
1515 /* p_syntax_id_t */
1516 Stream_Write(s, &TSGU_UUID, sizeof(p_uuid_t));
1517 Stream_Write_UINT32(s, TSGU_SYNTAX_IF_VERSION);
1518 /* p_syntax_id_t */
1519 Stream_Write(s, &NDR_UUID, sizeof(p_uuid_t));
1520 Stream_Write_UINT32(s, NDR_SYNTAX_IF_VERSION);
1521 opnum = TsProxyCreateTunnelOpnum;
1522 }
1523 break;
1524
1525 case TSG_PACKET_TYPE_REAUTH:
1526 {
1527 const TSG_PACKET_REAUTH* packetReauth = &tsgPacket->tsgPacket.packetReauth;
1528 UINT32 index = 0;
1529 Stream_Write_UINT32(s, tsgPacket->packetId); /* PacketId (4 bytes) */
1530 Stream_Write_UINT32(s, tsgPacket->packetId); /* SwitchValue (4 bytes) */
1531 if (!tsg_ndr_pointer_write(tsg->log, s, &index, 1)) /* PacketReauthPtr (4 bytes) */
1532 goto fail;
1533 if (!tsg_ndr_write_reauth(tsg->log, s, &index, packetReauth))
1534 goto fail;
1535 opnum = TsProxyCreateTunnelOpnum;
1536 }
1537 break;
1538
1539 default:
1540 WLog_Print(tsg->log, WLOG_WARN, "unexpected packetId %s",
1541 tsg_packet_id_to_string(tsgPacket->packetId));
1542 write = FALSE;
1543 break;
1544 }
1545
1546 rc = TRUE;
1547
1548 if (write)
1549 return rpc_client_write_call(rpc, s, opnum);
1550fail:
1551 Stream_Free(s, TRUE);
1552 return rc;
1553}
1554
1555WINPR_ATTR_NODISCARD
1556static BOOL tsg_ndr_read_consent_message(wLog* log, rdpContext* context, wStream* s, UINT32* index,
1557 UINT32 msgType, BOOL isMessagePresent)
1558{
1559 TSG_PACKET_STRING_MESSAGE packetStringMessage = WINPR_C_ARRAY_INIT;
1560
1561 WINPR_ASSERT(context);
1562 WINPR_ASSERT(index);
1563
1564 if (!TsProxyReadPacketSTringMessage(log, s, index, &packetStringMessage))
1565 return FALSE;
1566
1567 if (context->instance && isMessagePresent)
1568 {
1569 return IFCALLRESULT(TRUE, context->instance->PresentGatewayMessage, context->instance,
1570 msgType, packetStringMessage.isDisplayMandatory != 0,
1571 packetStringMessage.isConsentMandatory != 0,
1572 packetStringMessage.msgBytes, packetStringMessage.msgBuffer);
1573 }
1574
1575 return TRUE;
1576}
1577
1578WINPR_ATTR_NODISCARD
1579static BOOL tsg_ndr_read_tunnel_context(wLog* log, wStream* s, CONTEXT_HANDLE* tunnelContext,
1580 UINT32* tunnelId)
1581{
1582 if (!tsg_stream_align(log, s, 4))
1583 return FALSE;
1584
1585 /* TunnelContext (20 bytes) */
1586 if (!TsProxyReadTunnelContext(log, s, tunnelContext))
1587 return FALSE;
1588
1589 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 8))
1590 return FALSE;
1591
1592 WINPR_ASSERT(tunnelId);
1593 Stream_Read_UINT32(s, *tunnelId); /* TunnelId (4 bytes) */
1594
1595 INT32 ReturnValue = 0;
1596 Stream_Read_INT32(s, ReturnValue); /* ReturnValue (4 bytes) */
1597 if (ReturnValue != NO_ERROR)
1598 WLog_WARN(TAG, "ReturnValue=%s", NtStatus2Tag(ReturnValue));
1599 return TRUE;
1600}
1601
1602WINPR_ATTR_NODISCARD
1603static BOOL tsg_ndr_read_TSG_PACKET_MSG_RESPONSE_header(wLog* log, wStream* s,
1604 TSG_PACKET_MSG_RESPONSE* pkt)
1605{
1606
1607 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 16))
1608 return FALSE;
1609
1610 Stream_Read_UINT32(s, pkt->msgID); /* MsgId (4 bytes) */
1611 Stream_Read_UINT32(s, pkt->msgType); /* MsgType (4 bytes) */
1612 Stream_Read_INT32(s, pkt->isMsgPresent); /* IsMsgPresent (4 bytes) */
1613 const uint32_t SwitchValue = Stream_Get_UINT32(s); /* SwitchValue (4 bytes) */
1614
1615 if (pkt->msgType != SwitchValue)
1616 {
1617 WLog_ERR(TAG,
1618 "[MS-TSGU] 2.2.9.2.1.9 TSG_PACKET_MSG_RESPONSE MsgType[0x%08" PRIx32
1619 "] != MessageSwitchValue [0x%08" PRIx32 "]",
1620 pkt->msgType, SwitchValue);
1621 return FALSE;
1622 }
1623
1624 return TRUE;
1625}
1626
1627WINPR_ATTR_NODISCARD
1628static BOOL tsg_ndr_read_TSG_PACKET_MSG_RESPONSE(wLog* log, rdpContext* context, wStream* s,
1629 uint32_t* index, uint32_t MsgPtr,
1630 const TSG_PACKET_MSG_RESPONSE* pkg,
1631 uint64_t* reauthContext)
1632{
1633 WINPR_ASSERT(pkg);
1634
1635 if (MsgPtr == 0)
1636 {
1637 WLog_Print(log, WLOG_DEBUG,
1638 "Message {0x%08" PRIx32 "} [%s]::isMsgPresent=%" PRId32 ", MsgPtr=0x%08" PRIx32,
1639 pkg->msgType, tsg_packet_id_to_string(pkg->msgType), pkg->isMsgPresent, MsgPtr);
1640 return TRUE;
1641 }
1642
1643 switch (pkg->msgType)
1644 {
1645 case TSG_ASYNC_MESSAGE_CONSENT_MESSAGE:
1646 case TSG_ASYNC_MESSAGE_SERVICE_MESSAGE:
1647 return tsg_ndr_read_consent_message(log, context, s, index, pkg->msgType,
1648 pkg->isMsgPresent);
1649
1650 case TSG_ASYNC_MESSAGE_REAUTH:
1651 {
1652 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 8))
1653 return FALSE;
1654
1655 WINPR_ASSERT(reauthContext);
1656 const uint64_t val = Stream_Get_UINT64(s); /* TunnelContext (8 bytes) */
1657 if (pkg->isMsgPresent != 0)
1658 *reauthContext = val;
1659 return TRUE;
1660 }
1661
1662 default:
1663 WLog_Print(log, WLOG_ERROR, "Unexpected Message Type: 0x%" PRIx32 "", pkg->msgType);
1664 return FALSE;
1665 }
1666}
1667
1668WINPR_ATTR_NODISCARD
1669static BOOL tsg_ndr_read_caps_response(wLog* log, rdpContext* context, wStream* s, UINT32* index,
1670 UINT32 PacketPtr, TSG_PACKET_CAPS_RESPONSE* caps,
1671 CONTEXT_HANDLE* tunnelContext, UINT32* tunnelId,
1672 uint64_t* reauthContext)
1673{
1674 UINT32 PacketQuarResponsePtr = 0;
1675
1676 WINPR_ASSERT(context);
1677 WINPR_ASSERT(index);
1678 WINPR_ASSERT(caps);
1679 WINPR_ASSERT(reauthContext);
1680
1681 if (!tsg_ndr_pointer_read(log, s, index, &PacketQuarResponsePtr, TRUE))
1682 goto fail;
1683
1684 if (!tsg_ndr_read_quarenc_response(log, s, index, &caps->pktQuarEncResponse))
1685 goto fail;
1686
1687 if (PacketPtr)
1688 {
1689 TSG_PACKET_MSG_RESPONSE pkg = WINPR_C_ARRAY_INIT;
1690 UINT32 MsgPtr = 0;
1691
1692 if (!tsg_ndr_read_TSG_PACKET_MSG_RESPONSE_header(log, s, &pkg))
1693 goto fail;
1694
1695 if (!tsg_ndr_pointer_read(log, s, index, &MsgPtr, TRUE))
1696 return FALSE;
1697
1698 if (!tsg_ndr_read_quarenc_data(log, s, index, &caps->pktQuarEncResponse))
1699 goto fail;
1700
1701 if (!tsg_ndr_read_TSG_PACKET_MSG_RESPONSE(log, context, s, index, MsgPtr, &pkg,
1702 reauthContext))
1703 goto fail;
1704 }
1705
1706 return tsg_ndr_read_tunnel_context(log, s, tunnelContext, tunnelId);
1707fail:
1708 return FALSE;
1709}
1710
1711WINPR_ATTR_NODISCARD
1712static BOOL TsProxyCreateTunnelReadResponse(rdpTsg* tsg, const RPC_PDU* pdu,
1713 CONTEXT_HANDLE* tunnelContext, UINT32* tunnelId)
1714{
1715 BOOL rc = FALSE;
1716 UINT32 index = 0;
1717 TSG_PACKET packet = WINPR_C_ARRAY_INIT;
1718 UINT32 SwitchValue = 0;
1719 rdpContext* context = nullptr;
1720 UINT32 PacketPtr = 0;
1721
1722 WINPR_ASSERT(tsg);
1723 WINPR_ASSERT(tsg->rpc);
1724 WINPR_ASSERT(tsg->rpc->transport);
1725
1726 context = transport_get_context(tsg->rpc->transport);
1727 WINPR_ASSERT(context);
1728
1729 if (!pdu)
1730 return FALSE;
1731
1732 if (!tsg_ndr_pointer_read(tsg->log, pdu->s, &index, &PacketPtr, TRUE))
1733 goto fail;
1734
1735 if (!Stream_CheckAndLogRequiredLengthWLog(tsg->log, pdu->s, 8))
1736 goto fail;
1737 Stream_Read_UINT32(pdu->s, packet.packetId); /* PacketId (4 bytes) */
1738 Stream_Read_UINT32(pdu->s, SwitchValue); /* SwitchValue (4 bytes) */
1739
1740 WLog_Print(tsg->log, WLOG_DEBUG, "%s", tsg_packet_id_to_string(packet.packetId));
1741
1742 if ((packet.packetId == TSG_PACKET_TYPE_CAPS_RESPONSE) &&
1743 (SwitchValue == TSG_PACKET_TYPE_CAPS_RESPONSE))
1744 {
1745 if (!tsg_ndr_read_caps_response(tsg->log, context, pdu->s, &index, PacketPtr,
1746 &packet.tsgPacket.packetCapsResponse, tunnelContext,
1747 tunnelId, &tsg->ReauthTunnelContext))
1748 goto fail;
1749 tsg->CapsResponse = packet.tsgPacket.packetCapsResponse.pktQuarEncResponse;
1750 }
1751 else if ((packet.packetId == TSG_PACKET_TYPE_QUARENC_RESPONSE) &&
1752 (SwitchValue == TSG_PACKET_TYPE_QUARENC_RESPONSE))
1753 {
1754 UINT32 PacketQuarResponsePtr = 0;
1755
1756 if (!tsg_ndr_pointer_read(tsg->log, pdu->s, &index, &PacketQuarResponsePtr, TRUE))
1757 goto fail;
1758
1759 if (!tsg_ndr_read_quarenc_response(tsg->log, pdu->s, &index,
1760 &packet.tsgPacket.packetQuarEncResponse))
1761 goto fail;
1762
1763 if (!tsg_ndr_read_quarenc_data(tsg->log, pdu->s, &index,
1764 &packet.tsgPacket.packetQuarEncResponse))
1765 goto fail;
1766
1767 if (!tsg_ndr_read_tunnel_context(tsg->log, pdu->s, tunnelContext, tunnelId))
1768 goto fail;
1769
1770 tsg->CapsResponse = packet.tsgPacket.packetQuarEncResponse;
1771 }
1772 else
1773 {
1774 WLog_Print(tsg->log, WLOG_ERROR,
1775 "Unexpected PacketId: 0x%08" PRIX32 ", Expected TSG_PACKET_TYPE_CAPS_RESPONSE "
1776 "or TSG_PACKET_TYPE_QUARENC_RESPONSE",
1777 packet.packetId);
1778 goto fail;
1779 }
1780
1781 {
1782 const size_t rem = Stream_GetRemainingLength(pdu->s);
1783 if (rem != 0)
1784 {
1785 WLog_Print(tsg->log, WLOG_WARN, "Partially parsed %s, %" PRIuz " bytes remain",
1786 tsg_packet_id_to_string(packet.packetId), rem);
1787 }
1788 }
1789
1790 rc = TRUE;
1791fail:
1792 return rc;
1793}
1794
1805WINPR_ATTR_NODISCARD
1806static BOOL TsProxyAuthorizeTunnelWriteRequest(rdpTsg* tsg, CONTEXT_HANDLE* tunnelContext)
1807{
1808 if (!tsg || !tsg->rpc || !tunnelContext)
1809 return FALSE;
1810
1811 rdpRpc* rpc = tsg->rpc;
1812
1813 WLog_Print(tsg->log, WLOG_DEBUG, "TsProxyAuthorizeTunnelWriteRequest");
1814 wStream* s = Stream_New(nullptr, 1024 + sizeof(WCHAR) * tsg->QuarreQuest.nameLength +
1815 tsg->QuarreQuest.dataLen);
1816
1817 if (!s)
1818 return FALSE;
1819
1820 if (!TsProxyWriteTunnelContext(tsg->log, s, tunnelContext))
1821 {
1822 Stream_Free(s, TRUE);
1823 return FALSE;
1824 }
1825
1826 /* 4-byte alignment */
1827 UINT32 index = 0;
1828 Stream_Write_UINT32(s, TSG_PACKET_TYPE_QUARREQUEST); /* PacketId (4 bytes) */
1829 Stream_Write_UINT32(s, TSG_PACKET_TYPE_QUARREQUEST); /* SwitchValue (4 bytes) */
1830 if (!tsg_ndr_pointer_write(tsg->log, s, &index, 1)) /* PacketQuarRequestPtr (4 bytes) */
1831 goto fail;
1832 Stream_Write_UINT32(s, tsg->QuarreQuest.flags); /* Flags (4 bytes) */
1833 if (!tsg_ndr_pointer_write(tsg->log, s, &index, 1)) /* MachineNamePtr (4 bytes) */
1834 goto fail;
1835 Stream_Write_UINT32(s, tsg->QuarreQuest.nameLength); /* NameLength (4 bytes) */
1836 if (!tsg_ndr_pointer_write(tsg->log, s, &index, 1)) /* DataPtr (4 bytes) */
1837 goto fail;
1838 Stream_Write_UINT32(s, tsg->QuarreQuest.dataLen); /* DataLength (4 bytes) */
1839 /* MachineName */
1840 if (!tsg_ndr_write_string(tsg->log, s, tsg->QuarreQuest.machineName,
1841 tsg->QuarreQuest.nameLength))
1842 goto fail;
1843 /* data */
1844 if (!tsg_ndr_write_conformant_array(tsg->log, s, tsg->QuarreQuest.data,
1845 tsg->QuarreQuest.dataLen))
1846 goto fail;
1847
1848 Stream_SealLength(s);
1849 return rpc_client_write_call(rpc, s, TsProxyAuthorizeTunnelOpnum);
1850fail:
1851 Stream_Free(s, TRUE);
1852 return FALSE;
1853}
1854
1855WINPR_ATTR_NODISCARD
1856static UINT32 tsg_redir_to_flags(const TSG_REDIRECTION_FLAGS* redirect)
1857{
1858 UINT32 flags = 0;
1859 if (redirect->enableAllRedirections)
1860 flags |= HTTP_TUNNEL_REDIR_ENABLE_ALL;
1861 if (redirect->disableAllRedirections)
1862 flags |= HTTP_TUNNEL_REDIR_DISABLE_ALL;
1863
1864 if (redirect->driveRedirectionDisabled)
1865 flags |= HTTP_TUNNEL_REDIR_DISABLE_DRIVE;
1866 if (redirect->printerRedirectionDisabled)
1867 flags |= HTTP_TUNNEL_REDIR_DISABLE_PRINTER;
1868 if (redirect->portRedirectionDisabled)
1869 flags |= HTTP_TUNNEL_REDIR_DISABLE_PORT;
1870 if (redirect->clipboardRedirectionDisabled)
1871 flags |= HTTP_TUNNEL_REDIR_DISABLE_CLIPBOARD;
1872 if (redirect->pnpRedirectionDisabled)
1873 flags |= HTTP_TUNNEL_REDIR_DISABLE_PNP;
1874 return flags;
1875}
1876
1877WINPR_ATTR_NODISCARD
1878static BOOL tsg_redirect_apply(rdpTsg* tsg, const TSG_REDIRECTION_FLAGS* redirect)
1879{
1880 WINPR_ASSERT(tsg);
1881 WINPR_ASSERT(redirect);
1882
1883 rdpTransport* transport = tsg->transport;
1884 WINPR_ASSERT(transport);
1885
1886 rdpContext* context = transport_get_context(transport);
1887 UINT32 redirFlags = tsg_redir_to_flags(redirect);
1888 return utils_apply_gateway_policy(tsg->log, context, redirFlags, "TSG");
1889}
1890
1891WINPR_ATTR_NODISCARD
1892static BOOL tsg_ndr_read_timeout(wLog* log, wStream* s, size_t tlen)
1893{
1894 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(log, s, 1, sizeof(UINT32)))
1895 return FALSE;
1896
1897 if (tlen < sizeof(UINT32))
1898 {
1899 WLog_Print(log, WLOG_ERROR, "[IDLE_TIMEOUT] array element length %" PRIuz ", expected 4",
1900 tlen);
1901 return FALSE;
1902 }
1903
1904 const UINT32 idleTimeout = Stream_Get_UINT32(s);
1905 WLog_Print(log, WLOG_DEBUG, "[IDLE_TIMEOUT] idleTimeout=%" PRIu32 ": TODO: unused",
1906 idleTimeout);
1907 return TRUE;
1908}
1909
1910WINPR_ATTR_NODISCARD
1911static BOOL tsg_ndr_read_sohr(wLog* log, wStream* s, BOOL expected)
1912{
1913 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(log, s, 1, sizeof(UINT32)))
1914 return FALSE;
1915
1916 const UINT32 len = Stream_Get_UINT32(s);
1917 if (!expected)
1918 {
1919 if (len != 0)
1920 {
1921 WLog_Print(log, WLOG_DEBUG, "[SOH] len=%" PRIu32 ": skipping", len);
1922 return FALSE;
1923 }
1924 return TRUE;
1925 }
1926 else if (len == 0)
1927 {
1928 WLog_Print(log, WLOG_WARN, "[SOH] len=%" PRIu32 ": expected length > 0", len);
1929 }
1930
1931 WLog_Print(log, WLOG_DEBUG, "[SOH] len=%" PRIu32 ": TODO: unused", len);
1932 if (!Stream_SafeSeek(s, len))
1933 return FALSE;
1934
1935 winpr_HexLogDump(log, WLOG_DEBUG, Stream_Pointer(s), len);
1936 return TRUE;
1937}
1938
1939WINPR_ATTR_NODISCARD
1940static BOOL tsg_ndr_read_packet_response_data(rdpTsg* tsg, wStream* s,
1941 const TSG_PACKET_RESPONSE* response)
1942{
1943 WINPR_ASSERT(tsg);
1944
1945 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(tsg->log, s, 1, 4))
1946 return FALSE;
1947
1948 const uint32_t arrayMaxLen = Stream_Get_UINT32(s);
1949 const size_t rem = Stream_GetRemainingLength(s);
1950 if (arrayMaxLen != response->responseDataLen)
1951 {
1952 WLog_Print(tsg->log, WLOG_ERROR,
1953 "2.2.9.2.1.5 TSG_PACKET_RESPONSE::responseDataLen=%" PRIu32
1954 " != NDR array len %" PRIu32,
1955 response->responseDataLen, arrayMaxLen);
1956 }
1957 if (response->responseDataLen > 0)
1958 {
1959 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(tsg->log, s, 1, 4))
1960 return FALSE;
1961
1962 if (tsg->CapsResponse.versionCaps.tsgCaps.capabilityType != TSG_CAPABILITY_TYPE_NAP)
1963 {
1964 WLog_Print(
1965 tsg->log, WLOG_ERROR,
1966 "2.2.9.2.1.5 TSG_PACKET_RESPONSE Negotiated Capabilities type is 0x%08" PRIx32
1967 ", expected TSG_CAPABILITY_TYPE_NAP[0x00000001]",
1968 tsg->CapsResponse.versionCaps.tsgCaps.capabilityType);
1969 return FALSE;
1970 }
1971 const UINT32 mask = (TSG_NAP_CAPABILITY_QUAR_SOH | TSG_NAP_CAPABILITY_IDLE_TIMEOUT);
1972 const UINT32 val =
1973 (tsg->CapsResponse.versionCaps.tsgCaps.tsgPacket.tsgCapNap.capabilities & mask);
1974 if ((val == mask) && (tsg->QuarreQuest.dataLen > 0))
1975 {
1976 if (!tsg_ndr_read_timeout(tsg->log, s, arrayMaxLen))
1977 return FALSE;
1978 if (!tsg_ndr_read_sohr(tsg->log, s, TRUE))
1979 return FALSE;
1980 }
1981 else if ((val == TSG_NAP_CAPABILITY_QUAR_SOH) && (tsg->QuarreQuest.dataLen > 0))
1982 {
1983 if (!tsg_ndr_read_sohr(tsg->log, s, TRUE))
1984 return FALSE;
1985 }
1986 else if ((val & TSG_NAP_CAPABILITY_IDLE_TIMEOUT) != 0)
1987 {
1988 if (!tsg_ndr_read_timeout(tsg->log, s, arrayMaxLen))
1989 return FALSE;
1990 if (!tsg_ndr_read_sohr(tsg->log, s, FALSE))
1991 return FALSE;
1992 }
1993 else
1994 {
1995 WLog_Print(
1996 tsg->log, WLOG_ERROR,
1997 "2.2.9.2.1.5 TSG_PACKET_RESPONSE::responseDataLen=%" PRIu32
1998 ", but neither TSG_NAP_CAPABILITY_QUAR_SOH nor "
1999 "TSG_NAP_CAPABILITY_IDLE_TIMEOUT are set, so expecting 0 (actually got %" PRIuz ")",
2000 response->responseDataLen, rem);
2001 return FALSE;
2002 }
2003 }
2004 else if (rem > 0)
2005 {
2006 char buffer[256] = WINPR_C_ARRAY_INIT;
2007 WLog_Print(tsg->log, WLOG_WARN,
2008 "2.2.9.2.1.5 TSG_PACKET_RESPONSE::responseDataLen=%" PRIu32
2009 ", but actually got %" PRIuz " [flags=%s], ignoring.",
2010 response->responseDataLen, rem,
2011 tsg_caps_to_string(
2012 tsg->CapsResponse.versionCaps.tsgCaps.tsgPacket.tsgCapNap.capabilities,
2013 buffer, sizeof(buffer)));
2014 if (!Stream_SafeSeek(s, rem))
2015 return FALSE;
2016 }
2017
2018 {
2019 const size_t trem = Stream_GetRemainingLength(s);
2020 if (trem > 0)
2021 {
2022 WLog_Print(tsg->log, WLOG_WARN,
2023 "2.2.9.2.1.5 TSG_PACKET_RESPONSE %" PRIuz " unhandled bytes remain", trem);
2024 }
2025 }
2026 return TRUE;
2027}
2028
2029WINPR_ATTR_NODISCARD
2030static BOOL TsProxyAuthorizeTunnelReadResponse(rdpTsg* tsg, const RPC_PDU* pdu)
2031{
2032 BOOL rc = FALSE;
2033 UINT32 SwitchValue = 0;
2034 UINT32 index = 0;
2035 TSG_PACKET packet = WINPR_C_ARRAY_INIT;
2036 UINT32 PacketPtr = 0;
2037 UINT32 PacketResponseDataPtr = 0;
2038
2039 WINPR_ASSERT(tsg);
2040 WINPR_ASSERT(pdu);
2041
2042 wLog* log = tsg->log;
2043 WINPR_ASSERT(log);
2044
2045 if (!tsg_ndr_pointer_read(log, pdu->s, &index, &PacketPtr, TRUE))
2046 goto fail;
2047
2048 if (!Stream_CheckAndLogRequiredLengthWLog(log, pdu->s, 8))
2049 goto fail;
2050 Stream_Read_UINT32(pdu->s, packet.packetId); /* PacketId (4 bytes) */
2051 Stream_Read_UINT32(pdu->s, SwitchValue); /* SwitchValue (4 bytes) */
2052
2053 WLog_Print(log, WLOG_DEBUG, "%s", tsg_packet_id_to_string(packet.packetId));
2054
2055 if (packet.packetId == E_PROXY_NAP_ACCESSDENIED)
2056 {
2057 WLog_Print(log, WLOG_ERROR, "status: E_PROXY_NAP_ACCESSDENIED (0x%08X)",
2058 E_PROXY_NAP_ACCESSDENIED);
2059 WLog_Print(log, WLOG_ERROR,
2060 "Ensure that the Gateway Connection Authorization Policy is correct");
2061 goto fail;
2062 }
2063
2064 if ((packet.packetId != TSG_PACKET_TYPE_RESPONSE) || (SwitchValue != TSG_PACKET_TYPE_RESPONSE))
2065 {
2066 WLog_Print(log, WLOG_ERROR,
2067 "Unexpected PacketId: 0x%08" PRIX32 ", Expected TSG_PACKET_TYPE_RESPONSE",
2068 packet.packetId);
2069 goto fail;
2070 }
2071
2072 if (!tsg_ndr_pointer_read(log, pdu->s, &index, nullptr, TRUE))
2073 goto fail;
2074
2075 if (!Stream_CheckAndLogRequiredLengthWLog(log, pdu->s, 8))
2076 goto fail;
2077
2078 packet.tsgPacket.packetResponse.flags = Stream_Get_UINT32(pdu->s);
2079 if (packet.tsgPacket.packetResponse.flags != TSG_PACKET_TYPE_QUARREQUEST)
2080 {
2081 WLog_Print(log, WLOG_ERROR,
2082 "Unexpected Packet Response flags: 0x%08" PRIX32
2083 ", Expected TSG_PACKET_TYPE_QUARREQUEST",
2084 packet.tsgPacket.packetResponse.flags);
2085 goto fail;
2086 }
2087
2088 packet.tsgPacket.packetResponse.reserved = Stream_Get_UINT32(pdu->s);
2089
2090 packet.tsgPacket.packetResponse.responseData = nullptr;
2091 if (!tsg_ndr_pointer_read(log, pdu->s, &index, &PacketResponseDataPtr, FALSE))
2092 goto fail;
2093
2094 if (!Stream_CheckAndLogRequiredLengthWLog(log, pdu->s, 4))
2095 goto fail;
2096
2097 packet.tsgPacket.packetResponse.responseDataLen = Stream_Get_UINT32(pdu->s);
2098 if (packet.tsgPacket.packetResponse.responseDataLen > 24000)
2099 {
2100 WLog_Print(log, WLOG_ERROR,
2101 "2.2.9.2.1.5 TSG_PACKET_RESPONSE::responseDataLen %" PRIu32 " > maximum(24000)",
2102 packet.tsgPacket.packetResponse.responseDataLen);
2103 goto fail;
2104 }
2105 if ((PacketResponseDataPtr == 0) && (packet.tsgPacket.packetResponse.responseDataLen != 0))
2106 {
2107 WLog_Print(log, WLOG_ERROR,
2108 "2.2.9.2.1.5 TSG_PACKET_RESPONSE::responseDataLen %" PRIu32
2109 " but responseData = nullptr",
2110 packet.tsgPacket.packetResponse.responseDataLen);
2111 goto fail;
2112 }
2113
2114 if (!tsg_ndr_read_packet_redirection_flags(log, pdu->s,
2115 &packet.tsgPacket.packetResponse.redirectionFlags))
2116 goto fail;
2117
2118 packet.tsgPacket.packetResponse.responseData = Stream_Pointer(pdu->s);
2119 if (!tsg_ndr_read_packet_response_data(tsg, pdu->s, &packet.tsgPacket.packetResponse))
2120 goto fail;
2121
2122 rc = tsg_redirect_apply(tsg, &packet.tsgPacket.packetResponse.redirectionFlags);
2123
2124fail:
2125 return rc;
2126}
2127
2139WINPR_ATTR_NODISCARD
2140static BOOL TsProxyMakeTunnelCallWriteRequest(rdpTsg* tsg, CONTEXT_HANDLE* tunnelContext,
2141 UINT32 procId)
2142{
2143 wStream* s = nullptr;
2144 rdpRpc* rpc = nullptr;
2145
2146 if (!tsg || !tsg->rpc || !tunnelContext)
2147 return FALSE;
2148
2149 rpc = tsg->rpc;
2150 WLog_Print(tsg->log, WLOG_DEBUG, "TsProxyMakeTunnelCallWriteRequest");
2151 s = Stream_New(nullptr, 40);
2152
2153 if (!s)
2154 return FALSE;
2155
2156 /* TunnelContext (20 bytes) */
2157 UINT32 index = 0;
2158 if (!TsProxyWriteTunnelContext(tsg->log, s, tunnelContext))
2159 goto fail;
2160 Stream_Write_UINT32(s, procId); /* ProcId (4 bytes) */
2161 /* 4-byte alignment */
2162 Stream_Write_UINT32(s, TSG_PACKET_TYPE_MSGREQUEST_PACKET); /* PacketId (4 bytes) */
2163 Stream_Write_UINT32(s, TSG_PACKET_TYPE_MSGREQUEST_PACKET); /* SwitchValue (4 bytes) */
2164 if (!tsg_ndr_pointer_write(tsg->log, s, &index, 1)) /* PacketMsgRequestPtr (4 bytes) */
2165 goto fail;
2166 Stream_Write_UINT32(s, 0x00000001); /* MaxMessagesPerBatch (4 bytes) */
2167 return rpc_client_write_call(rpc, s, TsProxyMakeTunnelCallOpnum);
2168fail:
2169 Stream_Free(s, TRUE);
2170 return FALSE;
2171}
2172
2173WINPR_ATTR_NODISCARD
2174static BOOL TsProxyReadPacketSTringMessage(wLog* log, wStream* s, uint32_t* index,
2175 TSG_PACKET_STRING_MESSAGE* msg)
2176{
2177 UINT32 MsgPtr = 0;
2178
2179 WINPR_ASSERT(msg);
2180
2181 const TSG_PACKET_STRING_MESSAGE empty = WINPR_C_ARRAY_INIT;
2182 *msg = empty;
2183
2184 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 12))
2185 return FALSE;
2186
2187 Stream_Read_INT32(s, msg->isDisplayMandatory); /* IsDisplayMandatory (4 bytes) */
2188 Stream_Read_INT32(s, msg->isConsentMandatory); /* IsConsentMandatory (4 bytes) */
2189 Stream_Read_UINT32(s, msg->msgBytes); /* MsgBytes (4 bytes) */
2190
2191 if (!tsg_ndr_pointer_read(log, s, index, &MsgPtr, msg->msgBytes != 0))
2192 return FALSE;
2193
2194 if (msg->msgBytes > TSG_MESSAGING_MAX_MESSAGE_LENGTH)
2195 {
2196 WLog_Print(log, WLOG_ERROR, "Out of Spec Message Length %" PRIu32 "", msg->msgBytes);
2197 return FALSE;
2198 }
2199
2200 if (msg->msgBytes == 0)
2201 {
2202 WLog_Print(log, WLOG_DEBUG, "Empty message, skipping string read");
2203 return TRUE;
2204 }
2205
2206 return tsg_ndr_read_string(log, s, &msg->msgBuffer, &msg->msgBytes);
2207}
2208
2209WINPR_ATTR_NODISCARD
2210static BOOL TsProxyMakeTunnelCallReadResponse(rdpTsg* tsg, const RPC_PDU* pdu)
2211{
2212 BOOL rc = FALSE;
2213 UINT32 index = 0;
2214 TSG_PACKET packet = WINPR_C_ARRAY_INIT;
2215 rdpContext* context = nullptr;
2216 TSG_PACKET_MSG_RESPONSE packetMsgResponse = WINPR_C_ARRAY_INIT;
2217 UINT32 PacketPtr = 0;
2218 UINT32 PacketMsgResponsePtr = 0;
2219
2220 WINPR_ASSERT(tsg);
2221 WINPR_ASSERT(tsg->rpc);
2222
2223 context = transport_get_context(tsg->rpc->transport);
2224 WINPR_ASSERT(context);
2225
2226 /* This is an asynchronous response */
2227
2228 if (!pdu)
2229 return FALSE;
2230
2231 if (!Stream_CheckAndLogRequiredLengthWLog(tsg->log, pdu->s, 28))
2232 goto fail;
2233
2234 if (!tsg_ndr_pointer_read(tsg->log, pdu->s, &index, &PacketPtr, TRUE))
2235 goto fail;
2236
2237 Stream_Read_UINT32(pdu->s, packet.packetId); /* PacketId (4 bytes) */
2238
2239 {
2240 const uint32_t SwitchValue = Stream_Get_UINT32(pdu->s); /* SwitchValue (4 bytes) */
2241 WLog_Print(tsg->log, WLOG_DEBUG, "%s", tsg_packet_id_to_string(packet.packetId));
2242
2243 if ((packet.packetId != TSG_PACKET_TYPE_MESSAGE_PACKET) || (packet.packetId != SwitchValue))
2244 {
2245 WLog_Print(tsg->log, WLOG_ERROR,
2246 "Unexpected PacketId: 0x%08" PRIX32
2247 ", Expected TSG_PACKET_TYPE_MESSAGE_PACKET",
2248 packet.packetId);
2249 goto fail;
2250 }
2251 }
2252
2253 if (!tsg_ndr_pointer_read(tsg->log, pdu->s, &index, &PacketMsgResponsePtr, TRUE))
2254 goto fail;
2255
2256 if (!tsg_ndr_read_TSG_PACKET_MSG_RESPONSE_header(tsg->log, pdu->s, &packetMsgResponse))
2257 goto fail;
2258
2259 {
2260 UINT32 MessagePtr = 0;
2261 if (!tsg_ndr_pointer_read(tsg->log, pdu->s, &index, &MessagePtr, TRUE))
2262 goto fail;
2263
2264 if (!tsg_ndr_read_TSG_PACKET_MSG_RESPONSE(tsg->log, context, pdu->s, &index, MessagePtr,
2265 &packetMsgResponse, &tsg->ReauthTunnelContext))
2266 goto fail;
2267 }
2268
2269 rc = TRUE;
2270fail:
2271 return rc;
2272}
2273
2284WINPR_ATTR_NODISCARD
2285static BOOL TsProxyCreateChannelWriteRequest(rdpTsg* tsg, CONTEXT_HANDLE* tunnelContext)
2286{
2287 WINPR_ASSERT(tsg);
2288 WINPR_ASSERT(tunnelContext);
2289
2290 WLog_Print(tsg->log, WLOG_DEBUG, "TsProxyCreateChannelWriteRequest");
2291
2292 if (!tsg->rpc || !tsg->Hostname)
2293 return FALSE;
2294
2295 rdpRpc* rpc = tsg->rpc;
2296 const size_t count = _wcslen(tsg->Hostname) + 1;
2297 if (count > UINT32_MAX)
2298 return FALSE;
2299
2300 wStream* s = Stream_New(nullptr, 60 + count * 2);
2301 if (!s)
2302 return FALSE;
2303
2304 /* TunnelContext (20 bytes) */
2305 if (!TsProxyWriteTunnelContext(tsg->log, s, tunnelContext))
2306 goto fail;
2307
2308 /* TSENDPOINTINFO */
2309 {
2310 UINT32 index = 0;
2311 if (!tsg_ndr_pointer_write(tsg->log, s, &index, 1))
2312 goto fail;
2313 Stream_Write_UINT32(s, 0x00000001); /* NumResourceNames (4 bytes) */
2314 if (!tsg_ndr_pointer_write(tsg->log, s, &index, 0))
2315 goto fail;
2316 }
2317
2318 Stream_Write_UINT16(s, 0x0000); /* NumAlternateResourceNames (2 bytes) */
2319 Stream_Write_UINT16(s, 0x0000); /* Pad (2 bytes) */
2320 /* Port (4 bytes) */
2321 Stream_Write_UINT16(s, 0x0003); /* ProtocolId (RDP = 3) (2 bytes) */
2322 Stream_Write_UINT16(s, tsg->Port); /* PortNumber (0xD3D = 3389) (2 bytes) */
2323 Stream_Write_UINT32(s, 0x00000001); /* NumResourceNames (4 bytes) */
2324 {
2325 UINT32 index = 0;
2326 if (!tsg_ndr_pointer_write(tsg->log, s, &index, 1))
2327 goto fail;
2328 }
2329 if (!tsg_ndr_write_string(tsg->log, s, tsg->Hostname, count))
2330 goto fail;
2331 return rpc_client_write_call(rpc, s, TsProxyCreateChannelOpnum);
2332
2333fail:
2334 Stream_Free(s, TRUE);
2335 return FALSE;
2336}
2337
2338WINPR_ATTR_NODISCARD
2339static BOOL TsProxyCreateChannelReadResponse(wLog* log, const RPC_PDU* pdu,
2340 CONTEXT_HANDLE* channelContext, UINT32* channelId)
2341{
2342 BOOL rc = FALSE;
2343
2344 WINPR_ASSERT(log);
2345 WINPR_ASSERT(pdu);
2346 WINPR_ASSERT(channelId);
2347
2348 WLog_Print(log, WLOG_DEBUG, "TsProxyCreateChannelReadResponse");
2349
2350 if (!Stream_CheckAndLogRequiredLengthWLog(log, pdu->s, 28))
2351 goto fail;
2352
2353 /* ChannelContext (20 bytes) */
2354 if (!TsProxyReadTunnelContext(log, pdu->s, channelContext))
2355 goto fail;
2356 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(log, pdu->s, 2, sizeof(UINT32)))
2357 goto fail;
2358 Stream_Read_UINT32(pdu->s, *channelId); /* ChannelId (4 bytes) */
2359 Stream_Seek_UINT32(pdu->s); /* ReturnValue (4 bytes) */
2360 rc = TRUE;
2361fail:
2362 return rc;
2363}
2364
2370WINPR_ATTR_NODISCARD
2371static BOOL TsProxyCloseChannelWriteRequest(rdpTsg* tsg, CONTEXT_HANDLE* context)
2372{
2373 WINPR_ASSERT(tsg);
2374 WINPR_ASSERT(context);
2375
2376 WLog_Print(tsg->log, WLOG_DEBUG, "TsProxyCloseChannelWriteRequest");
2377
2378 rdpRpc* rpc = tsg->rpc;
2379 WINPR_ASSERT(rpc);
2380
2381 wStream* s = Stream_New(nullptr, 20);
2382
2383 if (!s)
2384 return FALSE;
2385
2386 /* ChannelContext (20 bytes) */
2387 if (!TsProxyWriteTunnelContext(tsg->log, s, context))
2388 goto fail;
2389 return rpc_client_write_call(rpc, s, TsProxyCloseChannelOpnum);
2390fail:
2391 Stream_Free(s, TRUE);
2392 return FALSE;
2393}
2394
2395WINPR_ATTR_NODISCARD
2396static BOOL TsProxyCloseChannelReadResponse(wLog* log, const RPC_PDU* pdu, CONTEXT_HANDLE* context)
2397{
2398 BOOL rc = FALSE;
2399 WLog_Print(log, WLOG_DEBUG, "TsProxyCloseChannelReadResponse");
2400
2401 if (!pdu)
2402 return FALSE;
2403
2404 if (!Stream_CheckAndLogRequiredLengthWLog(log, pdu->s, 24))
2405 goto fail;
2406
2407 /* ChannelContext (20 bytes) */
2408 if (!TsProxyReadTunnelContext(log, pdu->s, context))
2409 goto fail;
2410
2411 {
2412 const size_t len = sizeof(UINT32);
2413 if (!Stream_CheckAndLogRequiredLengthWLog(log, pdu->s, len))
2414 goto fail;
2415 Stream_Seek(pdu->s, len); /* ReturnValue (4 bytes) */
2416 rc = TRUE;
2417 }
2418fail:
2419 return rc;
2420}
2421
2427WINPR_ATTR_NODISCARD
2428static BOOL TsProxyCloseTunnelWriteRequest(rdpTsg* tsg, const CONTEXT_HANDLE* context)
2429{
2430 WINPR_ASSERT(tsg);
2431 WINPR_ASSERT(context);
2432
2433 WLog_Print(tsg->log, WLOG_DEBUG, "TsProxyCloseTunnelWriteRequest");
2434
2435 rdpRpc* rpc = tsg->rpc;
2436 WINPR_ASSERT(rpc);
2437
2438 wStream* s = Stream_New(nullptr, 20);
2439
2440 if (!s)
2441 return FALSE;
2442
2443 /* TunnelContext (20 bytes) */
2444 if (!TsProxyWriteTunnelContext(tsg->log, s, context))
2445 goto fail;
2446 return rpc_client_write_call(rpc, s, TsProxyCloseTunnelOpnum);
2447fail:
2448 Stream_Free(s, TRUE);
2449 return FALSE;
2450}
2451
2452WINPR_ATTR_NODISCARD
2453static BOOL TsProxyCloseTunnelReadResponse(wLog* log, const RPC_PDU* pdu, CONTEXT_HANDLE* context)
2454{
2455 BOOL rc = FALSE;
2456
2457 WINPR_ASSERT(log);
2458 WINPR_ASSERT(pdu);
2459 WINPR_ASSERT(context);
2460
2461 WLog_Print(log, WLOG_DEBUG, "TsProxyCloseTunnelReadResponse");
2462
2463 if (!Stream_CheckAndLogRequiredLengthWLog(log, pdu->s, 24))
2464 goto fail;
2465
2466 /* TunnelContext (20 bytes) */
2467 if (!TsProxyReadTunnelContext(log, pdu->s, context))
2468 goto fail;
2469 {
2470 const size_t len = sizeof(UINT32);
2471 if (!Stream_CheckAndLogRequiredLengthWLog(log, pdu->s, len))
2472 goto fail;
2473 Stream_Seek(pdu->s, len); /* ReturnValue (4 bytes) */
2474 rc = TRUE;
2475 }
2476fail:
2477 return rc;
2478}
2479
2487WINPR_ATTR_NODISCARD
2488static BOOL TsProxySetupReceivePipeWriteRequest(rdpTsg* tsg, const CONTEXT_HANDLE* channelContext)
2489{
2490 wStream* s = nullptr;
2491 rdpRpc* rpc = nullptr;
2492 WLog_Print(tsg->log, WLOG_DEBUG, "TsProxySetupReceivePipeWriteRequest");
2493
2494 WINPR_ASSERT(tsg);
2495 WINPR_ASSERT(tsg->rpc);
2496
2497 if (!channelContext)
2498 return FALSE;
2499
2500 rpc = tsg->rpc;
2501 s = Stream_New(nullptr, 20);
2502
2503 if (!s)
2504 return FALSE;
2505
2506 /* ChannelContext (20 bytes) */
2507 if (!TsProxyWriteTunnelContext(tsg->log, s, channelContext))
2508 goto fail;
2509 return rpc_client_write_call(rpc, s, TsProxySetupReceivePipeOpnum);
2510fail:
2511 Stream_Free(s, TRUE);
2512 return FALSE;
2513}
2514
2515WINPR_ATTR_NODISCARD
2516static BOOL tsg_transition_to_state(rdpTsg* tsg, TSG_STATE state)
2517{
2518 WINPR_ASSERT(tsg);
2519 const char* oldState = tsg_state_to_string(tsg->state);
2520 const char* newState = tsg_state_to_string(state);
2521
2522 WLog_Print(tsg->log, WLOG_DEBUG, "%s -> %s", oldState, newState);
2523 return tsg_set_state(tsg, state);
2524}
2525
2526WINPR_ATTR_NODISCARD
2527static BOOL tsg_initialize_version_caps(const rdpTsg* tsg,
2528 TSG_PACKET_VERSIONCAPS* packetVersionCaps)
2529{
2530 WINPR_ASSERT(tsg);
2531 WINPR_ASSERT(packetVersionCaps);
2532
2533 packetVersionCaps->tsgHeader.ComponentId = TS_GATEWAY_TRANSPORT;
2534 packetVersionCaps->tsgHeader.PacketId = TSG_PACKET_TYPE_VERSIONCAPS;
2535 packetVersionCaps->numCapabilities = 1;
2536 packetVersionCaps->majorVersion = 1;
2537 packetVersionCaps->minorVersion = 1;
2538 packetVersionCaps->quarantineCapabilities = 0;
2539 packetVersionCaps->tsgCaps.capabilityType = TSG_CAPABILITY_TYPE_NAP;
2540 /*
2541 * Using reduced capabilities appears to trigger
2542 * TSG_PACKET_TYPE_QUARENC_RESPONSE instead of TSG_PACKET_TYPE_CAPS_RESPONSE
2543 *
2544 * However, reduced capabilities may break connectivity with servers enforcing features,
2545 * such as "Only allow connections from Remote Desktop Services clients that support RD
2546 * Gateway messaging"
2547 */
2548
2549 packetVersionCaps->tsgCaps.tsgPacket.tsgCapNap.capabilities =
2550 TSG_NAP_CAPABILITY_IDLE_TIMEOUT | TSG_MESSAGING_CAP_CONSENT_SIGN |
2551 TSG_MESSAGING_CAP_SERVICE_MSG | TSG_MESSAGING_CAP_REAUTH;
2552 if (tsg->QuarreQuest.dataLen > 0)
2553 packetVersionCaps->tsgCaps.tsgPacket.tsgCapNap.capabilities |= TSG_NAP_CAPABILITY_QUAR_SOH;
2554
2555 return TRUE;
2556}
2557
2558static void resetCaps(rdpTsg* tsg)
2559{
2560 WINPR_ASSERT(tsg);
2561 const TSG_PACKET_QUARENC_RESPONSE empty = WINPR_C_ARRAY_INIT;
2562 tsg->CapsResponse = empty;
2563}
2564
2565BOOL tsg_proxy_begin(rdpTsg* tsg)
2566{
2567 TSG_PACKET tsgPacket = WINPR_C_ARRAY_INIT;
2568
2569 WINPR_ASSERT(tsg);
2570
2571 tsgPacket.packetId = TSG_PACKET_TYPE_VERSIONCAPS;
2572 if (!tsg_initialize_version_caps(tsg, &tsgPacket.tsgPacket.packetVersionCaps) ||
2573 !TsProxyCreateTunnelWriteRequest(tsg, &tsgPacket))
2574 {
2575 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyCreateTunnel failure");
2576 (void)tsg_transition_to_state(tsg, TSG_STATE_FINAL);
2577 return FALSE;
2578 }
2579
2580 resetCaps(tsg);
2581
2582 return tsg_transition_to_state(tsg, TSG_STATE_INITIAL);
2583}
2584
2585WINPR_ATTR_NODISCARD
2586static BOOL tsg_proxy_reauth(rdpTsg* tsg)
2587{
2588 TSG_PACKET tsgPacket = WINPR_C_ARRAY_INIT;
2589
2590 WINPR_ASSERT(tsg);
2591
2592 tsg->reauthSequence = TRUE;
2593 TSG_PACKET_REAUTH* packetReauth = &tsgPacket.tsgPacket.packetReauth;
2594
2595 tsgPacket.packetId = TSG_PACKET_TYPE_REAUTH;
2596 packetReauth->tunnelContext = tsg->ReauthTunnelContext;
2597 packetReauth->packetId = TSG_PACKET_TYPE_VERSIONCAPS;
2598
2599 if (!tsg_initialize_version_caps(tsg, &packetReauth->tsgInitialPacket.packetVersionCaps))
2600 return FALSE;
2601
2602 if (!TsProxyCreateTunnelWriteRequest(tsg, &tsgPacket))
2603 {
2604 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyCreateTunnel failure");
2605 (void)tsg_transition_to_state(tsg, TSG_STATE_FINAL);
2606 return FALSE;
2607 }
2608
2609 if (!TsProxyMakeTunnelCallWriteRequest(tsg, &tsg->TunnelContext,
2610 TSG_TUNNEL_CALL_ASYNC_MSG_REQUEST))
2611 {
2612 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyMakeTunnelCall failure");
2613 (void)tsg_transition_to_state(tsg, TSG_STATE_FINAL);
2614 return FALSE;
2615 }
2616
2617 resetCaps(tsg);
2618 return tsg_transition_to_state(tsg, TSG_STATE_INITIAL);
2619}
2620
2621BOOL tsg_recv_pdu(rdpTsg* tsg, const RPC_PDU* pdu)
2622{
2623 BOOL rc = FALSE;
2624 RpcClientCall* call = nullptr;
2625 rdpRpc* rpc = nullptr;
2626
2627 WINPR_ASSERT(tsg);
2628 WINPR_ASSERT(pdu);
2629 WINPR_ASSERT(tsg->rpc);
2630
2631 rpc = tsg->rpc;
2632
2633 if (!(pdu->Flags & RPC_PDU_FLAG_STUB))
2634 {
2635 const size_t len = 24;
2636 if (!Stream_CheckAndLogRequiredLengthWLog(tsg->log, pdu->s, len))
2637 return FALSE;
2638 Stream_Seek(pdu->s, len);
2639 }
2640
2641 const TSG_STATE oldState = tsg->state;
2642 switch (tsg->state)
2643 {
2644 case TSG_STATE_INITIAL:
2645 {
2646 CONTEXT_HANDLE* TunnelContext = nullptr;
2647 TunnelContext = (tsg->reauthSequence) ? &tsg->NewTunnelContext : &tsg->TunnelContext;
2648
2649 if (!TsProxyCreateTunnelReadResponse(tsg, pdu, TunnelContext, &tsg->TunnelId))
2650 {
2651 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyCreateTunnelReadResponse failure");
2652 return FALSE;
2653 }
2654
2655 if (!tsg_transition_to_state(tsg, TSG_STATE_CONNECTED))
2656 return FALSE;
2657
2658 if (!TsProxyAuthorizeTunnelWriteRequest(tsg, TunnelContext))
2659 {
2660 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyAuthorizeTunnel failure");
2661 return FALSE;
2662 }
2663
2664 rc = TRUE;
2665 }
2666 break;
2667
2668 case TSG_STATE_CONNECTED:
2669 {
2670 CONTEXT_HANDLE* TunnelContext =
2671 (tsg->reauthSequence) ? &tsg->NewTunnelContext : &tsg->TunnelContext;
2672
2673 if (!TsProxyAuthorizeTunnelReadResponse(tsg, pdu))
2674 {
2675 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyAuthorizeTunnelReadResponse failure");
2676 return FALSE;
2677 }
2678
2679 if (!tsg_transition_to_state(tsg, TSG_STATE_AUTHORIZED))
2680 return FALSE;
2681
2682 if (!tsg->reauthSequence)
2683 {
2684 if (!TsProxyMakeTunnelCallWriteRequest(tsg, TunnelContext,
2685 TSG_TUNNEL_CALL_ASYNC_MSG_REQUEST))
2686 {
2687 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyMakeTunnelCall failure");
2688 return FALSE;
2689 }
2690 }
2691
2692 if (!TsProxyCreateChannelWriteRequest(tsg, TunnelContext))
2693 {
2694 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyCreateChannel failure");
2695 return FALSE;
2696 }
2697
2698 rc = TRUE;
2699 }
2700 break;
2701
2702 case TSG_STATE_AUTHORIZED:
2703 call = rpc_client_call_find_by_id(rpc->client, pdu->CallId);
2704
2705 if (!call)
2706 return FALSE;
2707
2708 if (call->OpNum == TsProxyMakeTunnelCallOpnum)
2709 {
2710 if (!TsProxyMakeTunnelCallReadResponse(tsg, pdu))
2711 {
2712 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyMakeTunnelCallReadResponse failure");
2713 return FALSE;
2714 }
2715
2716 rc = TRUE;
2717 }
2718 else if (call->OpNum == TsProxyCreateChannelOpnum)
2719 {
2720 CONTEXT_HANDLE ChannelContext;
2721
2722 if (!TsProxyCreateChannelReadResponse(tsg->log, pdu, &ChannelContext,
2723 &tsg->ChannelId))
2724 {
2725 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyCreateChannelReadResponse failure");
2726 return FALSE;
2727 }
2728
2729 if (!tsg->reauthSequence)
2730 CopyMemory(&tsg->ChannelContext, &ChannelContext, sizeof(CONTEXT_HANDLE));
2731 else
2732 CopyMemory(&tsg->NewChannelContext, &ChannelContext, sizeof(CONTEXT_HANDLE));
2733
2734 if (!tsg_transition_to_state(tsg, TSG_STATE_CHANNEL_CREATED))
2735 return FALSE;
2736
2737 if (!tsg->reauthSequence)
2738 {
2739 if (!TsProxySetupReceivePipeWriteRequest(tsg, &tsg->ChannelContext))
2740 {
2741 WLog_Print(tsg->log, WLOG_ERROR, "TsProxySetupReceivePipe failure");
2742 return FALSE;
2743 }
2744 }
2745 else
2746 {
2747 if (!TsProxyCloseChannelWriteRequest(tsg, &tsg->NewChannelContext))
2748 {
2749 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyCloseChannelWriteRequest failure");
2750 return FALSE;
2751 }
2752
2753 if (!TsProxyCloseTunnelWriteRequest(tsg, &tsg->NewTunnelContext))
2754 {
2755 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyCloseTunnelWriteRequest failure");
2756 return FALSE;
2757 }
2758 }
2759
2760 rc = tsg_transition_to_state(tsg, TSG_STATE_PIPE_CREATED);
2761 tsg->reauthSequence = FALSE;
2762 }
2763 else
2764 {
2765 WLog_Print(tsg->log, WLOG_ERROR,
2766 "TSG_STATE_AUTHORIZED unexpected OpNum: %" PRIu32 "\n", call->OpNum);
2767 }
2768
2769 break;
2770
2771 case TSG_STATE_CHANNEL_CREATED:
2772 break;
2773
2774 case TSG_STATE_PIPE_CREATED:
2775 call = rpc_client_call_find_by_id(rpc->client, pdu->CallId);
2776
2777 if (!call)
2778 return FALSE;
2779
2780 if (call->OpNum == TsProxyMakeTunnelCallOpnum)
2781 {
2782 if (!TsProxyMakeTunnelCallReadResponse(tsg, pdu))
2783 {
2784 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyMakeTunnelCallReadResponse failure");
2785 return FALSE;
2786 }
2787
2788 rc = TRUE;
2789
2790 if (tsg->ReauthTunnelContext)
2791 rc = tsg_proxy_reauth(tsg);
2792 }
2793 else if (call->OpNum == TsProxyCloseChannelOpnum)
2794 {
2795 CONTEXT_HANDLE ChannelContext;
2796
2797 if (!TsProxyCloseChannelReadResponse(tsg->log, pdu, &ChannelContext))
2798 {
2799 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyCloseChannelReadResponse failure");
2800 return FALSE;
2801 }
2802
2803 rc = TRUE;
2804 }
2805 else if (call->OpNum == TsProxyCloseTunnelOpnum)
2806 {
2807 CONTEXT_HANDLE TunnelContext;
2808
2809 if (!TsProxyCloseTunnelReadResponse(tsg->log, pdu, &TunnelContext))
2810 {
2811 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyCloseTunnelReadResponse failure");
2812 return FALSE;
2813 }
2814
2815 rc = TRUE;
2816 }
2817
2818 break;
2819
2820 case TSG_STATE_TUNNEL_CLOSE_PENDING:
2821 {
2822 CONTEXT_HANDLE ChannelContext;
2823
2824 if (!TsProxyCloseChannelReadResponse(tsg->log, pdu, &ChannelContext))
2825 {
2826 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyCloseChannelReadResponse failure");
2827 return FALSE;
2828 }
2829
2830 if (!tsg_transition_to_state(tsg, TSG_STATE_CHANNEL_CLOSE_PENDING))
2831 return FALSE;
2832
2833 if (!TsProxyCloseChannelWriteRequest(tsg, nullptr))
2834 {
2835 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyCloseChannelWriteRequest failure");
2836 return FALSE;
2837 }
2838
2839 if (!TsProxyMakeTunnelCallWriteRequest(tsg, &tsg->TunnelContext,
2840 TSG_TUNNEL_CANCEL_ASYNC_MSG_REQUEST))
2841 {
2842 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyMakeTunnelCall failure");
2843 return FALSE;
2844 }
2845
2846 rc = TRUE;
2847 }
2848 break;
2849
2850 case TSG_STATE_CHANNEL_CLOSE_PENDING:
2851 {
2852 CONTEXT_HANDLE TunnelContext;
2853
2854 if (!TsProxyCloseTunnelReadResponse(tsg->log, pdu, &TunnelContext))
2855 {
2856 WLog_Print(tsg->log, WLOG_ERROR, "TsProxyCloseTunnelReadResponse failure");
2857 return FALSE;
2858 }
2859
2860 rc = tsg_transition_to_state(tsg, TSG_STATE_FINAL);
2861 }
2862 break;
2863
2864 case TSG_STATE_FINAL:
2865 break;
2866 default:
2867 break;
2868 }
2869
2870 {
2871 const size_t rem = Stream_GetRemainingLength(pdu->s);
2872 if (rem > 0)
2873 {
2874 WLog_Print(tsg->log, WLOG_WARN, "[%s] unparsed bytes: %" PRIuz,
2875 tsg_state_to_string(oldState), rem);
2876 }
2877 }
2878 return rc;
2879}
2880
2881BOOL tsg_check_event_handles(rdpTsg* tsg)
2882{
2883 WINPR_ASSERT(tsg);
2884 if (rpc_client_in_channel_recv(tsg->rpc) < 0)
2885 return FALSE;
2886
2887 if (rpc_client_out_channel_recv(tsg->rpc) < 0)
2888 return FALSE;
2889
2890 return TRUE;
2891}
2892
2893DWORD tsg_get_event_handles(rdpTsg* tsg, HANDLE* events, DWORD count)
2894{
2895 UINT32 nCount = 0;
2896 rdpRpc* rpc = tsg->rpc;
2897 RpcVirtualConnection* connection = rpc->VirtualConnection;
2898
2899 if (events && (nCount < count))
2900 {
2901 events[nCount] = rpc->client->PipeEvent;
2902 nCount++;
2903 }
2904 else
2905 return 0;
2906
2907 if (connection->DefaultInChannel && connection->DefaultInChannel->common.tls)
2908 {
2909 if (events && (nCount < count))
2910 {
2911 BIO_get_event(connection->DefaultInChannel->common.tls->bio, &events[nCount]);
2912 nCount++;
2913 }
2914 else
2915 return 0;
2916 }
2917
2918 if (connection->NonDefaultInChannel && connection->NonDefaultInChannel->common.tls)
2919 {
2920 if (events && (nCount < count))
2921 {
2922 BIO_get_event(connection->NonDefaultInChannel->common.tls->bio, &events[nCount]);
2923 nCount++;
2924 }
2925 else
2926 return 0;
2927 }
2928
2929 if (connection->DefaultOutChannel && connection->DefaultOutChannel->common.tls)
2930 {
2931 if (events && (nCount < count))
2932 {
2933 BIO_get_event(connection->DefaultOutChannel->common.tls->bio, &events[nCount]);
2934 nCount++;
2935 }
2936 else
2937 return 0;
2938 }
2939
2940 if (connection->NonDefaultOutChannel && connection->NonDefaultOutChannel->common.tls)
2941 {
2942 if (events && (nCount < count))
2943 {
2944 BIO_get_event(connection->NonDefaultOutChannel->common.tls->bio, &events[nCount]);
2945 nCount++;
2946 }
2947 else
2948 return 0;
2949 }
2950
2951 return nCount;
2952}
2953
2954WINPR_ATTR_NODISCARD
2955static BOOL tsg_set_hostname(rdpTsg* tsg, const char* hostname)
2956{
2957 WINPR_ASSERT(tsg);
2958 free(tsg->Hostname);
2959 tsg->Hostname = ConvertUtf8ToWCharAlloc(hostname, nullptr);
2960 return tsg->Hostname != nullptr;
2961}
2962
2963WINPR_ATTR_NODISCARD
2964static BOOL tsg_set_machine_name(rdpTsg* tsg, const char* machineName)
2965{
2966 WINPR_ASSERT(tsg);
2967
2968 free(tsg->QuarreQuest.machineName);
2969 tsg->QuarreQuest.machineName = nullptr;
2970 tsg->QuarreQuest.nameLength = 0;
2971 if (!machineName)
2972 return FALSE;
2973
2974 size_t size = 0;
2975 tsg->QuarreQuest.machineName = ConvertUtf8ToWCharAlloc(machineName, &size);
2976 tsg->QuarreQuest.nameLength = WINPR_ASSERTING_INT_CAST(uint32_t, size + 1ull);
2977 return tsg->QuarreQuest.machineName && (size > 0);
2978}
2979
2980BOOL tsg_connect(rdpTsg* tsg, const char* hostname, UINT16 port, DWORD timeout)
2981{
2982 UINT64 looptimeout = timeout * 1000ULL;
2983 DWORD nCount = 0;
2984 HANDLE events[MAXIMUM_WAIT_OBJECTS] = WINPR_C_ARRAY_INIT;
2985
2986 WINPR_ASSERT(tsg);
2987
2988 rdpRpc* rpc = tsg->rpc;
2989 WINPR_ASSERT(rpc);
2990
2991 rdpTransport* transport = rpc->transport;
2992 rdpContext* context = transport_get_context(transport);
2993 WINPR_ASSERT(context);
2994
2995 rdpSettings* settings = context->settings;
2996
2997 freerdp_set_last_error(context, ERROR_SUCCESS);
2998
2999 tsg->Port = port;
3000 tsg->transport = transport;
3001
3002 {
3003 const UINT32 GatewayPort = freerdp_settings_get_uint32(settings, FreeRDP_GatewayPort);
3004 if (GatewayPort == 0)
3005 {
3006 if (!freerdp_settings_set_uint32(settings, FreeRDP_GatewayPort, 443))
3007 return FALSE;
3008 }
3009 }
3010
3011 if (!tsg_set_hostname(tsg, hostname))
3012 return FALSE;
3013
3014 const char* ComputerName = freerdp_settings_get_string(settings, FreeRDP_ComputerName);
3015 if (!tsg_set_machine_name(tsg, ComputerName))
3016 return FALSE;
3017
3018 if (!rpc_connect(rpc, timeout))
3019 {
3020 WLog_Print(tsg->log, WLOG_ERROR, "rpc_connect error!");
3021 return FALSE;
3022 }
3023
3024 nCount = tsg_get_event_handles(tsg, events, ARRAYSIZE(events));
3025
3026 if (nCount == 0)
3027 return FALSE;
3028
3029 while (tsg->state != TSG_STATE_PIPE_CREATED)
3030 {
3031 const DWORD polltimeout = 250;
3032 DWORD status = WaitForMultipleObjects(nCount, events, FALSE, polltimeout);
3033 if (status == WAIT_TIMEOUT)
3034 {
3035 if (timeout > 0)
3036 {
3037 if (looptimeout < polltimeout)
3038 return FALSE;
3039 looptimeout -= polltimeout;
3040 }
3041 }
3042 else
3043 looptimeout = timeout * 1000ULL;
3044
3045 if (!tsg_check_event_handles(tsg))
3046 {
3047 WLog_Print(tsg->log, WLOG_ERROR, "tsg_check failure");
3048 transport_set_layer(transport, TRANSPORT_LAYER_CLOSED);
3049 return FALSE;
3050 }
3051 }
3052
3053 WLog_Print(tsg->log, WLOG_INFO, "TS Gateway Connection Success");
3054 tsg->bio = BIO_new(BIO_s_tsg());
3055
3056 if (!tsg->bio)
3057 return FALSE;
3058
3059 BIO_set_data(tsg->bio, (void*)tsg);
3060 return TRUE;
3061}
3062
3063BOOL tsg_disconnect(rdpTsg* tsg)
3064{
3084 if (!tsg)
3085 return FALSE;
3086
3087 if (tsg->state != TSG_STATE_TUNNEL_CLOSE_PENDING)
3088 {
3089 if (!TsProxyCloseChannelWriteRequest(tsg, &tsg->ChannelContext))
3090 return FALSE;
3091
3092 return tsg_transition_to_state(tsg, TSG_STATE_CHANNEL_CLOSE_PENDING);
3093 }
3094
3095 return TRUE;
3096}
3097
3108WINPR_ATTR_NODISCARD
3109static int tsg_read(rdpTsg* tsg, BYTE* data, size_t length)
3110{
3111 rdpRpc* rpc = nullptr;
3112 int status = 0;
3113
3114 if (!tsg || !data)
3115 return -1;
3116
3117 rpc = tsg->rpc;
3118
3119 if (transport_get_layer(rpc->transport) == TRANSPORT_LAYER_CLOSED)
3120 {
3121 WLog_Print(tsg->log, WLOG_ERROR, "tsg_read error: connection lost");
3122 return -1;
3123 }
3124
3125 do
3126 {
3127 status = rpc_client_receive_pipe_read(rpc->client, data, length);
3128
3129 if (status < 0)
3130 return -1;
3131
3132 if (!status && !transport_get_blocking(rpc->transport))
3133 return 0;
3134
3135 if (transport_get_layer(rpc->transport) == TRANSPORT_LAYER_CLOSED)
3136 {
3137 WLog_Print(tsg->log, WLOG_ERROR, "tsg_read error: connection lost");
3138 return -1;
3139 }
3140
3141 if (status > 0)
3142 break;
3143
3144 if (transport_get_blocking(rpc->transport))
3145 {
3146 while (WaitForSingleObject(rpc->client->PipeEvent, 0) != WAIT_OBJECT_0)
3147 {
3148 if (!tsg_check_event_handles(tsg))
3149 return -1;
3150
3151 (void)WaitForSingleObject(rpc->client->PipeEvent, 100);
3152 }
3153 }
3154 } while (transport_get_blocking(rpc->transport));
3155
3156 return status;
3157}
3158
3159WINPR_ATTR_NODISCARD
3160static int tsg_write(rdpTsg* tsg, const BYTE* data, UINT32 length)
3161{
3162 int status = 0;
3163
3164 if (!tsg || !data || !tsg->rpc || !tsg->rpc->transport)
3165 return -1;
3166
3167 if (transport_get_layer(tsg->rpc->transport) == TRANSPORT_LAYER_CLOSED)
3168 {
3169 WLog_Print(tsg->log, WLOG_ERROR, "error, connection lost");
3170 return -1;
3171 }
3172
3173 status = TsProxySendToServer((handle_t)tsg, data, 1, &length);
3174
3175 if (status < 0)
3176 return -1;
3177
3178 return (int)length;
3179}
3180
3181rdpTsg* tsg_new(rdpTransport* transport)
3182{
3183 rdpTsg* tsg = (rdpTsg*)calloc(1, sizeof(rdpTsg));
3184
3185 if (!tsg)
3186 return nullptr;
3187 tsg->log = WLog_Get(TAG);
3188 tsg->transport = transport;
3189 tsg->rpc = rpc_new(tsg->transport);
3190
3191 if (!tsg->rpc)
3192 goto out_free;
3193
3194 return tsg;
3195out_free:
3196 free(tsg);
3197 return nullptr;
3198}
3199
3200void tsg_free(rdpTsg* tsg)
3201{
3202 if (tsg)
3203 {
3204 rpc_free(tsg->rpc);
3205 free(tsg->Hostname);
3206 free(tsg->QuarreQuest.machineName);
3207 free(tsg->QuarreQuest.data);
3208 free(tsg);
3209 }
3210}
3211
3212WINPR_ATTR_NODISCARD
3213static int transport_bio_tsg_write(BIO* bio, const char* buf, int num)
3214{
3215 int status = 0;
3216 rdpTsg* tsg = (rdpTsg*)BIO_get_data(bio);
3217 BIO_clear_flags(bio, BIO_FLAGS_WRITE);
3218
3219 if (num < 0)
3220 return -1;
3221 status = tsg_write(tsg, (const BYTE*)buf, (UINT32)num);
3222
3223 if (status < 0)
3224 {
3225 BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
3226 return -1;
3227 }
3228 else if (status == 0)
3229 {
3230 BIO_set_flags(bio, BIO_FLAGS_WRITE);
3231 WSASetLastError(WSAEWOULDBLOCK);
3232 }
3233 else
3234 {
3235 BIO_set_flags(bio, BIO_FLAGS_WRITE);
3236 }
3237
3238 return status >= 0 ? status : -1;
3239}
3240
3241WINPR_ATTR_NODISCARD
3242static int transport_bio_tsg_read(BIO* bio, char* buf, int size)
3243{
3244 int status = 0;
3245 rdpTsg* tsg = (rdpTsg*)BIO_get_data(bio);
3246
3247 if (!tsg || (size < 0))
3248 {
3249 BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
3250 return -1;
3251 }
3252
3253 BIO_clear_flags(bio, BIO_FLAGS_READ);
3254 status = tsg_read(tsg, (BYTE*)buf, (size_t)size);
3255
3256 if (status < 0)
3257 {
3258 BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
3259 return -1;
3260 }
3261 else if (status == 0)
3262 {
3263 BIO_set_flags(bio, BIO_FLAGS_READ);
3264 WSASetLastError(WSAEWOULDBLOCK);
3265 }
3266 else
3267 {
3268 BIO_set_flags(bio, BIO_FLAGS_READ);
3269 }
3270
3271 return status > 0 ? status : -1;
3272}
3273
3274WINPR_ATTR_NODISCARD
3275static int transport_bio_tsg_puts(BIO* bio, const char* str)
3276{
3277 WINPR_UNUSED(bio);
3278 WINPR_UNUSED(str);
3279 return -2;
3280}
3281
3282WINPR_ATTR_NODISCARD
3283// NOLINTNEXTLINE(readability-non-const-parameter)
3284static int transport_bio_tsg_gets(BIO* bio, char* str, int size)
3285{
3286 WINPR_UNUSED(bio);
3287 WINPR_UNUSED(str);
3288 WINPR_UNUSED(size);
3289 return 1;
3290}
3291
3292WINPR_ATTR_NODISCARD
3293static long transport_bio_tsg_ctrl(BIO* bio, int cmd, long arg1, void* arg2)
3294{
3295 long status = -1;
3296 rdpTsg* tsg = (rdpTsg*)BIO_get_data(bio);
3297 RpcVirtualConnection* connection = tsg->rpc->VirtualConnection;
3298 RpcInChannel* inChannel = connection->DefaultInChannel;
3299 RpcOutChannel* outChannel = connection->DefaultOutChannel;
3300
3301 switch (cmd)
3302 {
3303 case BIO_CTRL_FLUSH:
3304 (void)BIO_flush(inChannel->common.tls->bio);
3305 (void)BIO_flush(outChannel->common.tls->bio);
3306 status = 1;
3307 break;
3308
3309 case BIO_C_GET_EVENT:
3310 if (arg2)
3311 {
3312 *((HANDLE*)arg2) = tsg->rpc->client->PipeEvent;
3313 status = 1;
3314 }
3315
3316 break;
3317
3318 case BIO_C_SET_NONBLOCK:
3319 status = 1;
3320 break;
3321
3322 case BIO_C_READ_BLOCKED:
3323 {
3324 BIO* cbio = outChannel->common.bio;
3325 status = BIO_read_blocked(cbio);
3326 }
3327 break;
3328
3329 case BIO_C_WRITE_BLOCKED:
3330 {
3331 BIO* cbio = inChannel->common.bio;
3332 status = BIO_write_blocked(cbio);
3333 }
3334 break;
3335
3336 case BIO_C_WAIT_READ:
3337 {
3338 int timeout = (int)arg1;
3339 BIO* cbio = outChannel->common.bio;
3340
3341 if (BIO_read_blocked(cbio))
3342 return BIO_wait_read(cbio, timeout);
3343 else if (BIO_write_blocked(cbio))
3344 return BIO_wait_write(cbio, timeout);
3345 else
3346 status = 1;
3347 }
3348 break;
3349
3350 case BIO_C_WAIT_WRITE:
3351 {
3352 int timeout = (int)arg1;
3353 BIO* cbio = inChannel->common.bio;
3354
3355 if (BIO_write_blocked(cbio))
3356 status = BIO_wait_write(cbio, timeout);
3357 else if (BIO_read_blocked(cbio))
3358 status = BIO_wait_read(cbio, timeout);
3359 else
3360 status = 1;
3361 }
3362 break;
3363#if OPENSSL_VERSION_NUMBER >= 0x30000000L
3364 case BIO_CTRL_GET_KTLS_SEND:
3365 status = 0;
3366 break;
3367 case BIO_CTRL_GET_KTLS_RECV:
3368 status = 0;
3369 break;
3370#endif
3371 default:
3372 break;
3373 }
3374
3375 return status;
3376}
3377
3378WINPR_ATTR_NODISCARD
3379static int transport_bio_tsg_new(BIO* bio)
3380{
3381 WINPR_ASSERT(bio);
3382 BIO_set_init(bio, 1);
3383 BIO_set_flags(bio, BIO_FLAGS_SHOULD_RETRY);
3384 return 1;
3385}
3386
3387WINPR_ATTR_NODISCARD
3388static int transport_bio_tsg_free(BIO* bio)
3389{
3390 WINPR_ASSERT(bio);
3391 WINPR_UNUSED(bio);
3392 return 1;
3393}
3394
3395BIO_METHOD* BIO_s_tsg(void)
3396{
3397 static BIO_METHOD* bio_methods = nullptr;
3398
3399 if (bio_methods == nullptr)
3400 {
3401 if (!(bio_methods = BIO_meth_new(BIO_TYPE_TSG, "TSGateway")))
3402 return nullptr;
3403
3404 BIO_meth_set_write(bio_methods, transport_bio_tsg_write);
3405 BIO_meth_set_read(bio_methods, transport_bio_tsg_read);
3406 BIO_meth_set_puts(bio_methods, transport_bio_tsg_puts);
3407 BIO_meth_set_gets(bio_methods, transport_bio_tsg_gets);
3408 BIO_meth_set_ctrl(bio_methods, transport_bio_tsg_ctrl);
3409 BIO_meth_set_create(bio_methods, transport_bio_tsg_new);
3410 BIO_meth_set_destroy(bio_methods, transport_bio_tsg_free);
3411 }
3412
3413 return bio_methods;
3414}
3415
3416TSG_STATE tsg_get_state(rdpTsg* tsg)
3417{
3418 if (!tsg)
3419 return TSG_STATE_INITIAL;
3420
3421 return tsg->state;
3422}
3423
3424BIO* tsg_get_bio(rdpTsg* tsg)
3425{
3426 if (!tsg)
3427 return nullptr;
3428
3429 return tsg->bio;
3430}
3431
3432BOOL tsg_set_state(rdpTsg* tsg, TSG_STATE state)
3433{
3434 WINPR_ASSERT(tsg);
3435 tsg->state = state;
3436 return TRUE;
3437}
freerdp_settings_get_string
WINPR_ATTR_NODISCARD FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
freerdp_settings_set_uint32
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 val)
Sets a UINT32 settings value.
freerdp_settings_get_uint32
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
CONTEXT_HANDLE
Definition winpr/include/winpr/rpc.h:26
RPC_PDU
Definition libfreerdp/core/gateway/rpc.h:66
p_uuid_t
Definition libfreerdp/core/gateway/rpc.h:150