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