FreeRDP
Loading...
Searching...
No Matches
rdp.c
1
21#include <freerdp/config.h>
22
23#include "settings.h"
24
25#include <winpr/crt.h>
26#include <winpr/string.h>
27#include <winpr/synch.h>
28#include <winpr/assert.h>
29#include <winpr/cast.h>
30#include <winpr/json.h>
31#include <winpr/ssl.h>
32
33#include "rdp.h"
34
35#include "state.h"
36#include "info.h"
37#include "utils.h"
38#include "mcs.h"
39#include "redirection.h"
40
41#include <freerdp/codec/bulk.h>
42#include <freerdp/crypto/per.h>
43#include <freerdp/log.h>
44#include <freerdp/buildflags.h>
45
46#define RDP_TAG FREERDP_TAG("core.rdp")
47
48typedef struct
49{
50 const char* file;
51 const char* fkt;
52 size_t line;
53 DWORD level;
54} log_line_t;
55
56static const char* DATA_PDU_TYPE_STRINGS[80] = {
57 "?",
58 "?", /* 0x00 - 0x01 */
59 "Update", /* 0x02 */
60 "?",
61 "?",
62 "?",
63 "?",
64 "?",
65 "?",
66 "?",
67 "?", /* 0x03 - 0x0A */
68 "?",
69 "?",
70 "?",
71 "?",
72 "?",
73 "?",
74 "?",
75 "?",
76 "?", /* 0x0B - 0x13 */
77 "Control", /* 0x14 */
78 "?",
79 "?",
80 "?",
81 "?",
82 "?",
83 "?", /* 0x15 - 0x1A */
84 "Pointer", /* 0x1B */
85 "Input", /* 0x1C */
86 "?",
87 "?", /* 0x1D - 0x1E */
88 "Synchronize", /* 0x1F */
89 "?", /* 0x20 */
90 "Refresh Rect", /* 0x21 */
91 "Play Sound", /* 0x22 */
92 "Suppress Output", /* 0x23 */
93 "Shutdown Request", /* 0x24 */
94 "Shutdown Denied", /* 0x25 */
95 "Save Session Info", /* 0x26 */
96 "Font List", /* 0x27 */
97 "Font Map", /* 0x28 */
98 "Set Keyboard Indicators", /* 0x29 */
99 "?", /* 0x2A */
100 "Bitmap Cache Persistent List", /* 0x2B */
101 "Bitmap Cache Error", /* 0x2C */
102 "Set Keyboard IME Status", /* 0x2D */
103 "Offscreen Cache Error", /* 0x2E */
104 "Set Error Info", /* 0x2F */
105 "Draw Nine Grid Error", /* 0x30 */
106 "Draw GDI+ Error", /* 0x31 */
107 "ARC Status", /* 0x32 */
108 "?",
109 "?",
110 "?", /* 0x33 - 0x35 */
111 "Status Info", /* 0x36 */
112 "Monitor Layout", /* 0x37 */
113 "FrameAcknowledge",
114 "?",
115 "?", /* 0x38 - 0x40 */
116 "?",
117 "?",
118 "?",
119 "?",
120 "?",
121 "?" /* 0x41 - 0x46 */
122};
123
124#define rdp_check_monitor_layout_pdu_state(rdp, expected) \
125 rdp_check_monitor_layout_pdu_state_(rdp, expected, __FILE__, __func__, __LINE__)
126
127WINPR_ATTR_NODISCARD
128static BOOL rdp_check_monitor_layout_pdu_state_(const rdpRdp* rdp, BOOL expected, const char* file,
129 const char* fkt, size_t line)
130{
131 WINPR_ASSERT(rdp);
132 if (expected != rdp->monitor_layout_pdu)
133 {
134 const DWORD log_level = WLOG_ERROR;
135 if (WLog_IsLevelActive(rdp->log, log_level))
136 {
137 WLog_PrintTextMessage(rdp->log, log_level, line, file, fkt,
138 "Expected rdp->monitor_layout_pdu == %s",
139 expected ? "TRUE" : "FALSE");
140 }
141 return FALSE;
142 }
143 return TRUE;
144}
145
146#define rdp_set_monitor_layout_pdu_state(rdp, expected) \
147 rdp_set_monitor_layout_pdu_state_(rdp, expected, __FILE__, __func__, __LINE__)
148WINPR_ATTR_NODISCARD
149static BOOL rdp_set_monitor_layout_pdu_state_(rdpRdp* rdp, BOOL value, const char* file,
150 const char* fkt, size_t line)
151{
152
153 WINPR_ASSERT(rdp);
154 if (value && (value == rdp->monitor_layout_pdu))
155 {
156 const DWORD log_level = WLOG_WARN;
157 if (WLog_IsLevelActive(rdp->log, log_level))
158 {
159 WLog_PrintTextMessage(rdp->log, log_level, line, file, fkt,
160 "rdp->monitor_layout_pdu == TRUE, expected FALSE");
161 }
162 return FALSE;
163 }
164 rdp->monitor_layout_pdu = value;
165 return TRUE;
166}
167
168const char* data_pdu_type_to_string(UINT8 type)
169{
170 if (type >= ARRAYSIZE(DATA_PDU_TYPE_STRINGS))
171 return "???";
172 return DATA_PDU_TYPE_STRINGS[type];
173}
174
175WINPR_ATTR_NODISCARD
176static BOOL rdp_read_flow_control_pdu(rdpRdp* rdp, wStream* s, UINT16* type, UINT16* channel_id);
177
178WINPR_ATTR_NODISCARD
179static BOOL rdp_write_share_control_header(rdpRdp* rdp, wStream* s, size_t length, UINT16 type,
180 UINT16 channel_id);
181
182WINPR_ATTR_NODISCARD
183static BOOL rdp_write_share_data_header(rdpRdp* rdp, wStream* s, size_t length, BYTE type,
184 UINT32 share_id);
185
196BOOL rdp_read_security_header(rdpRdp* rdp, wStream* s, UINT16* flags, UINT16* length)
197{
198 char buffer[256] = WINPR_C_ARRAY_INIT;
199 WINPR_ASSERT(s);
200 WINPR_ASSERT(flags);
201 WINPR_ASSERT(rdp);
202
203 /* Basic Security Header */
204 if ((length && (*length < 4)))
205 {
206 WLog_Print(rdp->log, WLOG_WARN,
207 "invalid security header length, have %" PRIu16 ", must be >= 4", *length);
208 return FALSE;
209 }
210 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 4))
211 return FALSE;
212
213 *flags = Stream_Get_UINT16(s); /* flags */
214 const uint16_t flagsHi = Stream_Get_UINT16(s); /* flagsHi (unused) */
215 if ((*flags & SEC_FLAGSHI_VALID) != 0)
216 {
217 WLog_Print(rdp->log, WLOG_WARN,
218 "[MS-RDPBCGR] 2.2.8.1.1.2.1 Basic (TS_SECURITY_HEADER) SEC_FLAGSHI_VALID field "
219 "set: flagsHi=0x%04" PRIx16,
220 flagsHi);
221 }
222 WLog_Print(rdp->log, WLOG_TRACE, "%s",
223 rdp_security_flag_string(*flags, buffer, sizeof(buffer)));
224 if (length)
225 *length -= 4;
226
227 return TRUE;
228}
229
239BOOL rdp_write_security_header(rdpRdp* rdp, wStream* s, UINT16 flags)
240{
241 char buffer[256] = WINPR_C_ARRAY_INIT;
242 WINPR_ASSERT(s);
243 WINPR_ASSERT(rdp);
244
245 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, (s), 4))
246 return FALSE;
247
248 WLog_Print(rdp->log, WLOG_TRACE, "%s", rdp_security_flag_string(flags, buffer, sizeof(buffer)));
249 /* Basic Security Header */
250 WINPR_ASSERT((flags & SEC_FLAGSHI_VALID) == 0); /* SEC_FLAGSHI_VALID is unsupported */
251 Stream_Write_UINT16(s, flags); /* flags */
252 Stream_Write_UINT16(s, 0); /* flagsHi (unused) */
253 return TRUE;
254}
255
256BOOL rdp_read_share_control_header(rdpRdp* rdp, wStream* s, UINT16* tpktLength,
257 UINT16* remainingLength, UINT16* type, UINT16* channel_id)
258{
259 UINT16 len = 0;
260 UINT16 tmp = 0;
261
262 WINPR_ASSERT(rdp);
263 WINPR_ASSERT(s);
264 WINPR_ASSERT(type);
265 WINPR_ASSERT(channel_id);
266
267 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 2))
268 return FALSE;
269
270 /* Share Control Header */
271 Stream_Read_UINT16(s, len); /* totalLength */
272
273 /* If length is 0x8000 then we actually got a flow control PDU that we should ignore
274 http://msdn.microsoft.com/en-us/library/cc240576.aspx */
275 if (len == 0x8000)
276 {
277 if (!rdp_read_flow_control_pdu(rdp, s, type, channel_id))
278 return FALSE;
279 *channel_id = 0;
280 if (tpktLength)
281 *tpktLength = 8; /* Flow control PDU is 8 bytes */
282 if (remainingLength)
283 *remainingLength = 0;
284
285 char buffer[128] = WINPR_C_ARRAY_INIT;
286 WLog_Print(rdp->log, WLOG_DEBUG,
287 "[Flow control PDU] type=%s, tpktLength=%" PRIu16 ", remainingLength=%" PRIu16,
288 pdu_type_to_str(*type, buffer, sizeof(buffer)), tpktLength ? *tpktLength : 0u,
289 remainingLength ? *remainingLength : 0u);
290 return TRUE;
291 }
292
293 if (len < 4U)
294 {
295 WLog_Print(rdp->log, WLOG_ERROR,
296 "Invalid share control header, length is %" PRIu16 ", must be >4", len);
297 return FALSE;
298 }
299
300 if (tpktLength)
301 *tpktLength = len;
302
303 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 2))
304 return FALSE;
305
306 Stream_Read_UINT16(s, tmp); /* pduType */
307 *type = tmp & 0x0F; /* type is in the 4 least significant bits */
308
309 size_t remLen = len - 4;
310 if (len > 5)
311 {
312 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 2))
313 return FALSE;
314
315 Stream_Read_UINT16(s, *channel_id); /* pduSource */
316 remLen = len - 6;
317 }
318 else
319 *channel_id = 0; /* Windows XP can send such short DEACTIVATE_ALL PDUs. */
320
321 char buffer[128] = WINPR_C_ARRAY_INIT;
322 WLog_Print(rdp->log, WLOG_DEBUG, "type=%s, tpktLength=%" PRIu16 ", remainingLength=%" PRIuz,
323 pdu_type_to_str(*type, buffer, sizeof(buffer)), len, remLen);
324 if (remainingLength)
325 {
326 WINPR_ASSERT(remLen <= UINT16_MAX);
327 *remainingLength = (UINT16)remLen;
328 }
329 return Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, remLen);
330}
331
332BOOL rdp_write_share_control_header(rdpRdp* rdp, wStream* s, size_t length, UINT16 type,
333 UINT16 channel_id)
334{
335 WINPR_ASSERT(s);
336 WINPR_ASSERT(rdp);
337 if (length > UINT16_MAX)
338 return FALSE;
339
340 if (length < RDP_PACKET_HEADER_MAX_LENGTH)
341 return FALSE;
342 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, (s), 6))
343 return FALSE;
344 length -= RDP_PACKET_HEADER_MAX_LENGTH;
345 /* Share Control Header */
346 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, length)); /* totalLength */
347 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, type | 0x10)); /* pduType */
348 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, channel_id)); /* pduSource */
349 return TRUE;
350}
351
352BOOL rdp_read_share_data_header(rdpRdp* rdp, wStream* s, UINT16* length, BYTE* type,
353 UINT32* shareId, BYTE* compressedType, UINT16* compressedLength)
354{
355 WINPR_ASSERT(s);
356 WINPR_ASSERT(rdp);
357
358 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 12))
359 return FALSE;
360
361 /* Share Data Header */
362 Stream_Read_UINT32(s, *shareId); /* shareId (4 bytes) */
363 Stream_Seek_UINT8(s); /* pad1 (1 byte) */
364 Stream_Seek_UINT8(s); /* streamId (1 byte) */
365 Stream_Read_UINT16(s, *length); /* uncompressedLength (2 bytes) */
366 Stream_Read_UINT8(s, *type); /* pduType2, Data PDU Type (1 byte) */
367 Stream_Read_UINT8(s, *compressedType); /* compressedType (1 byte) */
368 Stream_Read_UINT16(s, *compressedLength); /* compressedLength (2 bytes) */
369 return TRUE;
370}
371
372BOOL rdp_write_share_data_header(rdpRdp* rdp, wStream* s, size_t length, BYTE type, UINT32 share_id)
373{
374 const size_t headerLen = RDP_PACKET_HEADER_MAX_LENGTH + RDP_SHARE_CONTROL_HEADER_LENGTH +
375 RDP_SHARE_DATA_HEADER_LENGTH;
376
377 WINPR_ASSERT(s);
378 WINPR_ASSERT(rdp);
379 if (length > UINT16_MAX)
380 return FALSE;
381
382 if (length < headerLen)
383 return FALSE;
384 length -= headerLen;
385 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, (s), 12))
386 return FALSE;
387
388 /* Share Data Header */
389 Stream_Write_UINT32(s, share_id); /* shareId (4 bytes) */
390 Stream_Write_UINT8(s, 0); /* pad1 (1 byte) */
391 Stream_Write_UINT8(s, STREAM_LOW); /* streamId (1 byte) */
392 Stream_Write_UINT16(
393 s, WINPR_ASSERTING_INT_CAST(uint16_t, length)); /* uncompressedLength (2 bytes) */
394 Stream_Write_UINT8(s, type); /* pduType2, Data PDU Type (1 byte) */
395 Stream_Write_UINT8(s, 0); /* compressedType (1 byte) */
396 Stream_Write_UINT16(s, 0); /* compressedLength (2 bytes) */
397 return TRUE;
398}
399
400WINPR_ATTR_NODISCARD
401static BOOL rdp_security_stream_init(rdpRdp* rdp, wStream* s, BOOL sec_header, UINT16* sec_flags)
402{
403 WINPR_ASSERT(rdp);
404 WINPR_ASSERT(s);
405 WINPR_ASSERT(sec_flags);
406
407 if (rdp->do_crypt)
408 {
409 if (!Stream_SafeZero(s, 12))
410 return FALSE;
411
412 if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
413 {
414 if (!Stream_SafeZero(s, 4))
415 return FALSE;
416 }
417
418 *sec_flags |= SEC_ENCRYPT;
419
420 if (rdp->do_secure_checksum)
421 *sec_flags |= SEC_SECURE_CHECKSUM;
422 }
423 else if (*sec_flags != 0 || sec_header)
424 {
425 if (!Stream_SafeZero(s, 4))
426 return FALSE;
427 }
428
429 return TRUE;
430}
431
432wStream* rdp_send_stream_init(rdpRdp* rdp, UINT16* sec_flags)
433{
434 wStream* s = nullptr;
435
436 WINPR_ASSERT(rdp);
437 WINPR_ASSERT(rdp->transport);
438
439 s = transport_send_stream_init(rdp->transport, 4096);
440
441 if (!s)
442 return nullptr;
443
444 if (!Stream_SafeZero(s, RDP_PACKET_HEADER_MAX_LENGTH))
445 goto fail;
446
447 if (!rdp_security_stream_init(rdp, s, FALSE, sec_flags))
448 goto fail;
449
450 return s;
451fail:
452 Stream_Release(s);
453 return nullptr;
454}
455
456wStream* rdp_send_stream_pdu_init(rdpRdp* rdp, UINT16* sec_flags)
457{
458 wStream* s = rdp_send_stream_init(rdp, sec_flags);
459
460 if (!s)
461 return nullptr;
462
463 if (!Stream_SafeZero(s, RDP_SHARE_CONTROL_HEADER_LENGTH))
464 goto fail;
465
466 return s;
467fail:
468 Stream_Release(s);
469 return nullptr;
470}
471
472wStream* rdp_data_pdu_init(rdpRdp* rdp, UINT16* sec_flags)
473{
474 wStream* s = rdp_send_stream_pdu_init(rdp, sec_flags);
475
476 if (!s)
477 return nullptr;
478
479 if (!Stream_SafeZero(s, RDP_SHARE_DATA_HEADER_LENGTH))
480 goto fail;
481
482 return s;
483fail:
484 Stream_Release(s);
485 return nullptr;
486}
487
488BOOL rdp_set_error_info(rdpRdp* rdp, UINT32 errorInfo)
489{
490 BOOL rc = TRUE;
491 WINPR_ASSERT(rdp);
492
493 rdp->errorInfo = errorInfo;
494
495 if (rdp->errorInfo != ERRINFO_SUCCESS)
496 {
497 rdpContext* context = rdp->context;
498 WINPR_ASSERT(context);
499
500 rdp_print_errinfo(rdp->errorInfo);
501
502 if (context)
503 {
504 freerdp_set_last_error_log(context, MAKE_FREERDP_ERROR(ERRINFO, errorInfo));
505
506 if (context->pubSub)
507 {
508 ErrorInfoEventArgs e = WINPR_C_ARRAY_INIT;
509 EventArgsInit(&e, "freerdp");
510 e.code = rdp->errorInfo;
511 rc = PubSub_OnErrorInfo(context->pubSub, context, &e) >= 0;
512 }
513 }
514 else
515 WLog_Print(rdp->log, WLOG_ERROR, "missing context=%p", (void*)context);
516 }
517 else
518 {
519 freerdp_set_last_error_log(rdp->context, FREERDP_ERROR_SUCCESS);
520 }
521
522 return rc;
523}
524
525wStream* rdp_message_channel_pdu_init(rdpRdp* rdp, UINT16* sec_flags)
526{
527 wStream* s = nullptr;
528
529 WINPR_ASSERT(rdp);
530
531 s = transport_send_stream_init(rdp->transport, 4096);
532
533 if (!s)
534 return nullptr;
535
536 if (!Stream_SafeZero(s, RDP_PACKET_HEADER_MAX_LENGTH))
537 goto fail;
538
539 if (!rdp_security_stream_init(rdp, s, TRUE, sec_flags))
540 goto fail;
541
542 return s;
543fail:
544 Stream_Release(s);
545 return nullptr;
546}
547
558BOOL rdp_read_header(rdpRdp* rdp, wStream* s, UINT16* length, UINT16* channelId)
559{
560 BYTE li = 0;
561 BYTE code = 0;
562 BYTE choice = 0;
563 UINT16 initiator = 0;
564
565 WINPR_ASSERT(rdp);
566 WINPR_ASSERT(rdp->settings);
567 WINPR_ASSERT(s);
568 DomainMCSPDU MCSPDU = (rdp->settings->ServerMode) ? DomainMCSPDU_SendDataRequest
569 : DomainMCSPDU_SendDataIndication;
570
571 const size_t start = Stream_GetPosition(s);
572 *channelId = 0; /* Initialize in case of early abort */
573 if (!tpkt_read_header(s, length))
574 return FALSE;
575 const UINT16 tpktLength = *length;
576
577 if (!tpdu_read_header(s, &code, &li, *length))
578 return FALSE;
579
580 if (code != X224_TPDU_DATA)
581 {
582 if (code == X224_TPDU_DISCONNECT_REQUEST)
583 {
584 WLog_Print(rdp->log, WLOG_WARN, "Received X224_TPDU_DISCONNECT_REQUEST, terminating");
585 utils_abort_connect(rdp);
586 return TRUE;
587 }
588
589 WLog_Print(rdp->log, WLOG_WARN,
590 "Unexpected X224 TPDU type %s [%08" PRIx32 "] instead of %s",
591 tpdu_type_to_string(code), code, tpdu_type_to_string(X224_TPDU_DATA));
592 return FALSE;
593 }
594
595 if (!per_read_choice(s, &choice))
596 return FALSE;
597
598 const DomainMCSPDU domainMCSPDU = (DomainMCSPDU)(choice >> 2);
599
600 if (domainMCSPDU != MCSPDU)
601 {
602 if (domainMCSPDU != DomainMCSPDU_DisconnectProviderUltimatum)
603 {
604 WLog_Print(rdp->log, WLOG_WARN, "Received %s instead of %s",
605 mcs_domain_pdu_string(domainMCSPDU), mcs_domain_pdu_string(MCSPDU));
606 return FALSE;
607 }
608 }
609
610 MCSPDU = domainMCSPDU;
611
612 if (*length < 8U)
613 {
614 WLog_Print(rdp->log, WLOG_WARN, "TPDU invalid length, got %" PRIu16 ", expected at least 8",
615 *length);
616 return FALSE;
617 }
618
619 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, *length - 8))
620 return FALSE;
621
622 if (MCSPDU == DomainMCSPDU_DisconnectProviderUltimatum)
623 {
624 int reason = 0;
625 TerminateEventArgs e = WINPR_C_ARRAY_INIT;
626
627 if (!mcs_recv_disconnect_provider_ultimatum(rdp->mcs, s, &reason))
628 return FALSE;
629
630 rdpContext* context = rdp->context;
631 WINPR_ASSERT(context);
632 context->disconnectUltimatum = reason;
633
634 if (rdp->errorInfo == ERRINFO_SUCCESS)
635 {
641 UINT32 errorInfo = ERRINFO_RPC_INITIATED_DISCONNECT;
642 if (reason == Disconnect_Ultimatum_provider_initiated)
643 errorInfo = ERRINFO_RPC_INITIATED_DISCONNECT;
644 else if (reason == Disconnect_Ultimatum_user_requested)
645 errorInfo = ERRINFO_LOGOFF_BY_USER;
646
647 if (!rdp_set_error_info(rdp, errorInfo))
648 return FALSE;
649 }
650
651 WLog_Print(rdp->log, WLOG_DEBUG, "DisconnectProviderUltimatum: reason: %d", reason);
652 utils_abort_connect(rdp);
653 EventArgsInit(&e, "freerdp");
654 e.code = 0;
655 return PubSub_OnTerminate(rdp->pubSub, context, &e) >= 0;
656 }
657
658 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 5))
659 return FALSE;
660
661 if (!per_read_integer16(s, &initiator, MCS_BASE_CHANNEL_ID)) /* initiator (UserId) */
662 return FALSE;
663
664 if (!per_read_integer16(s, channelId, 0)) /* channelId */
665 return FALSE;
666
667 const uint8_t dataPriority = Stream_Get_UINT8(s); /* dataPriority + Segmentation (0x70) */
668 WLog_Print(rdp->log, WLOG_TRACE, "dataPriority=%" PRIu8, dataPriority);
669
670 if (!per_read_length(s, length)) /* userData (OCTET_STRING) */
671 return FALSE;
672
673 /* userData fills the enclosing TPKT after the MCS header. Validate the wire
674 * length before removing security headers or FIPS padding. Share Control
675 * PDUs may still be batched inside this userData. */
676 const size_t headerLength = Stream_GetPosition(s) - start;
677 if ((headerLength > tpktLength) || (*length != tpktLength - headerLength))
678 {
679 WLog_Print(rdp->log, WLOG_ERROR,
680 "MCS userData length %" PRIu16 " is inconsistent with TPKT length %" PRIu16
681 " and header length %" PRIuz,
682 *length, tpktLength, headerLength);
683 return FALSE;
684 }
685
686 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, *length))
687 return FALSE;
688
689 return TRUE;
690}
691
702BOOL rdp_write_header(rdpRdp* rdp, wStream* s, size_t length, UINT16 channelId, UINT16 sec_flags)
703{
704 WINPR_ASSERT(rdp);
705 WINPR_ASSERT(rdp->settings);
706 WINPR_ASSERT(s);
707 WINPR_ASSERT(length >= RDP_PACKET_HEADER_MAX_LENGTH);
708 if (length > UINT16_MAX)
709 return FALSE;
710
711 DomainMCSPDU MCSPDU = (rdp->settings->ServerMode) ? DomainMCSPDU_SendDataIndication
712 : DomainMCSPDU_SendDataRequest;
713
714 if ((sec_flags & SEC_ENCRYPT) && (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS))
715 {
716 const UINT16 body_length = (UINT16)length - RDP_PACKET_HEADER_MAX_LENGTH;
717 const UINT16 pad = 8 - (body_length % 8);
718
719 if (pad != 8)
720 length += pad;
721 }
722
723 if (!mcs_write_domain_mcspdu_header(s, MCSPDU, (UINT16)length, 0))
724 return FALSE;
725 if (!per_write_integer16(s, rdp->mcs->userId, MCS_BASE_CHANNEL_ID)) /* initiator */
726 return FALSE;
727 if (!per_write_integer16(s, channelId, 0)) /* channelId */
728 return FALSE;
729 if (!Stream_EnsureRemainingCapacity(s, 3))
730 return FALSE;
731 Stream_Write_UINT8(s, 0x70); /* dataPriority + segmentation */
732 /*
733 * We always encode length in two bytes, even though we could use
734 * only one byte if length <= 0x7F. It is just easier that way,
735 * because we can leave room for fixed-length header, store all
736 * the data first and then store the header.
737 */
738 length = (length - RDP_PACKET_HEADER_MAX_LENGTH) | 0x8000;
739 Stream_Write_UINT16_BE(
740 s, WINPR_ASSERTING_INT_CAST(uint16_t, length)); /* userData (OCTET_STRING) */
741 return TRUE;
742}
743
744WINPR_ATTR_NODISCARD
745static BOOL rdp_security_stream_out(rdpRdp* rdp, wStream* s, size_t length, UINT16 sec_flags,
746 UINT32* pad)
747{
748 BOOL status = 0;
749 WINPR_ASSERT(rdp);
750 if (length > UINT16_MAX)
751 return FALSE;
752
753 *pad = 0;
754
755 if (sec_flags != 0)
756 {
757 WINPR_ASSERT(sec_flags <= UINT16_MAX);
758 if (!rdp_write_security_header(rdp, s, sec_flags))
759 return FALSE;
760
761 if (sec_flags & SEC_ENCRYPT)
762 {
763 if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
764 {
765 BYTE* data = Stream_PointerAs(s, BYTE) + 12;
766 const size_t size = WINPR_ASSERTING_INT_CAST(size_t, (data - Stream_Buffer(s)));
767 if (size > length)
768 return FALSE;
769
770 length -= size;
771
772 Stream_Write_UINT16(s, 0x10); /* length */
773 Stream_Write_UINT8(s, 0x1); /* TSFIPS_VERSION 1*/
774 /* handle padding */
775 *pad = 8 - (length % 8);
776
777 if (*pad == 8)
778 *pad = 0;
779
780 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, s, length + *pad))
781 return FALSE;
782
783 if (*pad)
784 memset(data + length, 0, *pad);
785
786 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, *pad));
787
788 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, s, 8))
789 return FALSE;
790 if (!security_hmac_signature(data, length, Stream_Pointer(s), 8, rdp))
791 return FALSE;
792
793 Stream_Seek(s, 8);
794 if (!security_fips_encrypt(data, length + *pad, rdp))
795 return FALSE;
796 }
797 else
798 {
799 const BYTE* data = Stream_PointerAs(s, const BYTE) + 8;
800 const size_t diff = Stream_GetPosition(s) + 8ULL;
801 if (diff > length)
802 return FALSE;
803 length -= diff;
804
805 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, s, 8))
806 return FALSE;
807 if (sec_flags & SEC_SECURE_CHECKSUM)
808 status = security_salted_mac_signature(rdp, data, (UINT32)length, TRUE,
809 Stream_Pointer(s), 8);
810 else
811 status = security_mac_signature(rdp, data, (UINT32)length,
812 Stream_PointerAs(s, BYTE), 8);
813
814 if (!status)
815 return FALSE;
816
817 Stream_Seek(s, 8);
818
819 if (!security_encrypt(Stream_Pointer(s), length, rdp))
820 return FALSE;
821 }
822 }
823 }
824
825 return TRUE;
826}
827
828WINPR_ATTR_NODISCARD
829static UINT32 rdp_get_sec_bytes(rdpRdp* rdp, UINT16 sec_flags)
830{
831 UINT32 sec_bytes = 0;
832
833 if (sec_flags & SEC_ENCRYPT)
834 {
835 sec_bytes = 12;
836
837 if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
838 sec_bytes += 4;
839 }
840 else if (sec_flags != 0)
841 {
842 sec_bytes = 4;
843 }
844 else
845 {
846 sec_bytes = 0;
847 }
848
849 return sec_bytes;
850}
851
852BOOL rdp_send(rdpRdp* rdp, wStream* s, UINT16 channelId, UINT16 sec_flags)
853{
854 BOOL rc = FALSE;
855 UINT32 pad = 0;
856 BOOL should_unlock = FALSE;
857
858 if (!s)
859 return FALSE;
860
861 if (!rdp)
862 goto fail;
863
864 if (sec_flags & SEC_ENCRYPT)
865 {
866 security_lock(rdp);
867 should_unlock = TRUE;
868 }
869
870 {
871 size_t length = Stream_GetPosition(s);
872 Stream_ResetPosition(s);
873 if (!rdp_write_header(rdp, s, length, channelId, sec_flags))
874 goto fail;
875
876 if (!rdp_security_stream_out(rdp, s, length, sec_flags, &pad))
877 goto fail;
878
879 length += pad;
880 if (!Stream_SetPosition(s, length))
881 goto fail;
882 Stream_SealLength(s);
883 }
884
885 if (transport_write(rdp->transport, s) < 0)
886 goto fail;
887
888 rc = TRUE;
889fail:
890 if (should_unlock)
891 security_unlock(rdp);
892 Stream_Release(s);
893 return rc;
894}
895
896BOOL rdp_send_pdu(rdpRdp* rdp, wStream* s, UINT16 type, UINT16 channel_id, UINT16 sec_flags)
897{
898 BOOL rc = FALSE;
899 UINT32 sec_bytes = 0;
900 size_t sec_hold = 0;
901 UINT32 pad = 0;
902 BOOL should_unlock = FALSE;
903
904 if (!s)
905 return FALSE;
906
907 if (!rdp)
908 goto fail;
909
910 if (sec_flags & SEC_ENCRYPT)
911 {
912 security_lock(rdp);
913 should_unlock = TRUE;
914 }
915
916 {
917 size_t length = Stream_GetPosition(s);
918 Stream_ResetPosition(s);
919 if (!rdp_write_header(rdp, s, length, MCS_GLOBAL_CHANNEL_ID, sec_flags))
920 goto fail;
921 sec_bytes = rdp_get_sec_bytes(rdp, sec_flags);
922 sec_hold = Stream_GetPosition(s);
923 Stream_Seek(s, sec_bytes);
924 if (!rdp_write_share_control_header(rdp, s, length - sec_bytes, type, channel_id))
925 goto fail;
926 if (!Stream_SetPosition(s, sec_hold))
927 goto fail;
928
929 if (!rdp_security_stream_out(rdp, s, length, sec_flags, &pad))
930 goto fail;
931
932 length += pad;
933 if (!Stream_SetPosition(s, length))
934 goto fail;
935 Stream_SealLength(s);
936 }
937
938 if (transport_write(rdp->transport, s) < 0)
939 goto fail;
940
941 rc = TRUE;
942fail:
943 if (should_unlock)
944 security_unlock(rdp);
945 return rc;
946}
947
948BOOL rdp_send_data_pdu(rdpRdp* rdp, wStream* s, BYTE type, UINT16 channel_id, UINT16 sec_flags)
949{
950 BOOL rc = FALSE;
951 UINT32 sec_bytes = 0;
952 size_t sec_hold = 0;
953 UINT32 pad = 0;
954 BOOL should_unlock = FALSE;
955
956 if (!s)
957 return FALSE;
958
959 if (!rdp)
960 goto fail;
961
962 if (sec_flags & SEC_ENCRYPT)
963 {
964 security_lock(rdp);
965 should_unlock = TRUE;
966 }
967
968 {
969 size_t length = Stream_GetPosition(s);
970 Stream_ResetPosition(s);
971 if (!rdp_write_header(rdp, s, length, MCS_GLOBAL_CHANNEL_ID, sec_flags))
972 goto fail;
973 sec_bytes = rdp_get_sec_bytes(rdp, sec_flags);
974 sec_hold = Stream_GetPosition(s);
975 Stream_Seek(s, sec_bytes);
976 if (!rdp_write_share_control_header(rdp, s, length - sec_bytes, PDU_TYPE_DATA, channel_id))
977 goto fail;
978 if (!rdp_write_share_data_header(rdp, s, length - sec_bytes, type, rdp->settings->ShareId))
979 goto fail;
980 if (!Stream_SetPosition(s, sec_hold))
981 goto fail;
982
983 if (!rdp_security_stream_out(rdp, s, length, sec_flags, &pad))
984 goto fail;
985
986 length += pad;
987 if (!Stream_SetPosition(s, length))
988 goto fail;
989 Stream_SealLength(s);
990 }
991 WLog_Print(rdp->log, WLOG_DEBUG,
992 "sending data (type=0x%x size=%" PRIuz " channelId=%" PRIu16 ")", type,
993 Stream_Length(s), channel_id);
994
995 rdp->outPackets++;
996 if (transport_write(rdp->transport, s) < 0)
997 goto fail;
998
999 rc = TRUE;
1000fail:
1001 if (should_unlock)
1002 security_unlock(rdp);
1003 Stream_Release(s);
1004 return rc;
1005}
1006
1007BOOL rdp_send_message_channel_pdu(rdpRdp* rdp, wStream* s, UINT16 sec_flags)
1008{
1009 BOOL rc = FALSE;
1010 UINT32 pad = 0;
1011 BOOL should_unlock = FALSE;
1012
1013 WINPR_ASSERT(rdp);
1014 WINPR_ASSERT(s);
1015
1016 if (sec_flags & SEC_ENCRYPT)
1017 {
1018 security_lock(rdp);
1019 should_unlock = TRUE;
1020 }
1021
1022 {
1023 size_t length = Stream_GetPosition(s);
1024 Stream_ResetPosition(s);
1025 if (!rdp_write_header(rdp, s, length, rdp->mcs->messageChannelId, sec_flags))
1026 goto fail;
1027
1028 if (!rdp_security_stream_out(rdp, s, length, sec_flags, &pad))
1029 goto fail;
1030
1031 length += pad;
1032 if (!Stream_SetPosition(s, length))
1033 goto fail;
1034 }
1035 Stream_SealLength(s);
1036
1037 if (transport_write(rdp->transport, s) < 0)
1038 goto fail;
1039
1040 rc = TRUE;
1041fail:
1042 if (should_unlock)
1043 security_unlock(rdp);
1044
1045 Stream_Release(s);
1046 return rc;
1047}
1048
1049WINPR_ATTR_NODISCARD
1050static BOOL rdp_recv_server_shutdown_denied_pdu(WINPR_ATTR_UNUSED rdpRdp* rdp,
1051 WINPR_ATTR_UNUSED wStream* s)
1052{
1053 return TRUE;
1054}
1055
1056WINPR_ATTR_NODISCARD
1057static BOOL rdp_recv_server_set_keyboard_indicators_pdu(rdpRdp* rdp, wStream* s)
1058{
1059 WINPR_ASSERT(rdp);
1060 WINPR_ASSERT(s);
1061
1062 rdpContext* context = rdp->context;
1063 WINPR_ASSERT(context);
1064 WINPR_ASSERT(context->update);
1065
1066 if (!rdp_has_reached_state(rdp, CONNECTION_STATE_ACTIVE))
1067 return FALSE;
1068
1069 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 4))
1070 return FALSE;
1071
1072 const uint16_t unitId = Stream_Get_UINT16(s); /* unitId (2 bytes) */
1073 if (unitId != 0)
1074 {
1075 WLog_Print(rdp->log, WLOG_WARN,
1076 "[MS-RDPBCGR] 2.2.8.2.1.1 Set Keyboard Indicators PDU Data "
1077 "(TS_SET_KEYBOARD_INDICATORS_PDU)::unitId should be 0, is %" PRIu16,
1078 unitId);
1079 }
1080 const UINT16 ledFlags = Stream_Get_UINT16(s); /* ledFlags (2 bytes) */
1081 return IFCALLRESULT(TRUE, context->update->SetKeyboardIndicators, context, ledFlags);
1082}
1083
1084WINPR_ATTR_NODISCARD
1085static BOOL rdp_recv_server_set_keyboard_ime_status_pdu(rdpRdp* rdp, wStream* s)
1086{
1087 if (!rdp || !rdp->input)
1088 return FALSE;
1089
1090 if (!rdp_has_reached_state(rdp, CONNECTION_STATE_ACTIVE))
1091 return FALSE;
1092
1093 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 10))
1094 return FALSE;
1095
1096 const uint16_t unitId = Stream_Get_UINT16(s); /* unitId (2 bytes) */
1097 if (unitId != 0)
1098 {
1099 WLog_Print(rdp->log, WLOG_WARN,
1100 "[MS-RDPBCGR] 2.2.8.2.2.1 Set Keyboard IME Status PDU Data "
1101 "(TS_SET_KEYBOARD_IME_STATUS_PDU)::unitId should be 0, is %" PRIu16,
1102 unitId);
1103 }
1104 const uint32_t imeState = Stream_Get_UINT32(s); /* imeState (4 bytes) */
1105 const uint32_t imeConvMode = Stream_Get_UINT32(s); /* imeConvMode (4 bytes) */
1106 return IFCALLRESULT(TRUE, rdp->update->SetKeyboardImeStatus, rdp->context, unitId, imeState,
1107 imeConvMode);
1108}
1109
1110WINPR_ATTR_NODISCARD
1111static BOOL rdp_recv_set_error_info_data_pdu(rdpRdp* rdp, wStream* s)
1112{
1113 UINT32 errorInfo = 0;
1114
1115 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 4))
1116 return FALSE;
1117
1118 Stream_Read_UINT32(s, errorInfo); /* errorInfo (4 bytes) */
1119 return rdp_set_error_info(rdp, errorInfo);
1120}
1121
1122WINPR_ATTR_NODISCARD
1123static BOOL rdp_recv_server_auto_reconnect_status_pdu(rdpRdp* rdp, wStream* s)
1124{
1125 UINT32 arcStatus = 0;
1126
1127 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 4))
1128 return FALSE;
1129
1130 Stream_Read_UINT32(s, arcStatus); /* arcStatus (4 bytes) */
1131 WLog_Print(rdp->log, WLOG_WARN, "AutoReconnectStatus: 0x%08" PRIX32 "", arcStatus);
1132 return TRUE;
1133}
1134
1135WINPR_ATTR_NODISCARD
1136static BOOL rdp_recv_server_status_info_pdu(rdpRdp* rdp, wStream* s)
1137{
1138 UINT32 statusCode = 0;
1139
1140 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 4))
1141 return FALSE;
1142
1143 Stream_Read_UINT32(s, statusCode); /* statusCode (4 bytes) */
1144
1145 if (rdp->update->ServerStatusInfo)
1146 return rdp->update->ServerStatusInfo(rdp->context, statusCode);
1147
1148 return TRUE;
1149}
1150
1151static void log_monitor(size_t idx, const MONITOR_DEF* monitor, wLog* log, DWORD level)
1152{
1153 WINPR_ASSERT(monitor);
1154
1155 WLog_Print(log, level, "[%" PRIuz "] {%dx%d-%dx%d} [0x%08" PRIx32 "]", idx, monitor->left,
1156 monitor->top, monitor->right, monitor->bottom, monitor->flags);
1157}
1158
1159static void log_monitor_configuration(wLog* log, const MONITOR_DEF* monitors, size_t count)
1160{
1161 const DWORD level = WLOG_DEBUG;
1162 WLog_Print(log, level, "[BEGIN] RemoteMonitors[%" PRIuz "]", count);
1163 for (size_t x = 0; x < count; x++)
1164 {
1165 const MONITOR_DEF* monitor = &monitors[x];
1166 log_monitor(x, monitor, log, level);
1167 }
1168 WLog_Print(log, level, "[END] RemoteMonitors[%" PRIuz "]", count);
1169}
1170
1171WINPR_ATTR_NODISCARD
1172static BOOL rdp_recv_monitor_layout_pdu(rdpRdp* rdp, wStream* s)
1173{
1174 BOOL ret = TRUE;
1175
1176 WINPR_ASSERT(rdp);
1177
1178 if (!rdp_has_reached_state(rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE_MONITOR_LAYOUT))
1179 return FALSE;
1180
1181 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 4))
1182 return FALSE;
1183
1184 const UINT32 monitorCount = Stream_Get_UINT32(s); /* monitorCount (4 bytes) */
1185
1186 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(rdp->log, s, monitorCount, 20ull))
1187 return FALSE;
1188
1189 MONITOR_DEF* monitorDefArray = (MONITOR_DEF*)calloc(monitorCount, sizeof(MONITOR_DEF));
1190
1191 if (!monitorDefArray)
1192 return FALSE;
1193
1194 for (UINT32 index = 0; index < monitorCount; index++)
1195 {
1196 MONITOR_DEF* monitor = &monitorDefArray[index];
1197 Stream_Read_INT32(s, monitor->left); /* left (4 bytes) */
1198 Stream_Read_INT32(s, monitor->top); /* top (4 bytes) */
1199 Stream_Read_INT32(s, monitor->right); /* right (4 bytes) */
1200 Stream_Read_INT32(s, monitor->bottom); /* bottom (4 bytes) */
1201 Stream_Read_UINT32(s, monitor->flags); /* flags (4 bytes) */
1202 }
1203
1204 log_monitor_configuration(rdp->log, monitorDefArray, monitorCount);
1205 IFCALLRET(rdp->update->RemoteMonitors, ret, rdp->context, monitorCount, monitorDefArray);
1206 free(monitorDefArray);
1207 if (!ret)
1208 return FALSE;
1209 return rdp_set_monitor_layout_pdu_state(rdp, TRUE);
1210}
1211
1212state_run_t rdp_recv_data_pdu(rdpRdp* rdp, wStream* s)
1213{
1214 BYTE type = 0;
1215 wStream* cs = nullptr;
1216 UINT16 length = 0;
1217 UINT32 shareId = 0;
1218 BYTE compressedType = 0;
1219 UINT16 compressedLength = 0;
1220
1221 WINPR_ASSERT(rdp);
1222 if (!rdp_read_share_data_header(rdp, s, &length, &type, &shareId, &compressedType,
1223 &compressedLength))
1224 {
1225 WLog_Print(rdp->log, WLOG_ERROR, "rdp_read_share_data_header() failed");
1226 return STATE_RUN_FAILED;
1227 }
1228
1229 cs = s;
1230
1231 if (compressedType & PACKET_COMPRESSED)
1232 {
1233 if (compressedLength < 18)
1234 {
1235 WLog_Print(rdp->log, WLOG_ERROR,
1236 "bulk_decompress: not enough bytes for compressedLength %" PRIu16 "",
1237 compressedLength);
1238 return STATE_RUN_FAILED;
1239 }
1240
1241 UINT32 DstSize = 0;
1242 const BYTE* pDstData = nullptr;
1243 UINT16 SrcSize = compressedLength - 18;
1244
1245 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, SrcSize))
1246 {
1247 WLog_Print(rdp->log, WLOG_ERROR,
1248 "bulk_decompress: not enough bytes for compressedLength %" PRIu16 "",
1249 compressedLength);
1250 return STATE_RUN_FAILED;
1251 }
1252
1253 if (bulk_decompress(rdp->bulk, Stream_ConstPointer(s), SrcSize, &pDstData, &DstSize,
1254 compressedType))
1255 {
1256 cs = transport_take_from_pool(rdp->transport, DstSize);
1257 if (!cs)
1258 {
1259 WLog_Print(rdp->log, WLOG_ERROR, "Couldn't take stream from pool");
1260 return STATE_RUN_FAILED;
1261 }
1262
1263 Stream_ResetPosition(cs);
1264 Stream_Write(cs, pDstData, DstSize);
1265 Stream_SealLength(cs);
1266 Stream_ResetPosition(cs);
1267 }
1268 else
1269 {
1270 WLog_Print(rdp->log, WLOG_ERROR, "bulk_decompress() failed");
1271 return STATE_RUN_FAILED;
1272 }
1273
1274 Stream_Seek(s, SrcSize);
1275 }
1276
1277 WLog_Print(rdp->log, WLOG_DEBUG, "recv %s Data PDU (0x%02" PRIX8 "), length: %" PRIu16 "",
1278 data_pdu_type_to_string(type), type, length);
1279
1280 switch (type)
1281 {
1282 case DATA_PDU_TYPE_UPDATE:
1283 if (!update_recv(rdp->update, cs))
1284 {
1285 WLog_Print(rdp->log, WLOG_ERROR, "DATA_PDU_TYPE_UPDATE - update_recv() failed");
1286 goto out_fail;
1287 }
1288
1289 break;
1290
1291 case DATA_PDU_TYPE_CONTROL:
1292 if (!rdp_recv_server_control_pdu(rdp, cs))
1293 {
1294 WLog_Print(rdp->log, WLOG_ERROR,
1295 "DATA_PDU_TYPE_CONTROL - rdp_recv_server_control_pdu() failed");
1296 goto out_fail;
1297 }
1298
1299 break;
1300
1301 case DATA_PDU_TYPE_POINTER:
1302 if (!update_recv_pointer(rdp->update, cs))
1303 {
1304 WLog_Print(rdp->log, WLOG_ERROR,
1305 "DATA_PDU_TYPE_POINTER - update_recv_pointer() failed");
1306 goto out_fail;
1307 }
1308
1309 break;
1310
1311 case DATA_PDU_TYPE_SYNCHRONIZE:
1312 if (!rdp_recv_server_synchronize_pdu(rdp, cs))
1313 {
1314 WLog_Print(rdp->log, WLOG_ERROR,
1315 "DATA_PDU_TYPE_SYNCHRONIZE - rdp_recv_synchronize_pdu() failed");
1316 goto out_fail;
1317 }
1318
1319 break;
1320
1321 case DATA_PDU_TYPE_PLAY_SOUND:
1322 if (!update_recv_play_sound(rdp->update, cs))
1323 {
1324 WLog_Print(rdp->log, WLOG_ERROR,
1325 "DATA_PDU_TYPE_PLAY_SOUND - update_recv_play_sound() failed");
1326 goto out_fail;
1327 }
1328
1329 break;
1330
1331 case DATA_PDU_TYPE_SHUTDOWN_DENIED:
1332 if (!rdp_recv_server_shutdown_denied_pdu(rdp, cs))
1333 {
1334 WLog_Print(
1335 rdp->log, WLOG_ERROR,
1336 "DATA_PDU_TYPE_SHUTDOWN_DENIED - rdp_recv_server_shutdown_denied_pdu() failed");
1337 goto out_fail;
1338 }
1339
1340 break;
1341
1342 case DATA_PDU_TYPE_SAVE_SESSION_INFO:
1343 if (!rdp_recv_save_session_info(rdp, cs))
1344 {
1345 WLog_Print(rdp->log, WLOG_ERROR,
1346 "DATA_PDU_TYPE_SAVE_SESSION_INFO - rdp_recv_save_session_info() failed");
1347 goto out_fail;
1348 }
1349
1350 break;
1351
1352 case DATA_PDU_TYPE_FONT_MAP:
1353 if (!rdp_recv_font_map_pdu(rdp, cs))
1354 {
1355 WLog_Print(rdp->log, WLOG_ERROR,
1356 "DATA_PDU_TYPE_FONT_MAP - rdp_recv_font_map_pdu() failed");
1357 goto out_fail;
1358 }
1359
1360 break;
1361
1362 case DATA_PDU_TYPE_SET_KEYBOARD_INDICATORS:
1363 if (!rdp_recv_server_set_keyboard_indicators_pdu(rdp, cs))
1364 {
1365 WLog_Print(rdp->log, WLOG_ERROR,
1366 "DATA_PDU_TYPE_SET_KEYBOARD_INDICATORS - "
1367 "rdp_recv_server_set_keyboard_indicators_pdu() failed");
1368 goto out_fail;
1369 }
1370
1371 break;
1372
1373 case DATA_PDU_TYPE_SET_KEYBOARD_IME_STATUS:
1374 if (!rdp_recv_server_set_keyboard_ime_status_pdu(rdp, cs))
1375 {
1376 WLog_Print(rdp->log, WLOG_ERROR,
1377 "DATA_PDU_TYPE_SET_KEYBOARD_IME_STATUS - "
1378 "rdp_recv_server_set_keyboard_ime_status_pdu() failed");
1379 goto out_fail;
1380 }
1381
1382 break;
1383
1384 case DATA_PDU_TYPE_SET_ERROR_INFO:
1385 if (!rdp_recv_set_error_info_data_pdu(rdp, cs))
1386 {
1387 WLog_Print(
1388 rdp->log, WLOG_ERROR,
1389 "DATA_PDU_TYPE_SET_ERROR_INFO - rdp_recv_set_error_info_data_pdu() failed");
1390 goto out_fail;
1391 }
1392
1393 break;
1394
1395 case DATA_PDU_TYPE_ARC_STATUS:
1396 if (!rdp_recv_server_auto_reconnect_status_pdu(rdp, cs))
1397 {
1398 WLog_Print(rdp->log, WLOG_ERROR,
1399 "DATA_PDU_TYPE_ARC_STATUS - "
1400 "rdp_recv_server_auto_reconnect_status_pdu() failed");
1401 goto out_fail;
1402 }
1403
1404 break;
1405
1406 case DATA_PDU_TYPE_STATUS_INFO:
1407 if (!rdp_recv_server_status_info_pdu(rdp, cs))
1408 {
1409 WLog_Print(rdp->log, WLOG_ERROR,
1410 "DATA_PDU_TYPE_STATUS_INFO - rdp_recv_server_status_info_pdu() failed");
1411 goto out_fail;
1412 }
1413
1414 break;
1415
1416 case DATA_PDU_TYPE_MONITOR_LAYOUT:
1417 if (!rdp_recv_monitor_layout_pdu(rdp, cs))
1418 {
1419 WLog_Print(rdp->log, WLOG_ERROR,
1420 "DATA_PDU_TYPE_MONITOR_LAYOUT - rdp_recv_monitor_layout_pdu() failed");
1421 goto out_fail;
1422 }
1423
1424 break;
1425
1426 default:
1427 WLog_Print(rdp->log, WLOG_WARN,
1428 "[UNHANDLED] %s Data PDU (0x%02" PRIX8 "), length: %" PRIu16 "",
1429 data_pdu_type_to_string(type), type, length);
1430 break;
1431 }
1432
1433 if (cs != s)
1434 Stream_Release(cs);
1435
1436 return STATE_RUN_SUCCESS;
1437out_fail:
1438
1439 if (cs != s)
1440 Stream_Release(cs);
1441
1442 return STATE_RUN_FAILED;
1443}
1444
1445state_run_t rdp_recv_message_channel_pdu(rdpRdp* rdp, wStream* s, UINT16 securityFlags)
1446{
1447 WINPR_ASSERT(rdp);
1448 WINPR_ASSERT(s);
1449
1450 if (securityFlags & SEC_AUTODETECT_REQ)
1451 {
1452 /* Server Auto-Detect Request PDU */
1453 return autodetect_recv_request_packet(rdp->autodetect, RDP_TRANSPORT_TCP, s);
1454 }
1455
1456 if (securityFlags & SEC_AUTODETECT_RSP)
1457 {
1458 /* Client Auto-Detect Response PDU */
1459 return autodetect_recv_response_packet(rdp->autodetect, RDP_TRANSPORT_TCP, s);
1460 }
1461
1462 if (securityFlags & SEC_HEARTBEAT)
1463 {
1464 /* Heartbeat PDU */
1465 return rdp_recv_heartbeat_packet(rdp, s);
1466 }
1467
1468 if (securityFlags & SEC_TRANSPORT_REQ)
1469 {
1470 return multitransport_recv_request(rdp->multitransport, s);
1471 }
1472
1473 if (securityFlags & SEC_TRANSPORT_RSP)
1474 {
1475 return multitransport_recv_response(rdp->multitransport, s);
1476 }
1477
1478 if (securityFlags & SEC_LICENSE_PKT)
1479 {
1480 return license_recv(rdp->license, s);
1481 }
1482
1483 if (securityFlags & SEC_LICENSE_ENCRYPT_CS)
1484 {
1485 return license_recv(rdp->license, s);
1486 }
1487
1488 if (securityFlags & SEC_LICENSE_ENCRYPT_SC)
1489 {
1490 return license_recv(rdp->license, s);
1491 }
1492
1493 return STATE_RUN_SUCCESS;
1494}
1495
1496state_run_t rdp_recv_out_of_sequence_pdu(rdpRdp* rdp, wStream* s, UINT16 pduType, UINT16 length)
1497{
1498 state_run_t rc = STATE_RUN_FAILED;
1499 WINPR_ASSERT(rdp);
1500
1501 switch (pduType)
1502 {
1503 case PDU_TYPE_DATA:
1504 rc = rdp_recv_data_pdu(rdp, s);
1505 break;
1506 case PDU_TYPE_SERVER_REDIRECTION:
1507 rc = rdp_recv_enhanced_security_redirection_packet(rdp, s);
1508 break;
1509 case PDU_TYPE_FLOW_RESPONSE:
1510 case PDU_TYPE_FLOW_STOP:
1511 case PDU_TYPE_FLOW_TEST:
1512 rc = STATE_RUN_SUCCESS;
1513 break;
1514 default:
1515 {
1516 char buffer1[256] = WINPR_C_ARRAY_INIT;
1517 char buffer2[256] = WINPR_C_ARRAY_INIT;
1518
1519 WLog_Print(rdp->log, WLOG_ERROR, "expected %s, got %s",
1520 pdu_type_to_str(PDU_TYPE_DEMAND_ACTIVE, buffer1, sizeof(buffer1)),
1521 pdu_type_to_str(pduType, buffer2, sizeof(buffer2)));
1522 rc = STATE_RUN_FAILED;
1523 }
1524 break;
1525 }
1526
1527 if (!tpkt_ensure_stream_consumed(rdp->log, s, length))
1528 return STATE_RUN_FAILED;
1529 return rc;
1530}
1531
1532BOOL rdp_read_flow_control_pdu(rdpRdp* rdp, wStream* s, UINT16* type, UINT16* channel_id)
1533{
1534 /*
1535 * Read flow control PDU - documented in FlowPDU section in T.128
1536 * http://www.itu.int/rec/T-REC-T.128-199802-S/en
1537 * The specification for the PDU has pad8bits listed BEFORE pduTypeFlow.
1538 * However, so far pad8bits has always been observed to arrive AFTER pduTypeFlow.
1539 * Switched the order of these two fields to match this observation.
1540 */
1541 UINT8 pduType = 0;
1542
1543 WINPR_ASSERT(rdp);
1544 WINPR_ASSERT(s);
1545 WINPR_ASSERT(type);
1546 WINPR_ASSERT(channel_id);
1547
1548 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 6))
1549 return FALSE;
1550 Stream_Read_UINT8(s, pduType); /* pduTypeFlow */
1551 *type = pduType;
1552 Stream_Seek_UINT8(s); /* pad8bits */
1553 Stream_Seek_UINT8(s); /* flowIdentifier */
1554 Stream_Seek_UINT8(s); /* flowNumber */
1555 Stream_Read_UINT16(s, *channel_id); /* pduSource */
1556 return TRUE;
1557}
1558
1570BOOL rdp_decrypt(rdpRdp* rdp, wStream* s, UINT16* pLength, UINT16 securityFlags)
1571{
1572 BOOL res = FALSE;
1573 BYTE cmac[8] = WINPR_C_ARRAY_INIT;
1574 BYTE wmac[8] = WINPR_C_ARRAY_INIT;
1575 BOOL status = FALSE;
1576
1577 WINPR_ASSERT(rdp);
1578 WINPR_ASSERT(rdp->settings);
1579 WINPR_ASSERT(s);
1580 WINPR_ASSERT(pLength);
1581
1582 security_lock(rdp);
1583
1584 INT32 length = *pLength;
1585 if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_NONE)
1586 {
1587 res = TRUE;
1588 goto unlock;
1589 }
1590
1591 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, *pLength))
1592 goto unlock;
1593
1594 if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
1595 {
1596 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 12))
1597 goto unlock;
1598
1599 UINT16 len = 0;
1600 Stream_Read_UINT16(s, len); /* 0x10 */
1601 if (len != 0x10)
1602 WLog_Print(rdp->log, WLOG_WARN, "ENCRYPTION_METHOD_FIPS length %" PRIu16 " != 0x10",
1603 len);
1604
1605 UINT16 version = 0;
1606 Stream_Read_UINT8(s, version); /* 0x1 */
1607 if (version != 1)
1608 WLog_Print(rdp->log, WLOG_WARN, "ENCRYPTION_METHOD_FIPS version %" PRIu16 " != 1",
1609 version);
1610
1611 BYTE pad = 0;
1612 Stream_Read_UINT8(s, pad);
1613 const BYTE* sig = Stream_ConstPointer(s);
1614 Stream_Seek(s, 8); /* signature */
1615 length -= 12;
1616 const INT32 padLength = length - pad;
1617
1618 if ((length <= 0) || (padLength <= 0) || (padLength > UINT16_MAX))
1619 {
1620 WLog_Print(rdp->log, WLOG_ERROR, "FATAL: invalid pad length %" PRId32, padLength);
1621 goto unlock;
1622 }
1623
1624 /* The 3DES CBC context has padding disabled and lives for the whole connection: an
1625 * incomplete block would be kept in it and prepended to the data of the next PDU, which
1626 * then decrypts to more bytes than it has. The sender pads to whole blocks (padlen). */
1627 if ((length % 8) != 0)
1628 {
1629 WLog_Print(rdp->log, WLOG_ERROR,
1630 "FATAL: FIPS data length %" PRId32 " is not a multiple of 3DES block size",
1631 length);
1632 goto unlock;
1633 }
1634
1635 if (!security_fips_decrypt(Stream_Pointer(s), (size_t)length, rdp))
1636 goto unlock;
1637
1638 if (!security_fips_check_signature(Stream_ConstPointer(s), (size_t)padLength, sig, 8, rdp))
1639 goto unlock;
1640
1641 if (!Stream_SetLength(s, Stream_Length(s) - pad))
1642 goto unlock;
1643
1644 *pLength = (UINT16)padLength;
1645 }
1646 else
1647 {
1648 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, sizeof(wmac)))
1649 goto unlock;
1650
1651 Stream_Read(s, wmac, sizeof(wmac));
1652 length -= sizeof(wmac);
1653
1654 if (length <= 0)
1655 {
1656 WLog_Print(rdp->log, WLOG_ERROR, "FATAL: invalid length field");
1657 goto unlock;
1658 }
1659
1660 if (!security_decrypt(Stream_PointerAs(s, BYTE), (size_t)length, rdp))
1661 goto unlock;
1662
1663 if (securityFlags & SEC_SECURE_CHECKSUM)
1664 status = security_salted_mac_signature(rdp, Stream_ConstPointer(s), (UINT32)length,
1665 FALSE, cmac, sizeof(cmac));
1666 else
1667 status = security_mac_signature(rdp, Stream_ConstPointer(s), (UINT32)length, cmac,
1668 sizeof(cmac));
1669
1670 if (!status)
1671 goto unlock;
1672
1673 if (memcmp(wmac, cmac, sizeof(wmac)) != 0)
1674 {
1675 WLog_Print(rdp->log, WLOG_ERROR, "WARNING: invalid packet signature");
1676 /*
1677 * Because Standard RDP Security is totally broken,
1678 * and cannot protect against MITM, don't treat signature
1679 * verification failure as critical. This at least enables
1680 * us to work with broken RDP clients and servers that
1681 * generate invalid signatures.
1682 */
1683 // return FALSE;
1684 }
1685
1686 *pLength = (UINT16)length;
1687 }
1688 res = TRUE;
1689unlock:
1690 security_unlock(rdp);
1691 return res;
1692}
1693
1694const char* pdu_type_to_str(UINT16 pduType, char* buffer, size_t length)
1695{
1696 const char* str = nullptr;
1697 switch (pduType)
1698 {
1699 case PDU_TYPE_DEMAND_ACTIVE:
1700 str = "PDU_TYPE_DEMAND_ACTIVE";
1701 break;
1702 case PDU_TYPE_CONFIRM_ACTIVE:
1703 str = "PDU_TYPE_CONFIRM_ACTIVE";
1704 break;
1705 case PDU_TYPE_DEACTIVATE_ALL:
1706 str = "PDU_TYPE_DEACTIVATE_ALL";
1707 break;
1708 case PDU_TYPE_DATA:
1709 str = "PDU_TYPE_DATA";
1710 break;
1711 case PDU_TYPE_SERVER_REDIRECTION:
1712 str = "PDU_TYPE_SERVER_REDIRECTION";
1713 break;
1714 case PDU_TYPE_FLOW_TEST:
1715 str = "PDU_TYPE_FLOW_TEST";
1716 break;
1717 case PDU_TYPE_FLOW_RESPONSE:
1718 str = "PDU_TYPE_FLOW_RESPONSE";
1719 break;
1720 case PDU_TYPE_FLOW_STOP:
1721 str = "PDU_TYPE_FLOW_STOP";
1722 break;
1723 default:
1724 str = "PDU_TYPE_UNKNOWN";
1725 break;
1726 }
1727
1728 winpr_str_append(str, buffer, length, "");
1729 {
1730 char msg[32] = WINPR_C_ARRAY_INIT;
1731 (void)_snprintf(msg, sizeof(msg), "[0x%08" PRIx32 "]", pduType);
1732 winpr_str_append(msg, buffer, length, "");
1733 }
1734 return buffer;
1735}
1736
1742WINPR_ATTR_NODISCARD
1743static state_run_t rdp_recv_tpkt_pdu(rdpRdp* rdp, wStream* s)
1744{
1745 state_run_t rc = STATE_RUN_SUCCESS;
1746 UINT16 length = 0;
1747 UINT16 pduType = 0;
1748 UINT16 pduSource = 0;
1749 UINT16 channelId = 0;
1750 UINT16 securityFlags = 0;
1751
1752 WINPR_ASSERT(rdp);
1753 WINPR_ASSERT(rdp->context);
1754 WINPR_ASSERT(s);
1755
1756 freerdp* instance = rdp->context->instance;
1757 WINPR_ASSERT(instance);
1758
1759 if (!rdp_read_header(rdp, s, &length, &channelId))
1760 return STATE_RUN_FAILED;
1761
1762 if (freerdp_shall_disconnect_context(rdp->context))
1763 return STATE_RUN_SUCCESS;
1764
1765 if (rdp->autodetect->bandwidthMeasureStarted)
1766 {
1767 rdp->autodetect->bandwidthMeasureByteCount += length;
1768 }
1769
1770 if (rdp->mcs->messageChannelId && (channelId == rdp->mcs->messageChannelId))
1771 {
1772 rdp->inPackets++;
1773 return rdp_handle_message_channel(rdp, s, channelId, length);
1774 }
1775
1776 if (rdp->settings->UseRdpSecurityLayer)
1777 {
1778 if (!rdp_read_security_header(rdp, s, &securityFlags, &length))
1779 return STATE_RUN_FAILED;
1780
1781 if (securityFlags & (SEC_ENCRYPT | SEC_REDIRECTION_PKT))
1782 {
1783 if (!rdp_decrypt(rdp, s, &length, securityFlags))
1784 return STATE_RUN_FAILED;
1785 }
1786
1787 if (securityFlags & SEC_REDIRECTION_PKT)
1788 {
1789 /*
1790 * [MS-RDPBCGR] 2.2.13.2.1
1791 * - no share control header, nor the 2 byte pad
1792 */
1793 Stream_Rewind(s, 2);
1794 rdp->inPackets++;
1795
1796 rc = rdp_recv_enhanced_security_redirection_packet(rdp, s);
1797 goto out;
1798 }
1799 }
1800
1801 if (channelId == MCS_GLOBAL_CHANNEL_ID)
1802 {
1803 while (Stream_GetRemainingLength(s) > 3)
1804 {
1805 wStream subbuffer;
1806 wStream* sub = nullptr;
1807 size_t diff = 0;
1808 UINT16 remain = 0;
1809
1810 if (!rdp_read_share_control_header(rdp, s, nullptr, &remain, &pduType, &pduSource))
1811 return STATE_RUN_FAILED;
1812
1813 sub = Stream_StaticInit(&subbuffer, Stream_Pointer(s), remain);
1814 if (!Stream_SafeSeek(s, remain))
1815 return STATE_RUN_FAILED;
1816
1817 rdp->settings->PduSource = pduSource;
1818 rdp->inPackets++;
1819
1820 switch (pduType)
1821 {
1822 case PDU_TYPE_DATA:
1823 rc = rdp_recv_data_pdu(rdp, sub);
1824 if (state_run_failed(rc))
1825 return rc;
1826 break;
1827
1828 case PDU_TYPE_DEACTIVATE_ALL:
1829 if (!rdp_recv_deactivate_all(rdp, sub))
1830 {
1831 WLog_Print(rdp->log, WLOG_ERROR,
1832 "rdp_recv_tpkt_pdu: rdp_recv_deactivate_all() fail");
1833 return STATE_RUN_FAILED;
1834 }
1835
1836 break;
1837
1838 case PDU_TYPE_SERVER_REDIRECTION:
1839 return rdp_recv_enhanced_security_redirection_packet(rdp, sub);
1840
1841 case PDU_TYPE_FLOW_RESPONSE:
1842 case PDU_TYPE_FLOW_STOP:
1843 case PDU_TYPE_FLOW_TEST:
1844 WLog_Print(rdp->log, WLOG_DEBUG, "flow message 0x%04" PRIX16 "", pduType);
1845 /* http://msdn.microsoft.com/en-us/library/cc240576.aspx */
1846 if (!Stream_SafeSeek(sub, remain))
1847 return STATE_RUN_FAILED;
1848 break;
1849
1850 default:
1851 {
1852 char buffer[256] = WINPR_C_ARRAY_INIT;
1853 WLog_Print(rdp->log, WLOG_ERROR, "incorrect PDU type: %s",
1854 pdu_type_to_str(pduType, buffer, sizeof(buffer)));
1855 }
1856 break;
1857 }
1858
1859 diff = Stream_GetRemainingLength(sub);
1860 if (diff > 0)
1861 {
1862 char buffer[256] = WINPR_C_ARRAY_INIT;
1863 WLog_Print(rdp->log, WLOG_WARN,
1864 "pduType %s not properly parsed, %" PRIuz
1865 " bytes remaining unhandled. Skipping.",
1866 pdu_type_to_str(pduType, buffer, sizeof(buffer)), diff);
1867 }
1868 }
1869 }
1870 else
1871 {
1872 rdp->inPackets++;
1873
1874 if (!freerdp_channel_process(instance, s, channelId, length))
1875 return STATE_RUN_FAILED;
1876 }
1877
1878out:
1879 if (!tpkt_ensure_stream_consumed(rdp->log, s, length))
1880 return STATE_RUN_FAILED;
1881 return rc;
1882}
1883
1884WINPR_ATTR_NODISCARD
1885static state_run_t rdp_recv_fastpath_pdu(rdpRdp* rdp, wStream* s)
1886{
1887 UINT16 length = 0;
1888
1889 WINPR_ASSERT(rdp);
1890 rdpFastPath* fastpath = rdp->fastpath;
1891
1892 if (!fastpath_read_header_rdp(fastpath, s, &length))
1893 {
1894 WLog_Print(rdp->log, WLOG_ERROR, "rdp_recv_fastpath_pdu: fastpath_read_header_rdp() fail");
1895 return STATE_RUN_FAILED;
1896 }
1897
1898 if ((length == 0) || (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, length)))
1899 {
1900 WLog_Print(rdp->log, WLOG_ERROR, "incorrect FastPath PDU header length %" PRIu16 "",
1901 length);
1902 return STATE_RUN_FAILED;
1903 }
1904
1905 if (rdp->autodetect->bandwidthMeasureStarted)
1906 {
1907 rdp->autodetect->bandwidthMeasureByteCount += length;
1908 }
1909
1910 if (!fastpath_decrypt(fastpath, s, &length))
1911 return STATE_RUN_FAILED;
1912
1913 return fastpath_recv_updates(rdp->fastpath, s);
1914}
1915
1916WINPR_ATTR_NODISCARD
1917static state_run_t rdp_recv_pdu(rdpRdp* rdp, wStream* s)
1918{
1919 const int rc = tpkt_verify_header(s);
1920 if (rc > 0)
1921 return rdp_recv_tpkt_pdu(rdp, s);
1922 else if (rc == 0)
1923 return rdp_recv_fastpath_pdu(rdp, s);
1924 else
1925 return STATE_RUN_FAILED;
1926}
1927
1928WINPR_ATTR_NODISCARD
1929static state_run_t rdp_handle_sc_flags(rdpRdp* rdp, wStream* s, UINT32 flag,
1930 CONNECTION_STATE nextState)
1931{
1932 const UINT32 mask = FINALIZE_SC_SYNCHRONIZE_PDU | FINALIZE_SC_CONTROL_COOPERATE_PDU |
1933 FINALIZE_SC_CONTROL_GRANTED_PDU | FINALIZE_SC_FONT_MAP_PDU;
1934 WINPR_ASSERT(rdp);
1935 state_run_t status = rdp_recv_pdu(rdp, s);
1936 if (state_run_success(status))
1937 {
1938 const UINT32 flags = rdp->finalize_sc_pdus & mask;
1939 if ((flags & flag) == flag)
1940 {
1941 if (!rdp_client_transition_to_state(rdp, nextState))
1942 status = STATE_RUN_FAILED;
1943 else
1944 status = STATE_RUN_SUCCESS;
1945 }
1946 else
1947 {
1948 char flag_buffer[256] = WINPR_C_ARRAY_INIT;
1949 char mask_buffer[256] = WINPR_C_ARRAY_INIT;
1950 WLog_Print(rdp->log, WLOG_WARN,
1951 "[%s] unexpected server message, expected flag %s [have %s]",
1952 rdp_get_state_string(rdp),
1953 rdp_finalize_flags_to_str(flag, flag_buffer, sizeof(flag_buffer)),
1954 rdp_finalize_flags_to_str(flags, mask_buffer, sizeof(mask_buffer)));
1955 }
1956 }
1957 return status;
1958}
1959
1960WINPR_ATTR_NODISCARD
1961static state_run_t rdp_client_exchange_monitor_layout(rdpRdp* rdp, wStream* s)
1962{
1963 WINPR_ASSERT(rdp);
1964
1965 if (!rdp_check_monitor_layout_pdu_state(rdp, FALSE))
1966 return STATE_RUN_FAILED;
1967
1968 /* We might receive unrelated messages from the server (channel traffic),
1969 * so only proceed if some flag changed
1970 */
1971 const UINT32 old = rdp->finalize_sc_pdus;
1972 state_run_t status = rdp_recv_pdu(rdp, s);
1973 const UINT32 now = rdp->finalize_sc_pdus;
1974 const BOOL changed = (old != now) || rdp->monitor_layout_pdu;
1975
1976 /* This PDU is optional, so if we received a finalize PDU continue there */
1977 if (state_run_success(status) && changed)
1978 {
1979 if (!rdp->monitor_layout_pdu)
1980 {
1981 if (!rdp_finalize_is_flag_set(rdp, FINALIZE_SC_SYNCHRONIZE_PDU))
1982 return STATE_RUN_FAILED;
1983 else if (!rdp_client_transition_to_state(rdp,
1984 CONNECTION_STATE_FINALIZATION_CLIENT_SYNC))
1985 return STATE_RUN_FAILED;
1986 else
1987 return STATE_RUN_TRY_AGAIN;
1988 }
1989
1990 /* The Monitor Layout PDU was consumed, wait for the server Synchronize PDU next.
1991 * Do not try again: the layout PDU must not be processed a second time. */
1992 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_FINALIZATION_CLIENT_SYNC))
1993 return STATE_RUN_FAILED;
1994 }
1995 return status;
1996}
1997
1998WINPR_ATTR_NODISCARD
1999static state_run_t rdp_recv_callback_int(WINPR_ATTR_UNUSED rdpTransport* transport, wStream* s,
2000 void* extra)
2001{
2002 state_run_t status = STATE_RUN_SUCCESS;
2003 rdpRdp* rdp = (rdpRdp*)extra;
2004
2005 WINPR_ASSERT(transport);
2006 WINPR_ASSERT(rdp);
2007 WINPR_ASSERT(s);
2008
2009 switch (rdp_get_state(rdp))
2010 {
2011 case CONNECTION_STATE_NEGO:
2012 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_CREATE_REQUEST))
2013 status = STATE_RUN_FAILED;
2014 else
2015 status = STATE_RUN_CONTINUE;
2016 break;
2017 case CONNECTION_STATE_NLA:
2018 if (nla_get_state(rdp->nla) < NLA_STATE_AUTH_INFO)
2019 {
2020 if (nla_recv_pdu(rdp->nla, s) < 1)
2021 {
2022 WLog_Print(rdp->log, WLOG_ERROR, "%s - nla_recv_pdu() fail",
2023 rdp_get_state_string(rdp));
2024 status = STATE_RUN_FAILED;
2025 }
2026 }
2027 else if (nla_get_state(rdp->nla) == NLA_STATE_POST_NEGO)
2028 {
2029 if (nego_recv(rdp->transport, s, (void*)rdp->nego) < 0)
2030 return STATE_RUN_FAILED;
2031
2032 if (!nego_update_settings_from_state(rdp->nego, rdp->settings))
2033 return STATE_RUN_FAILED;
2034
2035 if (nego_get_state(rdp->nego) != NEGO_STATE_FINAL)
2036 {
2037 WLog_Print(rdp->log, WLOG_ERROR, "%s - nego_recv() fail",
2038 rdp_get_state_string(rdp));
2039 status = STATE_RUN_FAILED;
2040 }
2041 else if (!nla_set_state(rdp->nla, NLA_STATE_FINAL))
2042 status = STATE_RUN_FAILED;
2043 }
2044
2045 if (state_run_success(status))
2046 {
2047 if (nla_get_state(rdp->nla) == NLA_STATE_AUTH_INFO)
2048 {
2049 transport_set_nla_mode(rdp->transport, FALSE);
2050
2051 if (rdp->settings->VmConnectMode)
2052 {
2053 if (!nego_set_state(rdp->nego, NEGO_STATE_NLA))
2054 status = STATE_RUN_FAILED;
2055 else if (!nego_set_requested_protocols(rdp->nego,
2056 PROTOCOL_HYBRID | PROTOCOL_SSL))
2057 status = STATE_RUN_FAILED;
2058 else if (!nego_send_negotiation_request(rdp->nego))
2059 status = STATE_RUN_FAILED;
2060 else if (!nla_set_state(rdp->nla, NLA_STATE_POST_NEGO))
2061 status = STATE_RUN_FAILED;
2062 }
2063 else
2064 {
2065 if (!nla_set_state(rdp->nla, NLA_STATE_FINAL))
2066 status = STATE_RUN_FAILED;
2067 }
2068 }
2069 }
2070 if (state_run_success(status))
2071 {
2072
2073 if (nla_get_state(rdp->nla) == NLA_STATE_FINAL)
2074 {
2075 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_CREATE_REQUEST))
2076 status = STATE_RUN_FAILED;
2077 else
2078 status = STATE_RUN_CONTINUE;
2079 }
2080 }
2081 break;
2082
2083 case CONNECTION_STATE_AAD:
2084 if (aad_recv(rdp->aad, s) < 1)
2085 {
2086 WLog_Print(rdp->log, WLOG_ERROR, "%s - aad_recv() fail", rdp_get_state_string(rdp));
2087 status = STATE_RUN_FAILED;
2088 }
2089 if (state_run_success(status))
2090 {
2091 if (aad_get_state(rdp->aad) == AAD_STATE_FINAL)
2092 {
2093 transport_set_aad_mode(rdp->transport, FALSE);
2094 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_CREATE_REQUEST))
2095 status = STATE_RUN_FAILED;
2096 else
2097 status = STATE_RUN_CONTINUE;
2098 }
2099 }
2100 break;
2101
2102 case CONNECTION_STATE_MCS_CREATE_REQUEST:
2103 if (!mcs_client_begin(rdp->mcs))
2104 {
2105 WLog_Print(rdp->log, WLOG_ERROR, "%s - mcs_client_begin() fail",
2106 rdp_get_state_string(rdp));
2107 status = STATE_RUN_FAILED;
2108 }
2109 else if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_CREATE_RESPONSE))
2110 status = STATE_RUN_FAILED;
2111 else if (Stream_GetRemainingLength(s) > 0)
2112 status = STATE_RUN_CONTINUE;
2113 break;
2114
2115 case CONNECTION_STATE_MCS_CREATE_RESPONSE:
2116 if (!mcs_recv_connect_response(rdp->mcs, s))
2117 {
2118 WLog_Print(rdp->log, WLOG_ERROR, "mcs_recv_connect_response failure");
2119 status = STATE_RUN_FAILED;
2120 }
2121 else
2122 {
2123 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_ERECT_DOMAIN))
2124 status = STATE_RUN_FAILED;
2125 else if (!mcs_send_erect_domain_request(rdp->mcs))
2126 {
2127 WLog_Print(rdp->log, WLOG_ERROR, "mcs_send_erect_domain_request failure");
2128 status = STATE_RUN_FAILED;
2129 }
2130 else if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_ATTACH_USER))
2131 status = STATE_RUN_FAILED;
2132 else if (!mcs_send_attach_user_request(rdp->mcs))
2133 {
2134 WLog_Print(rdp->log, WLOG_ERROR, "mcs_send_attach_user_request failure");
2135 status = STATE_RUN_FAILED;
2136 }
2137 else if (!rdp_client_transition_to_state(rdp,
2138 CONNECTION_STATE_MCS_ATTACH_USER_CONFIRM))
2139 status = STATE_RUN_FAILED;
2140 }
2141 break;
2142
2143 case CONNECTION_STATE_MCS_ATTACH_USER_CONFIRM:
2144 if (!mcs_recv_attach_user_confirm(rdp->mcs, s))
2145 {
2146 WLog_Print(rdp->log, WLOG_ERROR, "mcs_recv_attach_user_confirm failure");
2147 status = STATE_RUN_FAILED;
2148 }
2149 else if (!freerdp_settings_get_bool(rdp->settings, FreeRDP_SupportSkipChannelJoin))
2150 {
2151 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_CHANNEL_JOIN_REQUEST))
2152 status = STATE_RUN_FAILED;
2153 else if (!mcs_send_channel_join_request(rdp->mcs, rdp->mcs->userId))
2154 {
2155 WLog_Print(rdp->log, WLOG_ERROR, "mcs_send_channel_join_request failure");
2156 status = STATE_RUN_FAILED;
2157 }
2158 else if (!rdp_client_transition_to_state(
2159 rdp, CONNECTION_STATE_MCS_CHANNEL_JOIN_RESPONSE))
2160 status = STATE_RUN_FAILED;
2161 }
2162 else
2163 {
2164 /* SKIP_CHANNELJOIN is active, consider channels to be joined */
2165 if (!rdp_client_skip_mcs_channel_join(rdp))
2166 status = STATE_RUN_FAILED;
2167 }
2168 break;
2169
2170 case CONNECTION_STATE_MCS_CHANNEL_JOIN_RESPONSE:
2171 if (!rdp_client_connect_mcs_channel_join_confirm(rdp, s))
2172 {
2173 WLog_Print(rdp->log, WLOG_ERROR,
2174 "%s - "
2175 "rdp_client_connect_mcs_channel_join_confirm() fail",
2176 rdp_get_state_string(rdp));
2177 status = STATE_RUN_FAILED;
2178 }
2179
2180 break;
2181
2182 case CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT_REQUEST:
2183 if (!rdp_client_connect_auto_detect(rdp, s, WLOG_DEBUG))
2184 {
2185 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_LICENSING))
2186 status = STATE_RUN_FAILED;
2187 else
2188 status = STATE_RUN_TRY_AGAIN;
2189 }
2190 break;
2191
2192 case CONNECTION_STATE_LICENSING:
2193 status = rdp_client_connect_license(rdp, s);
2194
2195 if (state_run_failed(status))
2196 {
2197 char buffer[64] = WINPR_C_ARRAY_INIT;
2198 WLog_Print(rdp->log, WLOG_DEBUG, "%s - rdp_client_connect_license() - %s",
2199 rdp_get_state_string(rdp),
2200 state_run_result_string(status, buffer, ARRAYSIZE(buffer)));
2201 }
2202
2203 break;
2204
2205 case CONNECTION_STATE_MULTITRANSPORT_BOOTSTRAPPING_REQUEST:
2206 if (!rdp_client_connect_auto_detect(rdp, s, WLOG_DEBUG))
2207 {
2208 if (!rdp_client_transition_to_state(
2209 rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE))
2210 status = STATE_RUN_FAILED;
2211 else
2212 status = STATE_RUN_TRY_AGAIN;
2213 }
2214 break;
2215
2216 case CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE:
2217 status = rdp_client_connect_demand_active(rdp, s);
2218
2219 if (state_run_failed(status))
2220 {
2221 char buffer[64] = WINPR_C_ARRAY_INIT;
2222 WLog_Print(rdp->log, WLOG_DEBUG,
2223 "%s - "
2224 "rdp_client_connect_demand_active() - %s",
2225 rdp_get_state_string(rdp),
2226 state_run_result_string(status, buffer, ARRAYSIZE(buffer)));
2227 }
2228 else if (status == STATE_RUN_ACTIVE)
2229 {
2230 if (!rdp_client_transition_to_state(
2231 rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE_CONFIRM_ACTIVE))
2232 status = STATE_RUN_FAILED;
2233 else
2234 status = STATE_RUN_CONTINUE;
2235 }
2236 break;
2237
2238 case CONNECTION_STATE_CAPABILITIES_EXCHANGE_MONITOR_LAYOUT:
2239 status = rdp_client_exchange_monitor_layout(rdp, s);
2240 break;
2241
2242 case CONNECTION_STATE_CAPABILITIES_EXCHANGE_CONFIRM_ACTIVE:
2243 status = rdp_client_connect_confirm_active(rdp, s);
2244 break;
2245
2246 case CONNECTION_STATE_FINALIZATION_CLIENT_SYNC:
2247 status = rdp_handle_sc_flags(rdp, s, FINALIZE_SC_SYNCHRONIZE_PDU,
2248 CONNECTION_STATE_FINALIZATION_CLIENT_COOPERATE);
2249 break;
2250 case CONNECTION_STATE_FINALIZATION_CLIENT_COOPERATE:
2251 status = rdp_handle_sc_flags(rdp, s, FINALIZE_SC_CONTROL_COOPERATE_PDU,
2252 CONNECTION_STATE_FINALIZATION_CLIENT_GRANTED_CONTROL);
2253 break;
2254 case CONNECTION_STATE_FINALIZATION_CLIENT_GRANTED_CONTROL:
2255 status = rdp_handle_sc_flags(rdp, s, FINALIZE_SC_CONTROL_GRANTED_PDU,
2256 CONNECTION_STATE_FINALIZATION_CLIENT_FONT_MAP);
2257 break;
2258 case CONNECTION_STATE_FINALIZATION_CLIENT_FONT_MAP:
2259 status = rdp_handle_sc_flags(rdp, s, FINALIZE_SC_FONT_MAP_PDU, CONNECTION_STATE_ACTIVE);
2260 break;
2261
2262 case CONNECTION_STATE_ACTIVE:
2263 status = rdp_recv_pdu(rdp, s);
2264
2265 if (state_run_failed(status))
2266 {
2267 char buffer[64] = WINPR_C_ARRAY_INIT;
2268 WLog_Print(rdp->log, WLOG_DEBUG, "%s - rdp_recv_pdu() - %s",
2269 rdp_get_state_string(rdp),
2270 state_run_result_string(status, buffer, ARRAYSIZE(buffer)));
2271 }
2272 break;
2273
2274 default:
2275 WLog_Print(rdp->log, WLOG_ERROR, "%s state %u", rdp_get_state_string(rdp),
2276 rdp_get_state(rdp));
2277 status = STATE_RUN_FAILED;
2278 break;
2279 }
2280
2281 if (state_run_failed(status))
2282 {
2283 char buffer[64] = WINPR_C_ARRAY_INIT;
2284 WLog_Print(rdp->log, WLOG_ERROR, "%s status %s", rdp_get_state_string(rdp),
2285 state_run_result_string(status, buffer, ARRAYSIZE(buffer)));
2286 }
2287 return status;
2288}
2289
2290state_run_t rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra)
2291{
2292 char buffer[64] = WINPR_C_ARRAY_INIT;
2293 state_run_t rc = STATE_RUN_FAILED;
2294 const size_t start = Stream_GetPosition(s);
2295 const rdpContext* context = transport_get_context(transport);
2296
2297 WINPR_ASSERT(context);
2298 do
2299 {
2300 const rdpRdp* rdp = context->rdp;
2301 WINPR_ASSERT(rdp);
2302
2303 if (rc == STATE_RUN_TRY_AGAIN)
2304 {
2305 if (!Stream_SetPosition(s, start))
2306 return STATE_RUN_FAILED;
2307 }
2308
2309 const char* old = rdp_get_state_string(rdp);
2310 const size_t orem = Stream_GetRemainingLength(s);
2311 rc = rdp_recv_callback_int(transport, s, extra);
2312
2313 const char* now = rdp_get_state_string(rdp);
2314 const size_t rem = Stream_GetRemainingLength(s);
2315
2316 WLog_Print(rdp->log, WLOG_TRACE,
2317 "(client)[%s -> %s] current return %s [feeding %" PRIuz " bytes, %" PRIuz
2318 " bytes not processed]",
2319 old, now, state_run_result_string(rc, buffer, sizeof(buffer)), orem, rem);
2320 } while ((rc == STATE_RUN_TRY_AGAIN) || (rc == STATE_RUN_CONTINUE));
2321 return rc;
2322}
2323
2324BOOL rdp_send_channel_data(rdpRdp* rdp, UINT16 channelId, const BYTE* data, size_t size)
2325{
2326 return freerdp_channel_send(rdp, channelId, data, size);
2327}
2328
2329BOOL rdp_channel_send_packet(rdpRdp* rdp, UINT16 channelId, size_t totalSize, UINT32 flags,
2330 const BYTE* data, size_t chunkSize)
2331{
2332 return freerdp_channel_send_packet(rdp, channelId, totalSize, flags, data, chunkSize);
2333}
2334
2335BOOL rdp_send_error_info(rdpRdp* rdp)
2336{
2337 UINT16 sec_flags = 0;
2338 wStream* s = nullptr;
2339 BOOL status = 0;
2340
2341 if (rdp->errorInfo == ERRINFO_SUCCESS)
2342 return TRUE;
2343
2344 s = rdp_data_pdu_init(rdp, &sec_flags);
2345
2346 if (!s)
2347 return FALSE;
2348
2349 Stream_Write_UINT32(s, rdp->errorInfo); /* error id (4 bytes) */
2350 status = rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SET_ERROR_INFO, 0, sec_flags);
2351 return status;
2352}
2353
2354int rdp_check_fds(rdpRdp* rdp)
2355{
2356 int status = 0;
2357 rdpTsg* tsg = nullptr;
2358 rdpTransport* transport = nullptr;
2359
2360 WINPR_ASSERT(rdp);
2361 transport = rdp->transport;
2362
2363 tsg = transport_get_tsg(transport);
2364 if (tsg)
2365 {
2366 if (!tsg_check_event_handles(tsg))
2367 {
2368 WLog_Print(rdp->log, WLOG_ERROR, "rdp_check_fds: tsg_check_event_handles()");
2369 return -1;
2370 }
2371
2372 if (tsg_get_state(tsg) != TSG_STATE_PIPE_CREATED)
2373 return 1;
2374 }
2375
2376 status = transport_check_fds(transport);
2377
2378 if (status == 1)
2379 {
2380 if (!rdp_client_redirect(rdp)) /* session redirection */
2381 return -1;
2382 }
2383
2384 if (status < 0)
2385 WLog_Print(rdp->log, WLOG_DEBUG, "transport_check_fds() - %i", status);
2386 else
2387 status = freerdp_timer_poll(rdp->timer);
2388
2389 if ((status >= 0) && !multitransport_check(rdp->multitransport))
2390 status = -1;
2391
2392 return status;
2393}
2394
2395BOOL freerdp_get_stats(const rdpRdp* rdp, UINT64* inBytes, UINT64* outBytes, UINT64* inPackets,
2396 UINT64* outPackets)
2397{
2398 if (!rdp)
2399 return FALSE;
2400
2401 if (inBytes)
2402 *inBytes = rdp->inBytes;
2403 if (outBytes)
2404 *outBytes = rdp->outBytes;
2405 if (inPackets)
2406 *inPackets = rdp->inPackets;
2407 if (outPackets)
2408 *outPackets = rdp->outPackets;
2409
2410 return TRUE;
2411}
2412
2413WINPR_ATTR_NODISCARD
2414static bool rdp_new_common(rdpRdp* rdp)
2415{
2416 WINPR_ASSERT(rdp);
2417
2418 bool rc = false;
2419 rdp->transport = transport_new(rdp->context);
2420 if (!rdp->transport)
2421 goto fail;
2422
2423 if (rdp->io)
2424 {
2425 if (!transport_set_io_callbacks(rdp->transport, rdp->io))
2426 goto fail;
2427 }
2428
2429 rdp->aad = aad_new(rdp->context);
2430 if (!rdp->aad)
2431 goto fail;
2432
2433 rdp->nego = nego_new(rdp->transport);
2434 if (!rdp->nego)
2435 goto fail;
2436
2437 rdp->mcs = mcs_new(rdp->context);
2438 if (!rdp->mcs)
2439 goto fail;
2440
2441 rdp->license = license_new(rdp);
2442 if (!rdp->license)
2443 goto fail;
2444
2445 rdp->fastpath = fastpath_new(rdp);
2446 if (!rdp->fastpath)
2447 goto fail;
2448
2449 rc = true;
2450fail:
2451 return rc;
2452}
2453
2459rdpRdp* rdp_new(rdpContext* context)
2460{
2461 DWORD flags = 0;
2462 rdpRdp* rdp = (rdpRdp*)calloc(1, sizeof(rdpRdp));
2463
2464 if (!rdp)
2465 return nullptr;
2466
2467 rdp->log = WLog_Create(RDP_TAG, WLog_GetRoot());
2468 if (!rdp->log)
2469 goto fail;
2470
2471 (void)_snprintf(rdp->log_context, sizeof(rdp->log_context), "%p", (void*)context);
2472 if (!WLog_SetContext(rdp->log, nullptr, rdp->log_context))
2473 goto fail;
2474
2475 InitializeCriticalSection(&rdp->critical);
2476 rdp->context = context;
2477 WINPR_ASSERT(rdp->context);
2478
2479 if (context->ServerMode)
2480 flags |= FREERDP_SETTINGS_SERVER_MODE;
2481
2482 if (!context->settings)
2483 {
2484 context->settings = rdp->settings = freerdp_settings_new(flags);
2485
2486 if (!rdp->settings)
2487 goto fail;
2488 }
2489 else
2490 rdp->settings = context->settings;
2491
2492 /* Keep a backup copy of settings for later comparisons */
2493 if (!rdp_set_backup_settings(rdp))
2494 goto fail;
2495
2496 rdp->settings->instance = context->instance;
2497
2498 context->settings = rdp->settings;
2499 if (context->instance)
2500 context->settings->instance = context->instance;
2501 else if (context->peer)
2502 {
2503 rdp->settings->instance = context->peer;
2504
2505#if defined(WITH_FREERDP_DEPRECATED)
2506 context->peer->settings = rdp->settings;
2507#endif
2508 }
2509
2510 if (!rdp_new_common(rdp))
2511 goto fail;
2512
2513 {
2514 const rdpTransportIo* io = transport_get_io_callbacks(rdp->transport);
2515 if (!io)
2516 goto fail;
2517 rdp->io = calloc(1, sizeof(rdpTransportIo));
2518 if (!rdp->io)
2519 goto fail;
2520 *rdp->io = *io;
2521 }
2522
2523 rdp->input = input_new(rdp);
2524
2525 if (!rdp->input)
2526 goto fail;
2527
2528 rdp->update = update_new(rdp);
2529
2530 if (!rdp->update)
2531 goto fail;
2532
2533 rdp->redirection = redirection_new();
2534
2535 if (!rdp->redirection)
2536 goto fail;
2537
2538 rdp->autodetect = autodetect_new(rdp->context);
2539
2540 if (!rdp->autodetect)
2541 goto fail;
2542
2543 rdp->heartbeat = heartbeat_new();
2544
2545 if (!rdp->heartbeat)
2546 goto fail;
2547
2548 rdp->multitransport = multitransport_new(rdp, INITIATE_REQUEST_PROTOCOL_UDPFECL |
2549 INITIATE_REQUEST_PROTOCOL_UDPFECR);
2550
2551 if (!rdp->multitransport)
2552 goto fail;
2553
2554 rdp->bulk = bulk_new(context);
2555
2556 if (!rdp->bulk)
2557 goto fail;
2558
2559 rdp->pubSub = PubSub_New(TRUE);
2560 if (!rdp->pubSub)
2561 goto fail;
2562
2563 rdp->abortEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
2564 if (!rdp->abortEvent)
2565 goto fail;
2566
2567 rdp->timer = freerdp_timer_new(rdp);
2568 if (!rdp->timer)
2569 goto fail;
2570
2571 return rdp;
2572
2573fail:
2574 WINPR_PRAGMA_DIAG_PUSH
2575 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2576 rdp_free(rdp);
2577 WINPR_PRAGMA_DIAG_POP
2578 return nullptr;
2579}
2580
2581static void rdp_reset_free(rdpRdp* rdp)
2582{
2583 WINPR_ASSERT(rdp);
2584
2585 security_lock(rdp);
2586 rdp_free_rc4_decrypt_keys(rdp);
2587 rdp_free_rc4_encrypt_keys(rdp);
2588
2589 winpr_Cipher_Free(rdp->fips_encrypt);
2590 winpr_Cipher_Free(rdp->fips_decrypt);
2591 rdp->fips_encrypt = nullptr;
2592 rdp->fips_decrypt = nullptr;
2593 security_unlock(rdp);
2594
2595 aad_free(rdp->aad);
2596 mcs_free(rdp->mcs);
2597 nego_free(rdp->nego);
2598 license_free(rdp->license);
2599 transport_free(rdp->transport);
2600 fastpath_free(rdp->fastpath);
2601
2602 rdp->aad = nullptr;
2603 rdp->mcs = nullptr;
2604 rdp->nego = nullptr;
2605 rdp->license = nullptr;
2606 rdp->transport = nullptr;
2607 rdp->fastpath = nullptr;
2608}
2609
2610BOOL rdp_reset(rdpRdp* rdp)
2611{
2612 BOOL rc = TRUE;
2613
2614 WINPR_ASSERT(rdp);
2615
2616 rdpSettings* settings = rdp->settings;
2617 WINPR_ASSERT(settings);
2618
2619 bulk_reset(rdp->bulk);
2620 multitransport_reset(rdp->multitransport);
2621
2622 rdp_reset_free(rdp);
2623
2624 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerRandom, nullptr, 0))
2625 rc = FALSE;
2626
2627 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerCertificate, nullptr, 0))
2628 rc = FALSE;
2629
2630 if (!freerdp_settings_set_string(settings, FreeRDP_ClientAddress, nullptr))
2631 rc = FALSE;
2632
2633 if (!rc)
2634 goto fail;
2635
2636 rc = rdp_new_common(rdp);
2637 if (!rc)
2638 goto fail;
2639
2640 if (!transport_set_layer(rdp->transport, TRANSPORT_LAYER_TCP))
2641 goto fail;
2642
2643 rdp->errorInfo = 0;
2644 rc = rdp_finalize_reset_flags(rdp, TRUE);
2645
2646fail:
2647 return rc;
2648}
2649
2655void rdp_free(rdpRdp* rdp)
2656{
2657 if (rdp)
2658 {
2659 freerdp_timer_free(rdp->timer);
2660 rdp_reset_free(rdp);
2661
2662 freerdp_settings_free(rdp->settings);
2663 freerdp_settings_free(rdp->originalSettings);
2664 freerdp_settings_free(rdp->remoteSettings);
2665
2666 input_free(rdp->input);
2667 update_free(rdp->update);
2668 nla_free(rdp->nla);
2669 redirection_free(rdp->redirection);
2670 autodetect_free(rdp->autodetect);
2671 heartbeat_free(rdp->heartbeat);
2672 multitransport_free(rdp->multitransport);
2673 freerdp_bulk_free(rdp->bulk);
2674 free(rdp->io);
2675 PubSub_Free(rdp->pubSub);
2676 if (rdp->abortEvent)
2677 (void)CloseHandle(rdp->abortEvent);
2678 aad_free(rdp->aad);
2679 WINPR_JSON_Delete(rdp->wellknown);
2680 DeleteCriticalSection(&rdp->critical);
2681 WLog_Discard(rdp->log);
2682 free(rdp);
2683 }
2684}
2685
2686BOOL rdp_io_callback_set_event(rdpRdp* rdp, BOOL set)
2687{
2688 if (!rdp)
2689 return FALSE;
2690 return transport_io_callback_set_event(rdp->transport, set);
2691}
2692
2693const rdpTransportIo* rdp_get_io_callbacks(rdpRdp* rdp)
2694{
2695 if (!rdp)
2696 return nullptr;
2697 return rdp->io;
2698}
2699
2700BOOL rdp_set_io_callbacks(rdpRdp* rdp, const rdpTransportIo* io_callbacks)
2701{
2702 if (!rdp)
2703 return FALSE;
2704 free(rdp->io);
2705 rdp->io = nullptr;
2706 if (io_callbacks)
2707 {
2708 rdp->io = malloc(sizeof(rdpTransportIo));
2709 if (!rdp->io)
2710 return FALSE;
2711 *rdp->io = *io_callbacks;
2712 return transport_set_io_callbacks(rdp->transport, rdp->io);
2713 }
2714 return TRUE;
2715}
2716
2717BOOL rdp_set_io_callback_context(rdpRdp* rdp, void* usercontext)
2718{
2719 WINPR_ASSERT(rdp);
2720 rdp->ioContext = usercontext;
2721 return TRUE;
2722}
2723
2724void* rdp_get_io_callback_context(rdpRdp* rdp)
2725{
2726 WINPR_ASSERT(rdp);
2727 return rdp->ioContext;
2728}
2729
2730const char* rdp_finalize_flags_to_str(UINT32 flags, char* buffer, size_t size)
2731{
2732 char number[32] = WINPR_C_ARRAY_INIT;
2733 const UINT32 mask =
2734 (uint32_t)~(FINALIZE_SC_SYNCHRONIZE_PDU | FINALIZE_SC_CONTROL_COOPERATE_PDU |
2735 FINALIZE_SC_CONTROL_GRANTED_PDU | FINALIZE_SC_FONT_MAP_PDU |
2736 FINALIZE_CS_SYNCHRONIZE_PDU | FINALIZE_CS_CONTROL_COOPERATE_PDU |
2737 FINALIZE_CS_CONTROL_REQUEST_PDU | FINALIZE_CS_PERSISTENT_KEY_LIST_PDU |
2738 FINALIZE_CS_FONT_LIST_PDU | FINALIZE_DEACTIVATE_REACTIVATE);
2739
2740 if (flags & FINALIZE_SC_SYNCHRONIZE_PDU)
2741 winpr_str_append("FINALIZE_SC_SYNCHRONIZE_PDU", buffer, size, "|");
2742 if (flags & FINALIZE_SC_CONTROL_COOPERATE_PDU)
2743 winpr_str_append("FINALIZE_SC_CONTROL_COOPERATE_PDU", buffer, size, "|");
2744 if (flags & FINALIZE_SC_CONTROL_GRANTED_PDU)
2745 winpr_str_append("FINALIZE_SC_CONTROL_GRANTED_PDU", buffer, size, "|");
2746 if (flags & FINALIZE_SC_FONT_MAP_PDU)
2747 winpr_str_append("FINALIZE_SC_FONT_MAP_PDU", buffer, size, "|");
2748 if (flags & FINALIZE_CS_SYNCHRONIZE_PDU)
2749 winpr_str_append("FINALIZE_CS_SYNCHRONIZE_PDU", buffer, size, "|");
2750 if (flags & FINALIZE_CS_CONTROL_COOPERATE_PDU)
2751 winpr_str_append("FINALIZE_CS_CONTROL_COOPERATE_PDU", buffer, size, "|");
2752 if (flags & FINALIZE_CS_CONTROL_REQUEST_PDU)
2753 winpr_str_append("FINALIZE_CS_CONTROL_REQUEST_PDU", buffer, size, "|");
2754 if (flags & FINALIZE_CS_PERSISTENT_KEY_LIST_PDU)
2755 winpr_str_append("FINALIZE_CS_PERSISTENT_KEY_LIST_PDU", buffer, size, "|");
2756 if (flags & FINALIZE_CS_FONT_LIST_PDU)
2757 winpr_str_append("FINALIZE_CS_FONT_LIST_PDU", buffer, size, "|");
2758 if (flags & FINALIZE_DEACTIVATE_REACTIVATE)
2759 winpr_str_append("FINALIZE_DEACTIVATE_REACTIVATE", buffer, size, "|");
2760 if (flags & mask)
2761 winpr_str_append("UNKNOWN_FLAG", buffer, size, "|");
2762 if (flags == 0)
2763 winpr_str_append("NO_FLAG_SET", buffer, size, "|");
2764 (void)_snprintf(number, sizeof(number), " [0x%08" PRIx32 "]", flags);
2765 winpr_str_append(number, buffer, size, "");
2766 return buffer;
2767}
2768
2769BOOL rdp_finalize_reset_flags(rdpRdp* rdp, BOOL clearAll)
2770{
2771 WINPR_ASSERT(rdp);
2772 WLog_Print(rdp->log, WLOG_DEBUG, "[%s] reset finalize_sc_pdus", rdp_get_state_string(rdp));
2773 if (clearAll)
2774 rdp->finalize_sc_pdus = 0;
2775 else
2776 rdp->finalize_sc_pdus &= FINALIZE_DEACTIVATE_REACTIVATE;
2777
2778 return rdp_set_monitor_layout_pdu_state(rdp, FALSE);
2779}
2780
2781BOOL rdp_finalize_set_flag(rdpRdp* rdp, UINT32 flag)
2782{
2783 char buffer[1024] = WINPR_C_ARRAY_INIT;
2784
2785 WINPR_ASSERT(rdp);
2786
2787 WLog_Print(rdp->log, WLOG_DEBUG, "[%s] received flag %s", rdp_get_state_string(rdp),
2788 rdp_finalize_flags_to_str(flag, buffer, sizeof(buffer)));
2789 rdp->finalize_sc_pdus |= flag;
2790 return TRUE;
2791}
2792
2793BOOL rdp_finalize_is_flag_set(rdpRdp* rdp, UINT32 flag)
2794{
2795 WINPR_ASSERT(rdp);
2796 return (rdp->finalize_sc_pdus & flag) == flag;
2797}
2798
2799BOOL rdp_reset_rc4_encrypt_keys(rdpRdp* rdp)
2800{
2801 WINPR_ASSERT(rdp);
2802 rdp_free_rc4_encrypt_keys(rdp);
2803 rdp->rc4_encrypt_key = winpr_RC4_New(rdp->encrypt_key, rdp->rc4_key_len);
2804
2805 rdp->encrypt_use_count = 0;
2806 return rdp->rc4_encrypt_key != nullptr;
2807}
2808
2809void rdp_free_rc4_encrypt_keys(rdpRdp* rdp)
2810{
2811 WINPR_ASSERT(rdp);
2812 winpr_RC4_Free(rdp->rc4_encrypt_key);
2813 rdp->rc4_encrypt_key = nullptr;
2814}
2815
2816void rdp_free_rc4_decrypt_keys(rdpRdp* rdp)
2817{
2818 WINPR_ASSERT(rdp);
2819 winpr_RC4_Free(rdp->rc4_decrypt_key);
2820 rdp->rc4_decrypt_key = nullptr;
2821}
2822
2823BOOL rdp_reset_rc4_decrypt_keys(rdpRdp* rdp)
2824{
2825 WINPR_ASSERT(rdp);
2826 rdp_free_rc4_decrypt_keys(rdp);
2827 rdp->rc4_decrypt_key = winpr_RC4_New(rdp->decrypt_key, rdp->rc4_key_len);
2828
2829 rdp->decrypt_use_count = 0;
2830 return rdp->rc4_decrypt_key != nullptr;
2831}
2832
2833const char* rdp_security_flag_string(UINT32 securityFlags, char* buffer, size_t size)
2834{
2835 if (securityFlags & SEC_EXCHANGE_PKT)
2836 winpr_str_append("SEC_EXCHANGE_PKT", buffer, size, "|");
2837 if (securityFlags & SEC_TRANSPORT_REQ)
2838 winpr_str_append("SEC_TRANSPORT_REQ", buffer, size, "|");
2839 if (securityFlags & SEC_TRANSPORT_RSP)
2840 winpr_str_append("SEC_TRANSPORT_RSP", buffer, size, "|");
2841 if (securityFlags & SEC_ENCRYPT)
2842 winpr_str_append("SEC_ENCRYPT", buffer, size, "|");
2843 if (securityFlags & SEC_RESET_SEQNO)
2844 winpr_str_append("SEC_RESET_SEQNO", buffer, size, "|");
2845 if (securityFlags & SEC_IGNORE_SEQNO)
2846 winpr_str_append("SEC_IGNORE_SEQNO", buffer, size, "|");
2847 if (securityFlags & SEC_INFO_PKT)
2848 winpr_str_append("SEC_INFO_PKT", buffer, size, "|");
2849 if (securityFlags & SEC_LICENSE_PKT)
2850 winpr_str_append("SEC_LICENSE_PKT", buffer, size, "|");
2851 if (securityFlags & SEC_LICENSE_ENCRYPT_CS)
2852 winpr_str_append("SEC_LICENSE_ENCRYPT_CS", buffer, size, "|");
2853 if (securityFlags & SEC_LICENSE_ENCRYPT_SC)
2854 winpr_str_append("SEC_LICENSE_ENCRYPT_SC", buffer, size, "|");
2855 if (securityFlags & SEC_REDIRECTION_PKT)
2856 winpr_str_append("SEC_REDIRECTION_PKT", buffer, size, "|");
2857 if (securityFlags & SEC_SECURE_CHECKSUM)
2858 winpr_str_append("SEC_SECURE_CHECKSUM", buffer, size, "|");
2859 if (securityFlags & SEC_AUTODETECT_REQ)
2860 winpr_str_append("SEC_AUTODETECT_REQ", buffer, size, "|");
2861 if (securityFlags & SEC_AUTODETECT_RSP)
2862 winpr_str_append("SEC_AUTODETECT_RSP", buffer, size, "|");
2863 if (securityFlags & SEC_HEARTBEAT)
2864 winpr_str_append("SEC_HEARTBEAT", buffer, size, "|");
2865 if (securityFlags & SEC_FLAGSHI_VALID)
2866 winpr_str_append("SEC_FLAGSHI_VALID", buffer, size, "|");
2867 {
2868 char msg[32] = WINPR_C_ARRAY_INIT;
2869
2870 (void)_snprintf(msg, sizeof(msg), "[0x%08" PRIx32 "]", securityFlags);
2871 winpr_str_append(msg, buffer, size, "");
2872 }
2873 return buffer;
2874}
2875
2876WINPR_ATTR_NODISCARD
2877static BOOL rdp_reset_remote_settings(rdpRdp* rdp)
2878{
2879 UINT32 flags = FREERDP_SETTINGS_REMOTE_MODE;
2880 WINPR_ASSERT(rdp);
2881 freerdp_settings_free(rdp->remoteSettings);
2882
2883 if (!freerdp_settings_get_bool(rdp->settings, FreeRDP_ServerMode))
2884 flags |= FREERDP_SETTINGS_SERVER_MODE;
2885 rdp->remoteSettings = freerdp_settings_new(flags);
2886 return rdp->remoteSettings != nullptr;
2887}
2888
2889BOOL rdp_set_backup_settings(rdpRdp* rdp)
2890{
2891 WINPR_ASSERT(rdp);
2892 freerdp_settings_free(rdp->originalSettings);
2893 rdp->originalSettings = freerdp_settings_clone(rdp->settings);
2894 if (!rdp->originalSettings)
2895 return FALSE;
2896 return rdp_reset_remote_settings(rdp);
2897}
2898
2899BOOL rdp_reset_runtime_settings(rdpRdp* rdp)
2900{
2901 WINPR_ASSERT(rdp);
2902 WINPR_ASSERT(rdp->context);
2903
2904 freerdp_settings_free(rdp->settings);
2905 rdp->context->settings = rdp->settings = freerdp_settings_clone(rdp->originalSettings);
2906
2907 if (!rdp->settings)
2908 return FALSE;
2909 return rdp_reset_remote_settings(rdp);
2910}
2911
2912WINPR_ATTR_NODISCARD
2913static BOOL starts_with(const char* tok, const char* val)
2914{
2915 const size_t len = strlen(val);
2916 if (strncmp(tok, val, len) != 0)
2917 return FALSE;
2918 if (tok[len] != '=')
2919 return FALSE;
2920 return TRUE;
2921}
2922
2923WINPR_ATTR_NODISCARD
2924static BOOL option_equals(const char* what, const char* val)
2925{
2926 return _stricmp(what, val) == 0;
2927}
2928
2929WINPR_ATTR_NODISCARD
2930static BOOL parse_on_off_option(const char* value)
2931{
2932 WINPR_ASSERT(value);
2933 const char* sep = strchr(value, '=');
2934 if (!sep)
2935 return TRUE;
2936 if (option_equals("on", &sep[1]))
2937 return TRUE;
2938 if (option_equals("true", &sep[1]))
2939 return TRUE;
2940 if (option_equals("off", &sep[1]))
2941 return FALSE;
2942 if (option_equals("false", &sep[1]))
2943 return FALSE;
2944
2945 errno = 0;
2946 long val = strtol(value, nullptr, 0);
2947 if (errno == 0)
2948 return (val != 0);
2949
2950 return FALSE;
2951}
2952
2953#define STR(x) #x
2954
2955WINPR_ATTR_NODISCARD
2956static BOOL option_is_runtime_checks(WINPR_ATTR_UNUSED wLog* log, WINPR_ATTR_UNUSED DWORD level,
2957 const char* tok)
2958{
2959 const char* experimental[] = { STR(WITH_VERBOSE_WINPR_ASSERT) };
2960 for (size_t x = 0; x < ARRAYSIZE(experimental); x++)
2961 {
2962 const char* opt = experimental[x];
2963 if (starts_with(tok, opt))
2964 {
2965 return parse_on_off_option(tok);
2966 }
2967 }
2968 return FALSE;
2969}
2970
2971WINPR_ATTR_NODISCARD
2972static BOOL option_is_experimental(WINPR_ATTR_UNUSED wLog* log, WINPR_ATTR_UNUSED DWORD level,
2973 const char* tok)
2974{
2975 const char* experimental[] = { STR(WITH_DSP_EXPERIMENTAL), STR(WITH_FFMPEG_HWACCEL),
2976 STR(WITH_GFX_AV1), STR(WITH_GFX_AV2),
2977 STR(WITH_GFX_AZURE), STR(WITH_MEDIACODEC),
2978 STR(WITH_CLIENT_SDL2), STR(WITH_OPENCL),
2979 STR(WITH_LIBRESSL), STR(WITH_MBEDTLS),
2980 STR(WITH_MEDIA_FOUNDATION), STR(WITH_KRB5_HEIMDAL),
2981 STR(WITH_RDPEUDP) };
2982 for (size_t x = 0; x < ARRAYSIZE(experimental); x++)
2983 {
2984 const char* opt = experimental[x];
2985 if (starts_with(tok, opt))
2986 {
2987 return parse_on_off_option(tok);
2988 }
2989 }
2990 return FALSE;
2991}
2992
2993WINPR_ATTR_NODISCARD
2994static BOOL option_is_debug(wLog* log, WINPR_ATTR_UNUSED DWORD level, const char* tok)
2995{
2996 WINPR_ASSERT(log);
2997 const char* debug[] = { STR(WITH_DEBUG_ALL),
2998 STR(WITH_DEBUG_CERTIFICATE),
2999 STR(WITH_DEBUG_CAPABILITIES),
3000 STR(WITH_DEBUG_CHANNELS),
3001 STR(WITH_DEBUG_CLIPRDR),
3002 STR(WITH_DEBUG_CODECS),
3003 STR(WITH_DEBUG_DVC),
3004 STR(WITH_DEBUG_TSMF),
3005 STR(WITH_DEBUG_KBD),
3006 STR(WITH_DEBUG_LICENSE),
3007 STR(WITH_DEBUG_NEGO),
3008 STR(WITH_DEBUG_NLA),
3009 STR(WITH_DEBUG_TSG),
3010 STR(WITH_DEBUG_RAIL),
3011 STR(WITH_DEBUG_RDP),
3012 STR(WITH_DEBUG_RDPEI),
3013 STR(WITH_DEBUG_REDIR),
3014 STR(WITH_DEBUG_RDPDR),
3015 STR(WITH_DEBUG_RFX),
3016 STR(WITH_DEBUG_SCARD),
3017 STR(WITH_DEBUG_SND),
3018 STR(WITH_DEBUG_SVC),
3019 STR(WITH_DEBUG_TRANSPORT),
3020 STR(WITH_DEBUG_TIMEZONE),
3021 STR(WITH_DEBUG_WND),
3022 STR(WITH_DEBUG_RINGBUFFER),
3023 STR(WITH_DEBUG_SYMBOLS),
3024 STR(WITH_DEBUG_EVENTS),
3025 STR(WITH_DEBUG_MUTEX),
3026 STR(WITH_DEBUG_NTLM),
3027 STR(WITH_DEBUG_SDL_KBD_EVENTS),
3028 STR(WITH_DEBUG_SDL_KBD_EVENTS),
3029 STR(WITH_DEBUG_THREADS),
3030 STR(WITH_DEBUG_URBDRC) };
3031
3032 for (size_t x = 0; x < ARRAYSIZE(debug); x++)
3033 {
3034 const char* opt = debug[x];
3035 if (starts_with(tok, opt))
3036 return parse_on_off_option(tok);
3037 }
3038
3039 if (starts_with(tok, "WITH_DEBUG"))
3040 {
3041 WLog_Print(log, level, "[BUG] Unmapped Debug-Build option '%s'.", tok);
3042 return parse_on_off_option(tok);
3043 }
3044
3045 return FALSE;
3046}
3047
3048static void log_build_warn(wLog* log, DWORD level, const char* what, const char* msg,
3049 BOOL (*cmp)(wLog* log, DWORD level, const char* tok))
3050{
3051 WINPR_PRAGMA_DIAG_PUSH
3052 WINPR_PRAGMA_DIAG_IGNORED_OVERLENGTH_STRINGS
3053
3054 size_t len = sizeof(FREERDP_BUILD_CONFIG);
3055 char* list = calloc(len, sizeof(char));
3056 char* config = _strdup(FREERDP_BUILD_CONFIG);
3057 WINPR_PRAGMA_DIAG_POP
3058
3059 if (config && list)
3060 {
3061 char* saveptr = nullptr;
3062 char* tok = strtok_s(config, " ", &saveptr);
3063 while (tok)
3064 {
3065 if (cmp(log, level, tok))
3066 winpr_str_append(tok, list, len, " ");
3067
3068 tok = strtok_s(nullptr, " ", &saveptr);
3069 }
3070 }
3071 free(config);
3072
3073 if (list)
3074 {
3075 if (strlen(list) > 0)
3076 {
3077 WLog_Print(log, level, "*************************************************");
3078 WLog_Print(log, level, "This build is using [%s] build options:", what);
3079
3080 char* saveptr = nullptr;
3081 char* tok = strtok_s(list, " ", &saveptr);
3082 while (tok)
3083 {
3084 WLog_Print(log, level, "* '%s'", tok);
3085 tok = strtok_s(nullptr, " ", &saveptr);
3086 }
3087 WLog_Print(log, level, "*");
3088 WLog_Print(log, level, "[%s] build options %s", what, msg);
3089 WLog_Print(log, level, "*************************************************");
3090 }
3091 }
3092 free(list);
3093}
3094
3095#define print_first_line(log, level, firstLine, what) \
3096 print_first_line_int((log), (level), (firstLine), (what), __FILE__, __func__, __LINE__)
3097static void print_first_line_int(wLog* log, DWORD level, log_line_t* firstLine, const char* what,
3098 const char* file, const char* fkt, size_t line)
3099{
3100 WINPR_ASSERT(firstLine);
3101 if (!firstLine->fkt)
3102 {
3103 if (WLog_IsLevelActive(log, level))
3104 {
3105 WLog_PrintTextMessage(log, level, line, file, fkt,
3106 "*************************************************");
3107 WLog_PrintTextMessage(log, level, line, file, fkt,
3108 "[SSL] {%s} build or configuration missing:", what);
3109 }
3110 firstLine->line = line;
3111 firstLine->file = file;
3112 firstLine->fkt = fkt;
3113 firstLine->level = level;
3114 }
3115}
3116
3117static void print_last_line(wLog* log, const log_line_t* firstLine)
3118{
3119 WINPR_ASSERT(firstLine);
3120 if (firstLine->fkt)
3121 {
3122 if (WLog_IsLevelActive(log, firstLine->level))
3123 WLog_PrintTextMessage(log, firstLine->level, firstLine->line, firstLine->file,
3124 firstLine->fkt,
3125 "*************************************************");
3126 }
3127}
3128
3129static void log_build_warn_cipher(wLog* log, DWORD level, log_line_t* firstLine,
3130 WINPR_CIPHER_TYPE md, const char* what, BOOL allowFIPS)
3131{
3132 BOOL haveCipher = FALSE;
3133
3134 char key[WINPR_CIPHER_MAX_KEY_LENGTH] = WINPR_C_ARRAY_INIT;
3135 char iv[WINPR_CIPHER_MAX_IV_LENGTH] = WINPR_C_ARRAY_INIT;
3136
3137 /* RC4 only exists in the compatibility functions winpr_RC4_*
3138 * winpr_Cipher_* does not support that. */
3139 if (md == WINPR_CIPHER_ARC4_128)
3140 {
3141 WINPR_RC4_CTX* enc = nullptr;
3142 if (allowFIPS)
3143 enc = winpr_RC4_New_Allow_FIPS(key, sizeof(key));
3144 else
3145 enc = winpr_RC4_New(key, sizeof(key));
3146 haveCipher = enc != nullptr;
3147 winpr_RC4_Free(enc);
3148 }
3149 else
3150 {
3151 WINPR_CIPHER_CTX* enc =
3152 winpr_Cipher_NewEx(md, WINPR_ENCRYPT, key, sizeof(key), iv, sizeof(iv));
3153 WINPR_CIPHER_CTX* dec =
3154 winpr_Cipher_NewEx(md, WINPR_DECRYPT, key, sizeof(key), iv, sizeof(iv));
3155 if (enc && dec)
3156 haveCipher = TRUE;
3157
3158 winpr_Cipher_Free(enc);
3159 winpr_Cipher_Free(dec);
3160 }
3161
3162 if (!haveCipher)
3163 {
3164 print_first_line(log, level, firstLine, "Cipher");
3165 WLog_Print(log, level, "* %s: %s", winpr_cipher_type_to_string(md), what);
3166 }
3167}
3168
3169static void log_build_warn_hmac(wLog* log, DWORD level, log_line_t* firstLine, WINPR_MD_TYPE md,
3170 const char* what)
3171{
3172 BOOL haveHmacX = FALSE;
3173 WINPR_HMAC_CTX* hmac = winpr_HMAC_New();
3174 if (hmac)
3175 {
3176 /* We need some key length, but there is no real limit here.
3177 * just take the cipher maximum key length as we already have that available.
3178 */
3179 char key[WINPR_CIPHER_MAX_KEY_LENGTH] = WINPR_C_ARRAY_INIT;
3180 haveHmacX = winpr_HMAC_Init(hmac, md, key, sizeof(key));
3181 }
3182 winpr_HMAC_Free(hmac);
3183
3184 if (!haveHmacX)
3185 {
3186 print_first_line(log, level, firstLine, "HMAC");
3187 WLog_Print(log, level, " * %s: %s", winpr_md_type_to_string(md), what);
3188 }
3189}
3190
3191static void log_build_warn_hash(wLog* log, DWORD level, log_line_t* firstLine, WINPR_MD_TYPE md,
3192 const char* what, BOOL allowFIPS)
3193{
3194 BOOL haveDigestX = FALSE;
3195 WINPR_DIGEST_CTX* digest = winpr_Digest_New();
3196 if (digest)
3197 {
3198 if (allowFIPS)
3199 haveDigestX = winpr_Digest_Init_Allow_FIPS(digest, md);
3200 else
3201 haveDigestX = winpr_Digest_Init(digest, md);
3202 }
3203 winpr_Digest_Free(digest);
3204
3205 if (!haveDigestX)
3206 {
3207 print_first_line(log, level, firstLine, "Digest");
3208 WLog_Print(log, level, " * %s: %s", winpr_md_type_to_string(md), what);
3209 }
3210}
3211
3212static void log_build_warn_ssl(wLog* log, DWORD level)
3213{
3214 const BOOL fips = winpr_FIPSMode();
3215
3216 if (fips)
3217 {
3218 WLog_Print(log, WLOG_INFO,
3219 "FIPS mode active: non-approved algorithms are unavailable "
3220 "as expected. NTLM, autoreconnect cookies, assistance files "
3221 "with encrypted passwords and RDP security will not work.");
3222 }
3223
3224 log_line_t firstHashLine = WINPR_C_ARRAY_INIT;
3225 if (!fips)
3226 {
3227 log_build_warn_hash(log, level, &firstHashLine, WINPR_MD_MD4, "NTLM support not available",
3228 FALSE);
3229 log_build_warn_hash(log, level, &firstHashLine, WINPR_MD_MD5,
3230 "NTLM, assistance files with encrypted passwords "
3231 " and autoreconnect cookies will not work",
3232 FALSE);
3233 }
3234 log_build_warn_hash(log, level, &firstHashLine, WINPR_MD_MD5,
3235 "RDP licensing and RDP security will not work", TRUE);
3236 log_build_warn_hash(log, level, &firstHashLine, WINPR_MD_SHA1,
3237 "assistance files with encrypted passwords, Kerberos, Smartcard Logon, RDP "
3238 "security support not available",
3239 FALSE);
3240 log_build_warn_hash(log, level, &firstHashLine, WINPR_MD_SHA256,
3241 "file clipboard, AAD gateway, NLA security and certificates might not work",
3242 FALSE);
3243 print_last_line(log, &firstHashLine);
3244
3245 if (!fips)
3246 {
3247 log_line_t firstHmacLine = WINPR_C_ARRAY_INIT;
3248 log_build_warn_hmac(log, level, &firstHmacLine, WINPR_MD_MD5,
3249 "Autoreconnect cookie not supported");
3250 log_build_warn_hmac(log, level, &firstHmacLine, WINPR_MD_SHA1,
3251 "RDP security not supported");
3252 print_last_line(log, &firstHmacLine);
3253 }
3254
3255 log_line_t firstCipherLine = WINPR_C_ARRAY_INIT;
3256 if (!fips)
3257 {
3258 log_build_warn_cipher(log, level, &firstCipherLine, WINPR_CIPHER_ARC4_128,
3259 "assistance files with encrypted passwords, NTLM "
3260 "and autoreconnect cookies will not work",
3261 FALSE);
3262 }
3263 log_build_warn_cipher(log, level, &firstCipherLine, WINPR_CIPHER_ARC4_128,
3264 "RDP licensing and RDP security will not work", TRUE);
3265 if (!fips)
3266 log_build_warn_cipher(log, level, &firstCipherLine, WINPR_CIPHER_DES_EDE3_CBC,
3267 "RDP security will not work", TRUE);
3268 log_build_warn_cipher(
3269 log, level, &firstCipherLine, WINPR_CIPHER_AES_128_CBC,
3270 "assistance file encrypted LHTicket will not work and ARM gateway might not", FALSE);
3271 log_build_warn_cipher(log, level, &firstCipherLine, WINPR_CIPHER_AES_192_CBC,
3272 "ARM gateway might not work", FALSE);
3273 log_build_warn_cipher(log, level, &firstCipherLine, WINPR_CIPHER_AES_256_CBC,
3274 "ARM gateway might not work", FALSE);
3275 print_last_line(log, &firstCipherLine);
3276}
3277
3278static void rdp_log_build_warnings_wlog(wLog* log, DWORD level)
3279{
3280 static unsigned count = 0;
3281
3282 /* Since this function is called in context creation routines stop logging
3283 * this issue repeatedly. This is required for proxy, which would otherwise
3284 * spam the log with these. */
3285 if (count > 0)
3286 return;
3287 count++;
3288 log_build_warn(log, level, "experimental", "might crash the application",
3289 option_is_experimental);
3290 log_build_warn(log, level, "debug", "might leak sensitive information (credentials, ...)",
3291 option_is_debug);
3292 log_build_warn(log, level, "runtime-check", "might slow down the application",
3293 option_is_runtime_checks);
3294 log_build_warn_ssl(log, level);
3295 winpr_log_build_warn(log, level);
3296}
3297
3298void rdp_log_build_warnings(rdpRdp* rdp)
3299{
3300 WINPR_ASSERT(rdp);
3301 rdp_log_build_warnings_wlog(rdp->log, WLOG_WARN);
3302}
3303
3304size_t rdp_get_event_handles(rdpRdp* rdp, HANDLE* handles, uint32_t count)
3305{
3306 size_t nCount = transport_get_event_handles(rdp->transport, handles, count);
3307
3308 if (nCount == 0)
3309 return 0;
3310
3311 /* room for the abort, timer and multitransport events */
3312 if ((nCount > count) || (count - nCount < 3))
3313 return 0;
3314
3315 handles[nCount++] = utils_get_abort_event(rdp);
3316 handles[nCount++] = freerdp_timer_get_event(rdp->timer);
3317 handles[nCount++] = multitransport_get_event_handle(rdp->multitransport);
3318 return nCount;
3319}
WINPR_JSON_Delete
WINPR_API void WINPR_JSON_Delete(WINPR_JSON *item)
Delete a WinPR JSON wrapper object.
Definition c-json.c:103
freerdp_settings_new
FREERDP_API rdpSettings * freerdp_settings_new(DWORD flags)
creates a new setting struct
Definition core/settings.c:885
freerdp_settings_clone
FREERDP_API rdpSettings * freerdp_settings_clone(const rdpSettings *settings)
Creates a deep copy of settings.
Definition core/settings.c:1712
freerdp_settings_set_pointer_len
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_set_pointer_len(rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id, const void *data, size_t len)
Set a pointer to value data.
Definition common/settings.c:1446
freerdp_settings_free
FREERDP_API void freerdp_settings_free(rdpSettings *settings)
Free a settings struct with all data in it.
Definition core/settings.c:1464
FREERDP_SETTINGS_SERVER_MODE
#define FREERDP_SETTINGS_SERVER_MODE
Definition include/freerdp/settings.h:80
freerdp_settings_set_string
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_set_string(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const char *val)
Sets a string settings value. The param is copied.
Definition settings_getters.c:3866
freerdp_settings_get_bool
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
MONITOR_DEF
Definition settings_types.h:434