FreeRDP
Loading...
Searching...
No Matches
info.c
1
22#include <freerdp/config.h>
23
24#include "settings.h"
25
26#include <winpr/crt.h>
27#include <winpr/assert.h>
28
29#include <freerdp/crypto/crypto.h>
30#include <freerdp/log.h>
31#include <freerdp/session.h>
32#include <stdio.h>
33
34#include "timezone.h"
35
36#include "info.h"
37
38#define TAG FREERDP_TAG("core.info")
39
40#define logonInfoV2Size (2 + 4 + 4 + 4 + 4)
41#define logonInfoV2ReservedSize 558
42#define logonInfoV2TotalSize (logonInfoV2Size + logonInfoV2ReservedSize)
43
44static const char* INFO_TYPE_LOGON_STRINGS[4] = { "Logon Info V1", "Logon Info V2",
45 "Logon Plain Notify", "Logon Extended Info" };
46
47/* This define limits the length of the strings in the label field. */
48#define MAX_LABEL_LENGTH 40
49struct info_flags_t
50{
51 UINT32 flag;
52 const char* label;
53};
54
55static const struct info_flags_t info_flags[] = {
56 { INFO_MOUSE, "INFO_MOUSE" },
57 { INFO_DISABLECTRLALTDEL, "INFO_DISABLECTRLALTDEL" },
58 { INFO_AUTOLOGON, "INFO_AUTOLOGON" },
59 { INFO_UNICODE, "INFO_UNICODE" },
60 { INFO_MAXIMIZESHELL, "INFO_MAXIMIZESHELL" },
61 { INFO_LOGONNOTIFY, "INFO_LOGONNOTIFY" },
62 { INFO_COMPRESSION, "INFO_COMPRESSION" },
63 { INFO_ENABLEWINDOWSKEY, "INFO_ENABLEWINDOWSKEY" },
64 { INFO_REMOTECONSOLEAUDIO, "INFO_REMOTECONSOLEAUDIO" },
65 { INFO_FORCE_ENCRYPTED_CS_PDU, "INFO_FORCE_ENCRYPTED_CS_PDU" },
66 { INFO_RAIL, "INFO_RAIL" },
67 { INFO_LOGONERRORS, "INFO_LOGONERRORS" },
68 { INFO_MOUSE_HAS_WHEEL, "INFO_MOUSE_HAS_WHEEL" },
69 { INFO_PASSWORD_IS_SC_PIN, "INFO_PASSWORD_IS_SC_PIN" },
70 { INFO_NOAUDIOPLAYBACK, "INFO_NOAUDIOPLAYBACK" },
71 { INFO_USING_SAVED_CREDS, "INFO_USING_SAVED_CREDS" },
72 { INFO_AUDIOCAPTURE, "INFO_AUDIOCAPTURE" },
73 { INFO_VIDEO_DISABLE, "INFO_VIDEO_DISABLE" },
74 { INFO_HIDEF_RAIL_SUPPORTED, "INFO_HIDEF_RAIL_SUPPORTED" },
75};
76
77static BOOL rdp_read_info_null_string(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
78 const char* what, UINT32 flags, wStream* s, size_t cbLen,
79 size_t max)
80{
81 const BOOL unicode = (flags & INFO_UNICODE) ? TRUE : FALSE;
82
83 if (!freerdp_settings_set_string(settings, id, NULL))
84 return FALSE;
85
86 if (!Stream_CheckAndLogRequiredLength(TAG, s, (size_t)(cbLen)))
87 return FALSE;
88
89 if (cbLen > 0)
90 {
91 if ((cbLen > max) || (unicode && ((cbLen % 2) != 0)))
92 {
93 WLog_ERR(TAG, "protocol error: %s has invalid value: %" PRIuz "", what, cbLen);
94 return FALSE;
95 }
96
97 if (unicode)
98 {
99 const WCHAR* domain = Stream_PointerAs(s, WCHAR);
100 if (!freerdp_settings_set_string_from_utf16N(settings, id, domain,
101 cbLen / sizeof(WCHAR)))
102 {
103 WLog_ERR(TAG, "protocol error: no data to read for %s [expected %" PRIuz "]", what,
104 cbLen);
105 return FALSE;
106 }
107 }
108 else
109 {
110 const char* domain = Stream_ConstPointer(s);
111 if (!freerdp_settings_set_string_len(settings, id, domain, cbLen))
112 return FALSE;
113 }
114 }
115 Stream_Seek(s, cbLen);
116
117 return TRUE;
118}
119
120static char* rdp_info_package_flags_description(UINT32 flags)
121{
122 char* result = NULL;
123 size_t maximum_size = 1 + MAX_LABEL_LENGTH * ARRAYSIZE(info_flags);
124
125 result = calloc(maximum_size, sizeof(char));
126
127 if (!result)
128 return 0;
129
130 for (size_t i = 0; i < ARRAYSIZE(info_flags); i++)
131 {
132 const struct info_flags_t* cur = &info_flags[i];
133 if (cur->flag & flags)
134 {
135 winpr_str_append(cur->label, result, maximum_size, "|");
136 }
137 }
138
139 return result;
140}
141
142static BOOL rdp_compute_client_auto_reconnect_cookie(rdpRdp* rdp)
143{
144 BYTE ClientRandom[CLIENT_RANDOM_LENGTH] = { 0 };
145 BYTE AutoReconnectRandom[32] = { 0 };
146 ARC_SC_PRIVATE_PACKET* serverCookie = NULL;
147 ARC_CS_PRIVATE_PACKET* clientCookie = NULL;
148
149 WINPR_ASSERT(rdp);
150 rdpSettings* settings = rdp->settings;
151 WINPR_ASSERT(settings);
152
153 serverCookie = settings->ServerAutoReconnectCookie;
154 clientCookie = settings->ClientAutoReconnectCookie;
155 clientCookie->cbLen = 28;
156 clientCookie->version = serverCookie->version;
157 clientCookie->logonId = serverCookie->logonId;
158 ZeroMemory(clientCookie->securityVerifier, sizeof(clientCookie->securityVerifier));
159 CopyMemory(AutoReconnectRandom, serverCookie->arcRandomBits,
160 sizeof(serverCookie->arcRandomBits));
161
162 if (settings->SelectedProtocol == PROTOCOL_RDP)
163 CopyMemory(ClientRandom, settings->ClientRandom, settings->ClientRandomLength);
164
165 /* SecurityVerifier = HMAC_MD5(AutoReconnectRandom, ClientRandom) */
166
167 if (!winpr_HMAC(WINPR_MD_MD5, AutoReconnectRandom, 16, ClientRandom, sizeof(ClientRandom),
168 clientCookie->securityVerifier, sizeof(clientCookie->securityVerifier)))
169 return FALSE;
170
171 return TRUE;
172}
173
179static BOOL rdp_read_server_auto_reconnect_cookie(rdpRdp* rdp, wStream* s, logon_info_ex* info)
180{
181 BYTE* p = NULL;
182 ARC_SC_PRIVATE_PACKET* autoReconnectCookie = NULL;
183 rdpSettings* settings = rdp->settings;
184 autoReconnectCookie = settings->ServerAutoReconnectCookie;
185
186 if (!Stream_CheckAndLogRequiredLength(TAG, s, 28))
187 return FALSE;
188
189 Stream_Read_UINT32(s, autoReconnectCookie->cbLen); /* cbLen (4 bytes) */
190
191 if (autoReconnectCookie->cbLen != 28)
192 {
193 WLog_ERR(TAG, "ServerAutoReconnectCookie.cbLen != 28");
194 return FALSE;
195 }
196
197 Stream_Read_UINT32(s, autoReconnectCookie->version); /* Version (4 bytes) */
198 Stream_Read_UINT32(s, autoReconnectCookie->logonId); /* LogonId (4 bytes) */
199 Stream_Read(s, autoReconnectCookie->arcRandomBits, 16); /* ArcRandomBits (16 bytes) */
200 p = autoReconnectCookie->arcRandomBits;
201 WLog_DBG(TAG,
202 "ServerAutoReconnectCookie: Version: %" PRIu32 " LogonId: %" PRIu32
203 " SecurityVerifier: "
204 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8
205 "%02" PRIX8 ""
206 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8
207 "%02" PRIX8 "",
208 autoReconnectCookie->version, autoReconnectCookie->logonId, p[0], p[1], p[2], p[3],
209 p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
210 info->LogonId = autoReconnectCookie->logonId;
211 CopyMemory(info->ArcRandomBits, p, 16);
212
213 if ((settings->PrintReconnectCookie))
214 {
215 char* base64 = NULL;
216 base64 = crypto_base64_encode((BYTE*)autoReconnectCookie, sizeof(ARC_SC_PRIVATE_PACKET));
217 WLog_INFO(TAG, "Reconnect-cookie: %s", base64);
218 free(base64);
219 }
220
221 return TRUE;
222}
223
229static BOOL rdp_read_client_auto_reconnect_cookie(rdpRdp* rdp, wStream* s)
230{
231 ARC_CS_PRIVATE_PACKET* autoReconnectCookie = NULL;
232 rdpSettings* settings = rdp->settings;
233 autoReconnectCookie = settings->ClientAutoReconnectCookie;
234
235 if (!Stream_CheckAndLogRequiredLength(TAG, s, 28))
236 return FALSE;
237
238 Stream_Read_UINT32(s, autoReconnectCookie->cbLen); /* cbLen (4 bytes) */
239 Stream_Read_UINT32(s, autoReconnectCookie->version); /* version (4 bytes) */
240 Stream_Read_UINT32(s, autoReconnectCookie->logonId); /* LogonId (4 bytes) */
241 Stream_Read(s, autoReconnectCookie->securityVerifier, 16); /* SecurityVerifier */
242 return TRUE;
243}
244
250static BOOL rdp_write_client_auto_reconnect_cookie(rdpRdp* rdp, wStream* s)
251{
252 BYTE* p = NULL;
253 ARC_CS_PRIVATE_PACKET* autoReconnectCookie = NULL;
254 rdpSettings* settings = NULL;
255
256 WINPR_ASSERT(rdp);
257
258 settings = rdp->settings;
259 WINPR_ASSERT(settings);
260
261 autoReconnectCookie = settings->ClientAutoReconnectCookie;
262 WINPR_ASSERT(autoReconnectCookie);
263
264 p = autoReconnectCookie->securityVerifier;
265 WINPR_ASSERT(p);
266
267 WLog_DBG(TAG,
268 "ClientAutoReconnectCookie: Version: %" PRIu32 " LogonId: %" PRIu32 " ArcRandomBits: "
269 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8
270 "%02" PRIX8 ""
271 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8
272 "%02" PRIX8 "",
273 autoReconnectCookie->version, autoReconnectCookie->logonId, p[0], p[1], p[2], p[3],
274 p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
275 if (!Stream_EnsureRemainingCapacity(s, 12ull + 16ull))
276 return FALSE;
277 Stream_Write_UINT32(s, autoReconnectCookie->cbLen); /* cbLen (4 bytes) */
278 Stream_Write_UINT32(s, autoReconnectCookie->version); /* version (4 bytes) */
279 Stream_Write_UINT32(s, autoReconnectCookie->logonId); /* LogonId (4 bytes) */
280 Stream_Write(s, autoReconnectCookie->securityVerifier, 16); /* SecurityVerifier (16 bytes) */
281 return TRUE;
282}
283
284/*
285 * Get the cbClientAddress size limit
286 * see [MS-RDPBCGR] 2.2.1.11.1.1.1 Extended Info Packet (TS_EXTENDED_INFO_PACKET)
287 */
288
289static size_t rdp_get_client_address_max_size(const rdpRdp* rdp)
290{
291 UINT32 version = 0;
292 rdpSettings* settings = NULL;
293
294 WINPR_ASSERT(rdp);
295
296 settings = rdp->settings;
297 WINPR_ASSERT(settings);
298
299 version = freerdp_settings_get_uint32(settings, FreeRDP_RdpVersion);
300 if (version < RDP_VERSION_10_0)
301 return 64;
302 return 80;
303}
304
310static BOOL rdp_read_extended_info_packet(rdpRdp* rdp, wStream* s)
311{
312 UINT16 clientAddressFamily = 0;
313 UINT16 cbClientAddress = 0;
314 UINT16 cbClientDir = 0;
315 UINT16 cbAutoReconnectLen = 0;
316
317 WINPR_ASSERT(rdp);
318
319 rdpSettings* settings = rdp->settings;
320 WINPR_ASSERT(settings);
321
322 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
323 return FALSE;
324
325 Stream_Read_UINT16(s, clientAddressFamily); /* clientAddressFamily (2 bytes) */
326 Stream_Read_UINT16(s, cbClientAddress); /* cbClientAddress (2 bytes) */
327
328 settings->IPv6Enabled = (clientAddressFamily == ADDRESS_FAMILY_INET6 ? TRUE : FALSE);
329
330 if (!rdp_read_info_null_string(settings, FreeRDP_ClientAddress, "cbClientAddress", INFO_UNICODE,
331 s, cbClientAddress, rdp_get_client_address_max_size(rdp)))
332 return FALSE;
333
334 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
335 return FALSE;
336
337 Stream_Read_UINT16(s, cbClientDir); /* cbClientDir (2 bytes) */
338
339 /* cbClientDir is the size in bytes of the character data in the clientDir field.
340 * This size includes the length of the mandatory null terminator.
341 * The maximum allowed value is 512 bytes.
342 * Note: Although according to [MS-RDPBCGR 2.2.1.11.1.1.1] the null terminator
343 * is mandatory the Microsoft Android client (starting with version 8.1.31.44)
344 * sets cbClientDir to 0.
345 */
346
347 if (!rdp_read_info_null_string(settings, FreeRDP_ClientDir, "cbClientDir", INFO_UNICODE, s,
348 cbClientDir, 512))
349 return FALSE;
350
356 /* optional: clientTimeZone (172 bytes) */
357 if (Stream_GetRemainingLength(s) == 0)
358 goto end;
359
360 if (!rdp_read_client_time_zone(s, settings))
361 return FALSE;
362
363 /* optional: clientSessionId (4 bytes), should be set to 0 */
364 if (Stream_GetRemainingLength(s) == 0)
365 goto end;
366 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
367 return FALSE;
368
369 Stream_Read_UINT32(s, settings->ClientSessionId);
370
371 /* optional: performanceFlags (4 bytes) */
372 if (Stream_GetRemainingLength(s) == 0)
373 goto end;
374
375 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
376 return FALSE;
377
378 Stream_Read_UINT32(s, settings->PerformanceFlags);
379 freerdp_performance_flags_split(settings);
380
381 /* optional: cbAutoReconnectLen (2 bytes) */
382 if (Stream_GetRemainingLength(s) == 0)
383 goto end;
384
385 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
386 return FALSE;
387
388 Stream_Read_UINT16(s, cbAutoReconnectLen);
389
390 /* optional: autoReconnectCookie (28 bytes) */
391 /* must be present if cbAutoReconnectLen is > 0 */
392 if (cbAutoReconnectLen > 0)
393 {
394 if (!rdp_read_client_auto_reconnect_cookie(rdp, s))
395 return FALSE;
396 }
397
398 /* skip reserved1 and reserved2 fields */
399 if (Stream_GetRemainingLength(s) == 0)
400 goto end;
401
402 if (!Stream_SafeSeek(s, 2))
403 return FALSE;
404
405 if (Stream_GetRemainingLength(s) == 0)
406 goto end;
407
408 if (!Stream_SafeSeek(s, 2))
409 return FALSE;
410
411 if (Stream_GetRemainingLength(s) == 0)
412 goto end;
413
414 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
415 return FALSE;
416
417 if (freerdp_settings_get_bool(settings, FreeRDP_SupportDynamicTimeZone))
418 {
419 UINT16 cbDynamicDSTTimeZoneKeyName = 0;
420
421 Stream_Read_UINT16(s, cbDynamicDSTTimeZoneKeyName);
422
423 if (!rdp_read_info_null_string(settings, FreeRDP_DynamicDSTTimeZoneKeyName,
424 "cbDynamicDSTTimeZoneKeyName", INFO_UNICODE, s,
425 cbDynamicDSTTimeZoneKeyName, 254))
426 return FALSE;
427
428 if (Stream_GetRemainingLength(s) == 0)
429 goto end;
430
431 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
432 return FALSE;
433 UINT16 DynamicDaylightTimeDisabled = 0;
434 Stream_Read_UINT16(s, DynamicDaylightTimeDisabled);
435 if (DynamicDaylightTimeDisabled > 1)
436 {
437 WLog_WARN(TAG,
438 "[MS-RDPBCGR] 2.2.1.11.1.1.1 Extended Info Packet "
439 "(TS_EXTENDED_INFO_PACKET)::dynamicDaylightTimeDisabled value %" PRIu16
440 " not allowed in [0,1]",
441 settings->DynamicDaylightTimeDisabled);
442 return FALSE;
443 }
444 if (!freerdp_settings_set_bool(settings, FreeRDP_DynamicDaylightTimeDisabled,
445 DynamicDaylightTimeDisabled != 0))
446 return FALSE;
447 DEBUG_TIMEZONE("DynamicTimeZone=%s [%s]",
448 freerdp_settings_get_string(settings, FreeRDP_DynamicDSTTimeZoneKeyName),
449 freerdp_settings_get_bool(settings, FreeRDP_DynamicDaylightTimeDisabled)
450 ? "no-DST"
451 : "DST");
452 }
453
454end:
455 return TRUE;
456}
457
463static BOOL rdp_write_extended_info_packet(rdpRdp* rdp, wStream* s)
464{
465 BOOL ret = FALSE;
466 size_t cbClientAddress = 0;
467 const size_t cbClientAddressMax = rdp_get_client_address_max_size(rdp);
468 WCHAR* clientDir = NULL;
469 size_t cbClientDir = 0;
470 const size_t cbClientDirMax = 512;
471 UINT16 cbAutoReconnectCookie = 0;
472
473 WINPR_ASSERT(rdp);
474
475 rdpSettings* settings = rdp->settings;
476 WINPR_ASSERT(settings);
477
478 UINT16 clientAddressFamily = ADDRESS_FAMILY_INET;
479 if (settings->ConnectChildSession)
480 clientAddressFamily = 0x0000;
481 else if (settings->IPv6Enabled)
482 clientAddressFamily = ADDRESS_FAMILY_INET6;
483
484 WCHAR* clientAddress = ConvertUtf8ToWCharAlloc(settings->ClientAddress, &cbClientAddress);
485
486 if (cbClientAddress > (UINT16_MAX / sizeof(WCHAR)))
487 {
488 WLog_ERR(TAG, "cbClientAddress > UINT16_MAX");
489 goto fail;
490 }
491
492 if (cbClientAddress > 0)
493 {
494 cbClientAddress = (UINT16)(cbClientAddress + 1) * sizeof(WCHAR);
495 if (cbClientAddress > cbClientAddressMax)
496 {
497 WLog_WARN(TAG,
498 "the client address %s [%" PRIuz "] exceeds the limit of %" PRIuz
499 ", truncating.",
500 settings->ClientAddress, cbClientAddress, cbClientAddressMax);
501
502 clientAddress[(cbClientAddressMax / sizeof(WCHAR)) - 1] = '\0';
503 cbClientAddress = cbClientAddressMax;
504 }
505 }
506
507 clientDir = ConvertUtf8ToWCharAlloc(settings->ClientDir, &cbClientDir);
508 if (cbClientDir > (UINT16_MAX / sizeof(WCHAR)))
509 {
510 WLog_ERR(TAG, "cbClientDir > UINT16_MAX");
511 goto fail;
512 }
513
514 if (cbClientDir > 0)
515 {
516 cbClientDir = (UINT16)(cbClientDir + 1) * sizeof(WCHAR);
517 if (cbClientDir > cbClientDirMax)
518 {
519 WLog_WARN(TAG,
520 "the client dir %s [%" PRIuz "] exceeds the limit of %" PRIuz ", truncating.",
521 settings->ClientDir, cbClientDir, cbClientDirMax);
522
523 clientDir[(cbClientDirMax / sizeof(WCHAR)) - 1] = '\0';
524 cbClientDir = cbClientDirMax;
525 }
526 }
527
528 if (settings->ServerAutoReconnectCookie->cbLen > UINT16_MAX)
529 {
530 WLog_ERR(TAG, "ServerAutoreconnectCookie::cbLen > UINT16_MAX");
531 goto fail;
532 }
533
534 cbAutoReconnectCookie = (UINT16)settings->ServerAutoReconnectCookie->cbLen;
535
536 if (!Stream_EnsureRemainingCapacity(s, 4ull + cbClientAddress + 2ull + cbClientDir))
537 goto fail;
538
539 Stream_Write_UINT16(s, clientAddressFamily); /* clientAddressFamily (2 bytes) */
540 Stream_Write_UINT16(s, (UINT16)cbClientAddress); /* cbClientAddress (2 bytes) */
541
542 Stream_Write(s, clientAddress, cbClientAddress); /* clientAddress */
543
544 Stream_Write_UINT16(s, (UINT16)cbClientDir); /* cbClientDir (2 bytes) */
545
546 Stream_Write(s, clientDir, cbClientDir); /* clientDir */
547
548 if (!rdp_write_client_time_zone(s, settings)) /* clientTimeZone (172 bytes) */
549 goto fail;
550
551 if (!Stream_EnsureRemainingCapacity(s, 10ull))
552 goto fail;
553
554 /* clientSessionId (4 bytes), should be set to 0 */
555 Stream_Write_UINT32(s, settings->ClientSessionId);
556 freerdp_performance_flags_make(settings);
557 Stream_Write_UINT32(s, settings->PerformanceFlags); /* performanceFlags (4 bytes) */
558 Stream_Write_UINT16(s, cbAutoReconnectCookie); /* cbAutoReconnectCookie (2 bytes) */
559
560 if (cbAutoReconnectCookie > 0)
561 {
562 if (!rdp_compute_client_auto_reconnect_cookie(rdp))
563 goto fail;
564 if (!rdp_write_client_auto_reconnect_cookie(rdp, s)) /* autoReconnectCookie */
565 goto fail;
566 }
567
568 if (freerdp_settings_get_bool(settings, FreeRDP_SupportDynamicTimeZone))
569 {
570 if (!Stream_EnsureRemainingCapacity(s, 8 + 254 * sizeof(WCHAR)))
571 goto fail;
572
573 Stream_Write_UINT16(s, 0); /* reserved1 (2 bytes) */
574 Stream_Write_UINT16(s, 0); /* reserved2 (2 bytes) */
575
576 size_t rlen = 0;
577 const char* tz = freerdp_settings_get_string(settings, FreeRDP_DynamicDSTTimeZoneKeyName);
578 if (tz)
579 rlen = strnlen(tz, 254);
580 Stream_Write_UINT16(s, (UINT16)rlen * sizeof(WCHAR));
581 if (Stream_Write_UTF16_String_From_UTF8(s, rlen, tz, rlen, FALSE) < 0)
582 goto fail;
583 Stream_Write_UINT16(s, settings->DynamicDaylightTimeDisabled ? 0x01 : 0x00);
584 }
585
586 ret = TRUE;
587fail:
588 free(clientAddress);
589 free(clientDir);
590 return ret;
591}
592
593static BOOL rdp_read_info_string(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
594 UINT32 flags, wStream* s, size_t cbLenNonNull, size_t max)
595{
596 union
597 {
598 char c;
599 WCHAR w;
600 BYTE b[2];
601 } terminator;
602
603 const BOOL unicode = (flags & INFO_UNICODE) ? TRUE : FALSE;
604 const size_t nullSize = unicode ? sizeof(WCHAR) : sizeof(CHAR);
605
606 if (!freerdp_settings_set_string(settings, id, NULL))
607 return FALSE;
608
609 if (!Stream_CheckAndLogRequiredLength(TAG, s, (size_t)(cbLenNonNull + nullSize)))
610 return FALSE;
611
612 if (cbLenNonNull > 0)
613 {
614 /* cbDomain is the size in bytes of the character data in the Domain field.
615 * This size excludes (!) the length of the mandatory null terminator.
616 * Maximum value including the mandatory null terminator: 512
617 */
618 if ((cbLenNonNull % 2) || (cbLenNonNull > (max - nullSize)))
619 {
620 WLog_ERR(TAG, "protocol error: invalid value: %" PRIuz "", cbLenNonNull);
621 return FALSE;
622 }
623
624 if (unicode)
625 {
626 const WCHAR* domain = Stream_PointerAs(s, WCHAR);
627 if (!freerdp_settings_set_string_from_utf16N(settings, id, domain,
628 cbLenNonNull / sizeof(WCHAR)))
629 return FALSE;
630 }
631 else
632 {
633 const char* domain = Stream_PointerAs(s, char);
634 if (!freerdp_settings_set_string_len(settings, id, domain, cbLenNonNull))
635 return FALSE;
636 }
637 }
638
639 Stream_Seek(s, cbLenNonNull);
640
641 terminator.w = L'\0';
642 Stream_Read(s, terminator.b, nullSize);
643
644 if (terminator.w != L'\0')
645 {
646 WLog_ERR(TAG, "protocol error: Domain must be null terminated");
647 (void)freerdp_settings_set_string(settings, id, NULL);
648 return FALSE;
649 }
650
651 return TRUE;
652}
653
659static BOOL rdp_read_info_packet(rdpRdp* rdp, wStream* s, UINT16 tpktlength)
660{
661 BOOL smallsize = FALSE;
662 UINT32 flags = 0;
663 UINT16 cbDomain = 0;
664 UINT16 cbUserName = 0;
665 UINT16 cbPassword = 0;
666 UINT16 cbAlternateShell = 0;
667 UINT16 cbWorkingDir = 0;
668 UINT32 CompressionLevel = 0;
669 rdpSettings* settings = rdp->settings;
670
671 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 18))
672 return FALSE;
673
674 Stream_Read_UINT32(s, settings->KeyboardCodePage); /* CodePage (4 bytes ) */
675 Stream_Read_UINT32(s, flags); /* flags (4 bytes) */
676 settings->AudioCapture = ((flags & INFO_AUDIOCAPTURE) ? TRUE : FALSE);
677 settings->AudioPlayback = ((flags & INFO_NOAUDIOPLAYBACK) ? FALSE : TRUE);
678 settings->AutoLogonEnabled = ((flags & INFO_AUTOLOGON) ? TRUE : FALSE);
679 settings->RemoteApplicationMode = ((flags & INFO_RAIL) ? TRUE : FALSE);
680 settings->HiDefRemoteApp = ((flags & INFO_HIDEF_RAIL_SUPPORTED) ? TRUE : FALSE);
681 settings->RemoteConsoleAudio = ((flags & INFO_REMOTECONSOLEAUDIO) ? TRUE : FALSE);
682 settings->CompressionEnabled = ((flags & INFO_COMPRESSION) ? TRUE : FALSE);
683 settings->LogonNotify = ((flags & INFO_LOGONNOTIFY) ? TRUE : FALSE);
684 settings->MouseHasWheel = ((flags & INFO_MOUSE_HAS_WHEEL) ? TRUE : FALSE);
685 settings->DisableCtrlAltDel = ((flags & INFO_DISABLECTRLALTDEL) ? TRUE : FALSE);
686 settings->ForceEncryptedCsPdu = ((flags & INFO_FORCE_ENCRYPTED_CS_PDU) ? TRUE : FALSE);
687 settings->PasswordIsSmartcardPin = ((flags & INFO_PASSWORD_IS_SC_PIN) ? TRUE : FALSE);
688
689 if (flags & INFO_COMPRESSION)
690 {
691 CompressionLevel = ((flags & 0x00001E00) >> 9);
692 settings->CompressionLevel = CompressionLevel;
693 }
694 else
695 {
696 settings->CompressionLevel = 0;
697 }
698
699 /* RDP 4 and 5 have smaller credential limits */
700 if (settings->RdpVersion < RDP_VERSION_5_PLUS)
701 smallsize = TRUE;
702
703 Stream_Read_UINT16(s, cbDomain); /* cbDomain (2 bytes) */
704 Stream_Read_UINT16(s, cbUserName); /* cbUserName (2 bytes) */
705 Stream_Read_UINT16(s, cbPassword); /* cbPassword (2 bytes) */
706 Stream_Read_UINT16(s, cbAlternateShell); /* cbAlternateShell (2 bytes) */
707 Stream_Read_UINT16(s, cbWorkingDir); /* cbWorkingDir (2 bytes) */
708
709 if (!rdp_read_info_string(settings, FreeRDP_Domain, flags, s, cbDomain, smallsize ? 52 : 512))
710 return FALSE;
711
712 if (!rdp_read_info_string(settings, FreeRDP_Username, flags, s, cbUserName,
713 smallsize ? 44 : 512))
714 return FALSE;
715
716 if (!rdp_read_info_string(settings, FreeRDP_Password, flags, s, cbPassword,
717 smallsize ? 32 : 512))
718 return FALSE;
719
720 if (!rdp_read_info_string(settings, FreeRDP_AlternateShell, flags, s, cbAlternateShell, 512))
721 return FALSE;
722
723 if (!rdp_read_info_string(settings, FreeRDP_ShellWorkingDirectory, flags, s, cbWorkingDir, 512))
724 return FALSE;
725
726 if (settings->RdpVersion >= RDP_VERSION_5_PLUS)
727 {
728 if (!rdp_read_extended_info_packet(rdp, s)) /* extraInfo */
729 return FALSE;
730 }
731
732 const size_t xrem = Stream_GetRemainingLength(s);
733 if (!tpkt_ensure_stream_consumed(rdp->log, s, tpktlength))
734 Stream_Seek(s, xrem);
735 return TRUE;
736}
737
743static BOOL rdp_write_info_packet(rdpRdp* rdp, wStream* s)
744{
745 BOOL ret = FALSE;
746 UINT32 flags = 0;
747 WCHAR* domainW = NULL;
748 size_t cbDomain = 0;
749 WCHAR* userNameW = NULL;
750 size_t cbUserName = 0;
751 WCHAR* passwordW = NULL;
752 size_t cbPassword = 0;
753 WCHAR* alternateShellW = NULL;
754 size_t cbAlternateShell = 0;
755 WCHAR* workingDirW = NULL;
756 size_t cbWorkingDir = 0;
757 BOOL usedPasswordCookie = FALSE;
758 rdpSettings* settings = NULL;
759
760 WINPR_ASSERT(rdp);
761 settings = rdp->settings;
762 WINPR_ASSERT(settings);
763
764 flags = INFO_MOUSE | INFO_UNICODE | INFO_LOGONERRORS | INFO_MAXIMIZESHELL |
765 INFO_ENABLEWINDOWSKEY | INFO_DISABLECTRLALTDEL | INFO_MOUSE_HAS_WHEEL |
766 INFO_FORCE_ENCRYPTED_CS_PDU;
767
768 if (settings->SmartcardLogon)
769 {
770 flags |= INFO_AUTOLOGON;
771 flags |= INFO_PASSWORD_IS_SC_PIN;
772 }
773
774 if (settings->AudioCapture)
775 flags |= INFO_AUDIOCAPTURE;
776
777 if (!settings->AudioPlayback)
778 flags |= INFO_NOAUDIOPLAYBACK;
779
780 if (settings->VideoDisable)
781 flags |= INFO_VIDEO_DISABLE;
782
783 if (settings->AutoLogonEnabled)
784 flags |= INFO_AUTOLOGON;
785
786 if (settings->RemoteApplicationMode)
787 {
788 if (settings->HiDefRemoteApp)
789 {
790 if (settings->RdpVersion >= RDP_VERSION_5_PLUS)
791 flags |= INFO_HIDEF_RAIL_SUPPORTED;
792 }
793
794 flags |= INFO_RAIL;
795 }
796
797 if (settings->RemoteConsoleAudio)
798 flags |= INFO_REMOTECONSOLEAUDIO;
799
800 if (settings->CompressionEnabled)
801 {
802 flags |= INFO_COMPRESSION;
803 flags |= ((settings->CompressionLevel << 9) & 0x00001E00);
804 }
805
806 if (settings->LogonNotify)
807 flags |= INFO_LOGONNOTIFY;
808
809 if (settings->PasswordIsSmartcardPin)
810 flags |= INFO_PASSWORD_IS_SC_PIN;
811
812 {
813 char* flags_description = rdp_info_package_flags_description(flags);
814
815 if (flags_description)
816 {
817 WLog_DBG(TAG, "Client Info Packet Flags = %s", flags_description);
818 free(flags_description);
819 }
820 }
821
822 domainW = freerdp_settings_get_string_as_utf16(settings, FreeRDP_Domain, &cbDomain);
823 if (cbDomain > UINT16_MAX / sizeof(WCHAR))
824 {
825 WLog_ERR(TAG, "cbDomain > UINT16_MAX");
826 goto fail;
827 }
828 cbDomain *= sizeof(WCHAR);
829
830 /* user name provided by the expert for connecting to the novice computer */
831 userNameW = freerdp_settings_get_string_as_utf16(settings, FreeRDP_Username, &cbUserName);
832 if (cbUserName > UINT16_MAX / sizeof(WCHAR))
833 {
834 WLog_ERR(TAG, "cbUserName > UINT16_MAX");
835 goto fail;
836 }
837 cbUserName *= sizeof(WCHAR);
838
839 {
840 const char* pin = "*";
841 if (!settings->RemoteAssistanceMode)
842 {
843 /* Ignore redirection password if we´re using smartcard and have the pin as password */
844 if (((flags & INFO_PASSWORD_IS_SC_PIN) == 0) && settings->RedirectionPassword &&
845 (settings->RedirectionPasswordLength > 0))
846 {
847 union
848 {
849 BYTE* bp;
850 WCHAR* wp;
851 } ptrconv;
852
853 if (settings->RedirectionPasswordLength > UINT16_MAX)
854 {
855 WLog_ERR(TAG, "RedirectionPasswordLength > UINT16_MAX");
856 goto fail;
857 }
858 usedPasswordCookie = TRUE;
859
860 ptrconv.bp = settings->RedirectionPassword;
861 passwordW = ptrconv.wp;
862 cbPassword = (UINT16)settings->RedirectionPasswordLength;
863 }
864 else
865 pin = freerdp_settings_get_string(settings, FreeRDP_Password);
866 }
867
868 if (!usedPasswordCookie && pin)
869 {
870 passwordW = ConvertUtf8ToWCharAlloc(pin, &cbPassword);
871 if (cbPassword > UINT16_MAX / sizeof(WCHAR))
872 {
873 WLog_ERR(TAG, "cbPassword > UINT16_MAX");
874 goto fail;
875 }
876 cbPassword = (UINT16)cbPassword * sizeof(WCHAR);
877 }
878 }
879
880 {
881 const char* altShell = NULL;
882 if (!settings->RemoteAssistanceMode)
883 altShell = freerdp_settings_get_string(settings, FreeRDP_AlternateShell);
884 else if (settings->RemoteAssistancePassStub)
885 altShell = "*"; /* This field MUST be filled with "*" */
886 else
887 altShell = freerdp_settings_get_string(settings, FreeRDP_RemoteAssistancePassword);
888
889 if (altShell && strlen(altShell) > 0)
890 {
891 alternateShellW = ConvertUtf8ToWCharAlloc(altShell, &cbAlternateShell);
892 if (!alternateShellW)
893 {
894 WLog_ERR(TAG, "alternateShellW == NULL");
895 goto fail;
896 }
897 if (cbAlternateShell > (UINT16_MAX / sizeof(WCHAR)))
898 {
899 WLog_ERR(TAG, "cbAlternateShell > UINT16_MAX");
900 goto fail;
901 }
902 cbAlternateShell = (UINT16)cbAlternateShell * sizeof(WCHAR);
903 }
904 }
905
906 {
907 FreeRDP_Settings_Keys_String inputId = FreeRDP_RemoteAssistanceSessionId;
908 if (!freerdp_settings_get_bool(settings, FreeRDP_RemoteAssistanceMode))
909 inputId = FreeRDP_ShellWorkingDirectory;
910
911 workingDirW = freerdp_settings_get_string_as_utf16(settings, inputId, &cbWorkingDir);
912 }
913 if (cbWorkingDir > (UINT16_MAX / sizeof(WCHAR)))
914 {
915 WLog_ERR(TAG, "cbWorkingDir > UINT16_MAX");
916 goto fail;
917 }
918 cbWorkingDir = (UINT16)cbWorkingDir * sizeof(WCHAR);
919
920 if (!Stream_EnsureRemainingCapacity(s, 18ull + cbDomain + cbUserName + cbPassword +
921 cbAlternateShell + cbWorkingDir + 5 * sizeof(WCHAR)))
922 goto fail;
923
924 Stream_Write_UINT32(s, settings->KeyboardCodePage); /* CodePage (4 bytes) */
925 Stream_Write_UINT32(s, flags); /* flags (4 bytes) */
926 Stream_Write_UINT16(s, (UINT16)cbDomain); /* cbDomain (2 bytes) */
927 Stream_Write_UINT16(s, (UINT16)cbUserName); /* cbUserName (2 bytes) */
928 Stream_Write_UINT16(s, (UINT16)cbPassword); /* cbPassword (2 bytes) */
929 Stream_Write_UINT16(s, (UINT16)cbAlternateShell); /* cbAlternateShell (2 bytes) */
930 Stream_Write_UINT16(s, (UINT16)cbWorkingDir); /* cbWorkingDir (2 bytes) */
931
932 Stream_Write(s, domainW, cbDomain);
933
934 /* the mandatory null terminator */
935 Stream_Write_UINT16(s, 0);
936
937 Stream_Write(s, userNameW, cbUserName);
938
939 /* the mandatory null terminator */
940 Stream_Write_UINT16(s, 0);
941
942 Stream_Write(s, passwordW, cbPassword);
943
944 /* the mandatory null terminator */
945 Stream_Write_UINT16(s, 0);
946
947 Stream_Write(s, alternateShellW, cbAlternateShell);
948
949 /* the mandatory null terminator */
950 Stream_Write_UINT16(s, 0);
951
952 Stream_Write(s, workingDirW, cbWorkingDir);
953
954 /* the mandatory null terminator */
955 Stream_Write_UINT16(s, 0);
956 ret = TRUE;
957fail:
958 free(domainW);
959 free(userNameW);
960 free(alternateShellW);
961 free(workingDirW);
962
963 if (!usedPasswordCookie)
964 free(passwordW);
965
966 if (!ret)
967 return FALSE;
968
969 if (settings->RdpVersion >= RDP_VERSION_5_PLUS)
970 ret = rdp_write_extended_info_packet(rdp, s); /* extraInfo */
971
972 return ret;
973}
974
982BOOL rdp_recv_client_info(rdpRdp* rdp, wStream* s)
983{
984 UINT16 length = 0;
985 UINT16 channelId = 0;
986 UINT16 securityFlags = 0;
987
988 WINPR_ASSERT(rdp_get_state(rdp) == CONNECTION_STATE_SECURE_SETTINGS_EXCHANGE);
989
990 if (!rdp_read_header(rdp, s, &length, &channelId))
991 return FALSE;
992
993 if (!rdp_read_security_header(rdp, s, &securityFlags, &length))
994 return FALSE;
995
996 if ((securityFlags & SEC_INFO_PKT) == 0)
997 return FALSE;
998
999 if (rdp->settings->UseRdpSecurityLayer)
1000 {
1001 if (securityFlags & SEC_REDIRECTION_PKT)
1002 {
1003 WLog_ERR(TAG, "Error: SEC_REDIRECTION_PKT unsupported");
1004 return FALSE;
1005 }
1006
1007 if (securityFlags & SEC_ENCRYPT)
1008 {
1009 if (!rdp_decrypt(rdp, s, &length, securityFlags))
1010 return FALSE;
1011 }
1012 }
1013
1014 return rdp_read_info_packet(rdp, s, length);
1015}
1016
1023BOOL rdp_send_client_info(rdpRdp* rdp)
1024{
1025 UINT16 sec_flags = SEC_INFO_PKT;
1026 wStream* s = NULL;
1027 WINPR_ASSERT(rdp);
1028 s = rdp_send_stream_init(rdp, &sec_flags);
1029
1030 if (!s)
1031 {
1032 WLog_ERR(TAG, "Stream_New failed!");
1033 return FALSE;
1034 }
1035
1036 if (!rdp_write_info_packet(rdp, s))
1037 {
1038 Stream_Release(s);
1039 return FALSE;
1040 }
1041 return rdp_send(rdp, s, MCS_GLOBAL_CHANNEL_ID, sec_flags);
1042}
1043
1044static void rdp_free_logon_info(logon_info* info)
1045{
1046 if (!info)
1047 return;
1048 free(info->domain);
1049 free(info->username);
1050
1051 const logon_info empty = { 0 };
1052 *info = empty;
1053}
1054
1055static BOOL rdp_info_read_string(const char* what, wStream* s, size_t size, size_t max,
1056 BOOL skipMax, char** dst)
1057{
1058 WINPR_ASSERT(dst);
1059 *dst = NULL;
1060
1061 if (size == 0)
1062 {
1063 if (skipMax)
1064 return Stream_SafeSeek(s, max);
1065 return TRUE;
1066 }
1067
1068 if (((size % sizeof(WCHAR)) != 0) || (size > max))
1069 {
1070 WLog_ERR(TAG, "protocol error: invalid %s value: %" PRIu32 "", what, size);
1071 return FALSE;
1072 }
1073
1074 const WCHAR* str = Stream_ConstPointer(s);
1075 if (!Stream_SafeSeek(s, skipMax ? max : size))
1076 return FALSE;
1077
1078 if (str[size / sizeof(WCHAR) - 1])
1079 {
1080 WLog_ERR(TAG, "protocol error: %s must be null terminated", what);
1081 return FALSE;
1082 }
1083
1084 size_t len = 0;
1085 char* rc = ConvertWCharNToUtf8Alloc(str, size / sizeof(WCHAR), &len);
1086 if (!rc)
1087 {
1088 WLog_ERR(TAG, "failed to convert the %s string", what);
1089 free(rc);
1090 return FALSE;
1091 }
1092
1093 *dst = rc;
1094 return TRUE;
1095}
1096
1097static BOOL rdp_recv_logon_info_v1(rdpRdp* rdp, wStream* s, logon_info* info)
1098{
1099 UINT32 cbDomain = 0;
1100 UINT32 cbUserName = 0;
1101
1102 WINPR_UNUSED(rdp);
1103 WINPR_ASSERT(info);
1104
1105 if (!Stream_CheckAndLogRequiredLength(TAG, s, 576))
1106 return FALSE;
1107
1108 Stream_Read_UINT32(s, cbDomain); /* cbDomain (4 bytes) */
1109
1110 /* cbDomain is the size of the Unicode character data (including the mandatory
1111 * null terminator) in bytes present in the fixed-length (52 bytes) Domain field
1112 */
1113 if (!rdp_info_read_string("Domain", s, cbDomain, 52, TRUE, &info->domain))
1114 goto fail;
1115
1116 Stream_Read_UINT32(s, cbUserName); /* cbUserName (4 bytes) */
1117
1118 /* cbUserName is the size of the Unicode character data (including the mandatory
1119 * null terminator) in bytes present in the fixed-length (512 bytes) UserName field.
1120 */
1121 if (!rdp_info_read_string("UserName", s, cbUserName, 512, TRUE, &info->username))
1122 goto fail;
1123
1124 Stream_Read_UINT32(s, info->sessionId); /* SessionId (4 bytes) */
1125 WLog_DBG(TAG, "LogonInfoV1: SessionId: 0x%08" PRIX32 " UserName: [%s] Domain: [%s]",
1126 info->sessionId, info->username, info->domain);
1127 return TRUE;
1128fail:
1129 return FALSE;
1130}
1131
1132static BOOL rdp_recv_logon_info_v2(rdpRdp* rdp, wStream* s, logon_info* info)
1133{
1134 UINT16 Version = 0;
1135 UINT32 Size = 0;
1136 UINT32 cbDomain = 0;
1137 UINT32 cbUserName = 0;
1138
1139 WINPR_ASSERT(rdp);
1140 WINPR_ASSERT(s);
1141 WINPR_ASSERT(info);
1142
1143 WINPR_UNUSED(rdp);
1144
1145 if (!Stream_CheckAndLogRequiredLength(TAG, s, logonInfoV2TotalSize))
1146 return FALSE;
1147
1148 Stream_Read_UINT16(s, Version); /* Version (2 bytes) */
1149 if (Version != SAVE_SESSION_PDU_VERSION_ONE)
1150 {
1151 WLog_WARN(TAG, "LogonInfoV2::Version expected %" PRIu16 " bytes, got %" PRIu16,
1152 SAVE_SESSION_PDU_VERSION_ONE, Version);
1153 return FALSE;
1154 }
1155
1156 Stream_Read_UINT32(s, Size); /* Size (4 bytes) */
1157
1158 /* [MS-RDPBCGR] 2.2.10.1.1.2 Logon Info Version 2 (TS_LOGON_INFO_VERSION_2)
1159 * should be logonInfoV2TotalSize
1160 * but even MS server 2019 sends logonInfoV2Size
1161 */
1162 if (Size != logonInfoV2TotalSize)
1163 {
1164 if (Size != logonInfoV2Size)
1165 {
1166 WLog_WARN(TAG, "LogonInfoV2::Size expected %" PRIu32 " bytes, got %" PRIu32,
1167 logonInfoV2TotalSize, Size);
1168 return FALSE;
1169 }
1170 }
1171
1172 Stream_Read_UINT32(s, info->sessionId); /* SessionId (4 bytes) */
1173 Stream_Read_UINT32(s, cbDomain); /* cbDomain (4 bytes) */
1174 Stream_Read_UINT32(s, cbUserName); /* cbUserName (4 bytes) */
1175 Stream_Seek(s, logonInfoV2ReservedSize); /* pad (558 bytes) */
1176
1177 /* cbDomain is the size in bytes of the Unicode character data in the Domain field.
1178 * The size of the mandatory null terminator is include in this value.
1179 * Note: Since MS-RDPBCGR 2.2.10.1.1.2 does not mention any size limits we assume
1180 * that the maximum value is 52 bytes, according to the fixed size of the
1181 * Domain field in the Logon Info Version 1 (TS_LOGON_INFO) structure.
1182 */
1183 if (!rdp_info_read_string("Domain", s, cbDomain, 52, FALSE, &info->domain))
1184 goto fail;
1185
1186 /* cbUserName is the size in bytes of the Unicode character data in the UserName field.
1187 * The size of the mandatory null terminator is include in this value.
1188 * Note: Since MS-RDPBCGR 2.2.10.1.1.2 does not mention any size limits we assume
1189 * that the maximum value is 512 bytes, according to the fixed size of the
1190 * Username field in the Logon Info Version 1 (TS_LOGON_INFO) structure.
1191 */
1192 if (!rdp_info_read_string("UserName", s, cbUserName, 512, FALSE, &info->username))
1193 goto fail;
1194
1195 /* We´ve seen undocumented padding with windows 11 here.
1196 * unless it has actual data in it ignore it.
1197 * if there is unexpected data, print a warning and dump the contents
1198 */
1199 {
1200 const size_t rem = Stream_GetRemainingLength(s);
1201 if (rem > 0)
1202 {
1203 BOOL warn = FALSE;
1204 const char* str = Stream_ConstPointer(s);
1205 for (size_t x = 0; x < rem; x++)
1206 {
1207 if (str[x] != '\0')
1208 warn = TRUE;
1209 }
1210 if (warn)
1211 {
1212 WLog_WARN(TAG, "unexpected padding of %" PRIuz " bytes, data not '\0'", rem);
1213 winpr_HexDump(TAG, WLOG_TRACE, str, rem);
1214 }
1215
1216 if (!Stream_SafeSeek(s, rem))
1217 goto fail;
1218 }
1219 }
1220
1221 WLog_DBG(TAG, "LogonInfoV2: SessionId: 0x%08" PRIX32 " UserName: [%s] Domain: [%s]",
1222 info->sessionId, info->username, info->domain);
1223 return TRUE;
1224fail:
1225 return FALSE;
1226}
1227
1228static BOOL rdp_recv_logon_plain_notify(rdpRdp* rdp, wStream* s)
1229{
1230 WINPR_UNUSED(rdp);
1231 if (!Stream_CheckAndLogRequiredLength(TAG, s, 576))
1232 return FALSE;
1233
1234 Stream_Seek(s, 576); /* pad (576 bytes) */
1235 WLog_DBG(TAG, "LogonPlainNotify");
1236 return TRUE;
1237}
1238
1239static BOOL rdp_recv_logon_error_info(rdpRdp* rdp, wStream* s, logon_info_ex* info)
1240{
1241 freerdp* instance = NULL;
1242 UINT32 errorNotificationType = 0;
1243 UINT32 errorNotificationData = 0;
1244
1245 WINPR_ASSERT(rdp);
1246 WINPR_ASSERT(rdp->context);
1247 WINPR_ASSERT(s);
1248 WINPR_ASSERT(info);
1249
1250 instance = rdp->context->instance;
1251 WINPR_ASSERT(instance);
1252
1253 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
1254 return FALSE;
1255
1256 Stream_Read_UINT32(s, errorNotificationType); /* errorNotificationType (4 bytes) */
1257 Stream_Read_UINT32(s, errorNotificationData); /* errorNotificationData (4 bytes) */
1258 WLog_DBG(TAG, "LogonErrorInfo: Data: 0x%08" PRIX32 " Type: 0x%08" PRIX32 "",
1259 errorNotificationData, errorNotificationType);
1260 IFCALL(instance->LogonErrorInfo, instance, errorNotificationData, errorNotificationType);
1261 info->ErrorNotificationType = errorNotificationType;
1262 info->ErrorNotificationData = errorNotificationData;
1263 return TRUE;
1264}
1265
1266static BOOL rdp_recv_logon_info_extended(rdpRdp* rdp, wStream* s, logon_info_ex* info)
1267{
1268 UINT32 cbFieldData = 0;
1269 UINT32 fieldsPresent = 0;
1270 UINT16 Length = 0;
1271
1272 WINPR_ASSERT(rdp);
1273 WINPR_ASSERT(s);
1274 WINPR_ASSERT(info);
1275
1276 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
1277 {
1278 WLog_WARN(TAG, "received short logon info extended, need 6 bytes, got %" PRIuz,
1279 Stream_GetRemainingLength(s));
1280 return FALSE;
1281 }
1282
1283 Stream_Read_UINT16(s, Length); /* Length (2 bytes) */
1284 Stream_Read_UINT32(s, fieldsPresent); /* fieldsPresent (4 bytes) */
1285
1286 if ((Length < 6) || (!Stream_CheckAndLogRequiredLength(TAG, s, (Length - 6U))))
1287 {
1288 WLog_WARN(TAG,
1289 "received short logon info extended, need %" PRIu16 " - 6 bytes, got %" PRIuz,
1290 Length, Stream_GetRemainingLength(s));
1291 return FALSE;
1292 }
1293
1294 WLog_DBG(TAG, "LogonInfoExtended: fieldsPresent: 0x%08" PRIX32 "", fieldsPresent);
1295
1296 /* logonFields */
1297
1298 if (fieldsPresent & LOGON_EX_AUTORECONNECTCOOKIE)
1299 {
1300 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
1301 return FALSE;
1302
1303 info->haveCookie = TRUE;
1304 Stream_Read_UINT32(s, cbFieldData); /* cbFieldData (4 bytes) */
1305
1306 if (!Stream_CheckAndLogRequiredLength(TAG, s, cbFieldData))
1307 return FALSE;
1308
1309 if (!rdp_read_server_auto_reconnect_cookie(rdp, s, info))
1310 return FALSE;
1311 }
1312
1313 if (fieldsPresent & LOGON_EX_LOGONERRORS)
1314 {
1315 info->haveErrorInfo = TRUE;
1316
1317 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
1318 return FALSE;
1319
1320 Stream_Read_UINT32(s, cbFieldData); /* cbFieldData (4 bytes) */
1321
1322 if (!Stream_CheckAndLogRequiredLength(TAG, s, cbFieldData))
1323 return FALSE;
1324
1325 if (!rdp_recv_logon_error_info(rdp, s, info))
1326 return FALSE;
1327 }
1328
1329 if (!Stream_CheckAndLogRequiredLength(TAG, s, 570))
1330 return FALSE;
1331
1332 Stream_Seek(s, 570); /* pad (570 bytes) */
1333 return TRUE;
1334}
1335
1336BOOL rdp_recv_save_session_info(rdpRdp* rdp, wStream* s)
1337{
1338 UINT32 infoType = 0;
1339 BOOL status = 0;
1340 logon_info logonInfo = { 0 };
1341 logon_info_ex logonInfoEx = { 0 };
1342 rdpContext* context = rdp->context;
1343 rdpUpdate* update = rdp->context->update;
1344
1345 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
1346 return FALSE;
1347
1348 Stream_Read_UINT32(s, infoType); /* infoType (4 bytes) */
1349
1350 switch (infoType)
1351 {
1352 case INFO_TYPE_LOGON:
1353 status = rdp_recv_logon_info_v1(rdp, s, &logonInfo);
1354
1355 if (status && update->SaveSessionInfo)
1356 status = update->SaveSessionInfo(context, infoType, &logonInfo);
1357
1358 rdp_free_logon_info(&logonInfo);
1359 break;
1360
1361 case INFO_TYPE_LOGON_LONG:
1362 status = rdp_recv_logon_info_v2(rdp, s, &logonInfo);
1363
1364 if (status && update->SaveSessionInfo)
1365 status = update->SaveSessionInfo(context, infoType, &logonInfo);
1366
1367 rdp_free_logon_info(&logonInfo);
1368 break;
1369
1370 case INFO_TYPE_LOGON_PLAIN_NOTIFY:
1371 status = rdp_recv_logon_plain_notify(rdp, s);
1372
1373 if (status && update->SaveSessionInfo)
1374 status = update->SaveSessionInfo(context, infoType, NULL);
1375
1376 break;
1377
1378 case INFO_TYPE_LOGON_EXTENDED_INF:
1379 status = rdp_recv_logon_info_extended(rdp, s, &logonInfoEx);
1380
1381 if (status && update->SaveSessionInfo)
1382 status = update->SaveSessionInfo(context, infoType, &logonInfoEx);
1383
1384 break;
1385
1386 default:
1387 WLog_ERR(TAG, "Unhandled saveSessionInfo type 0x%" PRIx32 "", infoType);
1388 status = TRUE;
1389 break;
1390 }
1391
1392 if (!status)
1393 {
1394 WLog_DBG(TAG, "SaveSessionInfo error: infoType: %s (%" PRIu32 ")",
1395 infoType < 4 ? INFO_TYPE_LOGON_STRINGS[infoType % 4] : "Unknown", infoType);
1396 }
1397
1398 return status;
1399}
1400
1401static BOOL rdp_write_logon_info_v1(wStream* s, logon_info* info)
1402{
1403 const size_t charLen = 52 / sizeof(WCHAR);
1404 const size_t userCharLen = 512 / sizeof(WCHAR);
1405
1406 size_t sz = 4 + 52 + 4 + 512 + 4;
1407
1408 if (!Stream_EnsureRemainingCapacity(s, sz))
1409 return FALSE;
1410
1411 /* domain */
1412 {
1413 WINPR_ASSERT(info);
1414 if (!info->domain || !info->username)
1415 return FALSE;
1416 const size_t len = strnlen(info->domain, charLen + 1);
1417 if (len > charLen)
1418 return FALSE;
1419
1420 const size_t wlen = len * sizeof(WCHAR);
1421 if (wlen > UINT32_MAX)
1422 return FALSE;
1423
1424 Stream_Write_UINT32(s, (UINT32)wlen);
1425 if (Stream_Write_UTF16_String_From_UTF8(s, charLen, info->domain, len, TRUE) < 0)
1426 return FALSE;
1427 }
1428
1429 /* username */
1430 {
1431 const size_t len = strnlen(info->username, userCharLen + 1);
1432 if (len > userCharLen)
1433 return FALSE;
1434
1435 const size_t wlen = len * sizeof(WCHAR);
1436 if (wlen > UINT32_MAX)
1437 return FALSE;
1438
1439 Stream_Write_UINT32(s, (UINT32)wlen);
1440
1441 if (Stream_Write_UTF16_String_From_UTF8(s, userCharLen, info->username, len, TRUE) < 0)
1442 return FALSE;
1443 }
1444
1445 /* sessionId */
1446 Stream_Write_UINT32(s, info->sessionId);
1447 return TRUE;
1448}
1449
1450static BOOL rdp_write_logon_info_v2(wStream* s, logon_info* info)
1451{
1452 size_t domainLen = 0;
1453 size_t usernameLen = 0;
1454
1455 if (!Stream_EnsureRemainingCapacity(s, logonInfoV2TotalSize))
1456 return FALSE;
1457
1458 Stream_Write_UINT16(s, SAVE_SESSION_PDU_VERSION_ONE);
1459 /* [MS-RDPBCGR] 2.2.10.1.1.2 Logon Info Version 2 (TS_LOGON_INFO_VERSION_2)
1460 * should be logonInfoV2TotalSize
1461 * but even MS server 2019 sends logonInfoV2Size
1462 */
1463 Stream_Write_UINT32(s, logonInfoV2Size);
1464 Stream_Write_UINT32(s, info->sessionId);
1465 domainLen = strnlen(info->domain, 256); /* lmcons.h UNLEN */
1466 if (domainLen >= UINT32_MAX / sizeof(WCHAR))
1467 return FALSE;
1468 Stream_Write_UINT32(s, (UINT32)(domainLen + 1) * sizeof(WCHAR));
1469 usernameLen = strnlen(info->username, 256); /* lmcons.h UNLEN */
1470 if (usernameLen >= UINT32_MAX / sizeof(WCHAR))
1471 return FALSE;
1472 Stream_Write_UINT32(s, (UINT32)(usernameLen + 1) * sizeof(WCHAR));
1473 Stream_Seek(s, logonInfoV2ReservedSize);
1474 if (Stream_Write_UTF16_String_From_UTF8(s, domainLen + 1, info->domain, domainLen, TRUE) < 0)
1475 return FALSE;
1476 if (Stream_Write_UTF16_String_From_UTF8(s, usernameLen + 1, info->username, usernameLen, TRUE) <
1477 0)
1478 return FALSE;
1479 return TRUE;
1480}
1481
1482static BOOL rdp_write_logon_info_plain(wStream* s)
1483{
1484 if (!Stream_EnsureRemainingCapacity(s, 576))
1485 return FALSE;
1486
1487 Stream_Seek(s, 576);
1488 return TRUE;
1489}
1490
1491static BOOL rdp_write_logon_info_ex(wStream* s, logon_info_ex* info)
1492{
1493 UINT32 FieldsPresent = 0;
1494 UINT16 Size = 2 + 4 + 570;
1495
1496 if (info->haveCookie)
1497 {
1498 FieldsPresent |= LOGON_EX_AUTORECONNECTCOOKIE;
1499 Size += 28;
1500 }
1501
1502 if (info->haveErrorInfo)
1503 {
1504 FieldsPresent |= LOGON_EX_LOGONERRORS;
1505 Size += 8;
1506 }
1507
1508 if (!Stream_EnsureRemainingCapacity(s, Size))
1509 return FALSE;
1510
1511 Stream_Write_UINT16(s, Size);
1512 Stream_Write_UINT32(s, FieldsPresent);
1513
1514 if (info->haveCookie)
1515 {
1516 Stream_Write_UINT32(s, 28); /* cbFieldData (4 bytes) */
1517 Stream_Write_UINT32(s, 28); /* cbLen (4 bytes) */
1518 Stream_Write_UINT32(s, AUTO_RECONNECT_VERSION_1); /* Version (4 bytes) */
1519 Stream_Write_UINT32(s, info->LogonId); /* LogonId (4 bytes) */
1520 Stream_Write(s, info->ArcRandomBits, 16); /* ArcRandomBits (16 bytes) */
1521 }
1522
1523 if (info->haveErrorInfo)
1524 {
1525 Stream_Write_UINT32(s, 8); /* cbFieldData (4 bytes) */
1526 Stream_Write_UINT32(s, info->ErrorNotificationType); /* ErrorNotificationType (4 bytes) */
1527 Stream_Write_UINT32(s, info->ErrorNotificationData); /* ErrorNotificationData (4 bytes) */
1528 }
1529
1530 Stream_Seek(s, 570);
1531 return TRUE;
1532}
1533
1534BOOL rdp_send_save_session_info(rdpContext* context, UINT32 type, void* data)
1535{
1536 UINT16 sec_flags = 0;
1537 wStream* s = NULL;
1538 BOOL status = 0;
1539 rdpRdp* rdp = context->rdp;
1540 s = rdp_data_pdu_init(rdp, &sec_flags);
1541
1542 if (!s)
1543 return FALSE;
1544
1545 Stream_Write_UINT32(s, type);
1546
1547 switch (type)
1548 {
1549 case INFO_TYPE_LOGON:
1550 status = rdp_write_logon_info_v1(s, (logon_info*)data);
1551 break;
1552
1553 case INFO_TYPE_LOGON_LONG:
1554 status = rdp_write_logon_info_v2(s, (logon_info*)data);
1555 break;
1556
1557 case INFO_TYPE_LOGON_PLAIN_NOTIFY:
1558 status = rdp_write_logon_info_plain(s);
1559 break;
1560
1561 case INFO_TYPE_LOGON_EXTENDED_INF:
1562 status = rdp_write_logon_info_ex(s, (logon_info_ex*)data);
1563 break;
1564
1565 default:
1566 WLog_ERR(TAG, "saveSessionInfo type 0x%" PRIx32 " not handled", type);
1567 status = FALSE;
1568 break;
1569 }
1570
1571 if (status)
1572 status =
1573 rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SAVE_SESSION_INFO, rdp->mcs->userId, sec_flags);
1574 else
1575 Stream_Release(s);
1576
1577 return status;
1578}
1579
1580BOOL rdp_send_server_status_info(rdpContext* context, UINT32 status)
1581{
1582 UINT16 sec_flags = 0;
1583 wStream* s = NULL;
1584 rdpRdp* rdp = context->rdp;
1585 s = rdp_data_pdu_init(rdp, &sec_flags);
1586
1587 if (!s)
1588 return FALSE;
1589
1590 Stream_Write_UINT32(s, status);
1591 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_STATUS_INFO, rdp->mcs->userId, sec_flags);
1592}
freerdp_settings_get_uint32
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_set_string
FREERDP_API BOOL freerdp_settings_set_string(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const char *param)
Sets a string settings value. The param is copied.
Definition settings_getters.c:3746
freerdp_settings_get_bool
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
freerdp_settings_set_string_from_utf16N
FREERDP_API BOOL freerdp_settings_set_string_from_utf16N(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const WCHAR *param, size_t length)
Sets a string settings value. The param is converted to UTF-8 and the copy stored.
Definition common/settings.c:2275
freerdp_settings_get_string_as_utf16
FREERDP_API WCHAR * freerdp_settings_get_string_as_utf16(const rdpSettings *settings, FreeRDP_Settings_Keys_String id, size_t *pCharLen)
Return an allocated UTF16 string.
Definition common/settings.c:2298
freerdp_settings_set_string_len
FREERDP_API BOOL freerdp_settings_set_string_len(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const char *param, size_t len)
Sets a string settings value. The param is copied.
Definition settings_getters.c:3740
freerdp_settings_get_string
FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
freerdp_settings_set_bool
FREERDP_API BOOL freerdp_settings_set_bool(rdpSettings *settings, FreeRDP_Settings_Keys_Bool id, BOOL param)
Sets a BOOL settings value.
ARC_CS_PRIVATE_PACKET
Definition settings_types.h:348
ARC_SC_PRIVATE_PACKET
Definition settings_types.h:357