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