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