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