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, 8 + 254 * 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 WINPR_ASSERT(rdp_get_state(rdp) == CONNECTION_STATE_SECURE_SETTINGS_EXCHANGE);
1066
1067 if (!rdp_read_header(rdp, s, &length, &channelId))
1068 return FALSE;
1069
1070 if (!rdp_read_security_header(rdp, s, &securityFlags, &length))
1071 return FALSE;
1072
1073 if ((securityFlags & SEC_INFO_PKT) == 0)
1074 return FALSE;
1075
1076 if (rdp->settings->UseRdpSecurityLayer)
1077 {
1078 if (securityFlags & SEC_REDIRECTION_PKT)
1079 {
1080 WLog_ERR(TAG, "Error: SEC_REDIRECTION_PKT unsupported");
1081 return FALSE;
1082 }
1083
1084 if (securityFlags & SEC_ENCRYPT)
1085 {
1086 if (!rdp_decrypt(rdp, s, &length, securityFlags))
1087 return FALSE;
1088 }
1089 }
1090
1091 return rdp_read_info_packet(rdp, s, length);
1092}
1093
1100BOOL rdp_send_client_info(rdpRdp* rdp)
1101{
1102 UINT16 sec_flags = SEC_INFO_PKT;
1103 wStream* s = nullptr;
1104 WINPR_ASSERT(rdp);
1105 s = rdp_send_stream_init(rdp, &sec_flags);
1106
1107 if (!s)
1108 {
1109 WLog_ERR(TAG, "Stream_New failed!");
1110 return FALSE;
1111 }
1112
1113 if (!rdp_write_info_packet(rdp, s))
1114 {
1115 Stream_Release(s);
1116 return FALSE;
1117 }
1118 return rdp_send(rdp, s, MCS_GLOBAL_CHANNEL_ID, sec_flags);
1119}
1120
1121static void rdp_free_logon_info(logon_info* info)
1122{
1123 if (!info)
1124 return;
1125 free(info->domain);
1126 free(info->username);
1127
1128 const logon_info empty = WINPR_C_ARRAY_INIT;
1129 *info = empty;
1130}
1131
1132static BOOL rdp_info_read_string(const char* what, wStream* s, size_t size, size_t max,
1133 BOOL skipMax, char** dst)
1134{
1135 WINPR_ASSERT(dst);
1136 *dst = nullptr;
1137
1138 if (size == 0)
1139 {
1140 if (skipMax)
1141 return Stream_SafeSeek(s, max);
1142 return TRUE;
1143 }
1144
1145 if (((size % sizeof(WCHAR)) != 0) || (size > max))
1146 {
1147 WLog_ERR(TAG, "protocol error: invalid %s value: %" PRIuz "", what, size);
1148 return FALSE;
1149 }
1150
1151 const WCHAR* str = Stream_ConstPointer(s);
1152 if (!Stream_SafeSeek(s, skipMax ? max : size))
1153 return FALSE;
1154
1155 if (str[size / sizeof(WCHAR) - 1])
1156 {
1157 WLog_ERR(TAG, "protocol error: %s must be null terminated", what);
1158 return FALSE;
1159 }
1160
1161 size_t len = 0;
1162 char* rc = ConvertWCharNToUtf8Alloc(str, size / sizeof(WCHAR), &len);
1163 if (!rc)
1164 {
1165 WLog_ERR(TAG, "failed to convert the %s string", what);
1166 free(rc);
1167 return FALSE;
1168 }
1169
1170 *dst = rc;
1171 return TRUE;
1172}
1173
1174static BOOL rdp_recv_logon_info_v1(rdpRdp* rdp, wStream* s, logon_info* info)
1175{
1176 UINT32 cbDomain = 0;
1177 UINT32 cbUserName = 0;
1178
1179 WINPR_UNUSED(rdp);
1180 WINPR_ASSERT(info);
1181
1182 if (!Stream_CheckAndLogRequiredLength(TAG, s, 576))
1183 return FALSE;
1184
1185 Stream_Read_UINT32(s, cbDomain); /* cbDomain (4 bytes) */
1186
1187 /* cbDomain is the size of the Unicode character data (including the mandatory
1188 * null terminator) in bytes present in the fixed-length (52 bytes) Domain field
1189 */
1190 if (!rdp_info_read_string("Domain", s, cbDomain, 52, TRUE, &info->domain))
1191 goto fail;
1192
1193 Stream_Read_UINT32(s, cbUserName); /* cbUserName (4 bytes) */
1194
1195 /* cbUserName is the size of the Unicode character data (including the mandatory
1196 * null terminator) in bytes present in the fixed-length (512 bytes) UserName field.
1197 */
1198 if (!rdp_info_read_string("UserName", s, cbUserName, 512, TRUE, &info->username))
1199 goto fail;
1200
1201 Stream_Read_UINT32(s, info->sessionId); /* SessionId (4 bytes) */
1202 WLog_DBG(TAG, "LogonInfoV1: SessionId: 0x%08" PRIX32 " UserName: [%s] Domain: [%s]",
1203 info->sessionId, info->username, info->domain);
1204 return TRUE;
1205fail:
1206 return FALSE;
1207}
1208
1209static BOOL rdp_recv_logon_info_v2(rdpRdp* rdp, wStream* s, logon_info* info)
1210{
1211 UINT16 Version = 0;
1212 UINT32 Size = 0;
1213 UINT32 cbDomain = 0;
1214 UINT32 cbUserName = 0;
1215
1216 WINPR_ASSERT(rdp);
1217 WINPR_ASSERT(s);
1218 WINPR_ASSERT(info);
1219
1220 WINPR_UNUSED(rdp);
1221
1222 if (!Stream_CheckAndLogRequiredLength(TAG, s, logonInfoV2TotalSize))
1223 return FALSE;
1224
1225 Stream_Read_UINT16(s, Version); /* Version (2 bytes) */
1226 if (Version != SAVE_SESSION_PDU_VERSION_ONE)
1227 {
1228 WLog_WARN(TAG, "LogonInfoV2::Version expected %d bytes, got %" PRIu16,
1229 SAVE_SESSION_PDU_VERSION_ONE, Version);
1230 return FALSE;
1231 }
1232
1233 Stream_Read_UINT32(s, Size); /* Size (4 bytes) */
1234
1235 /* [MS-RDPBCGR] 2.2.10.1.1.2 Logon Info Version 2 (TS_LOGON_INFO_VERSION_2)
1236 * should be logonInfoV2TotalSize
1237 * but even MS server 2019 sends logonInfoV2Size
1238 */
1239 if (Size != logonInfoV2TotalSize)
1240 {
1241 if (Size != logonInfoV2Size)
1242 {
1243 WLog_WARN(TAG, "LogonInfoV2::Size expected %" PRIu32 " bytes, got %" PRIu32,
1244 logonInfoV2TotalSize, Size);
1245 return FALSE;
1246 }
1247 }
1248
1249 Stream_Read_UINT32(s, info->sessionId); /* SessionId (4 bytes) */
1250 Stream_Read_UINT32(s, cbDomain); /* cbDomain (4 bytes) */
1251 Stream_Read_UINT32(s, cbUserName); /* cbUserName (4 bytes) */
1252 Stream_Seek(s, logonInfoV2ReservedSize); /* pad (558 bytes) */
1253
1254 /* cbDomain is the size in bytes of the Unicode character data in the Domain field.
1255 * The size of the mandatory null terminator is include in this value.
1256 * Note: Since MS-RDPBCGR 2.2.10.1.1.2 does not mention any size limits we assume
1257 * that the maximum value is 52 bytes, according to the fixed size of the
1258 * Domain field in the Logon Info Version 1 (TS_LOGON_INFO) structure.
1259 */
1260 if (!rdp_info_read_string("Domain", s, cbDomain, 52, FALSE, &info->domain))
1261 goto fail;
1262
1263 /* cbUserName is the size in bytes of the Unicode character data in the UserName field.
1264 * The size of the mandatory null terminator is include in this value.
1265 * Note: Since MS-RDPBCGR 2.2.10.1.1.2 does not mention any size limits we assume
1266 * that the maximum value is 512 bytes, according to the fixed size of the
1267 * Username field in the Logon Info Version 1 (TS_LOGON_INFO) structure.
1268 */
1269 if (!rdp_info_read_string("UserName", s, cbUserName, 512, FALSE, &info->username))
1270 goto fail;
1271
1272 /* We´ve seen undocumented padding with windows 11 here.
1273 * unless it has actual data in it ignore it.
1274 * if there is unexpected data, print a warning and dump the contents
1275 */
1276 {
1277 const size_t rem = Stream_GetRemainingLength(s);
1278 if (rem > 0)
1279 {
1280 BOOL warn = FALSE;
1281 const char* str = Stream_ConstPointer(s);
1282 for (size_t x = 0; x < rem; x++)
1283 {
1284 if (str[x] != '\0')
1285 warn = TRUE;
1286 }
1287 if (warn)
1288 {
1289 WLog_WARN(TAG, "unexpected padding of %" PRIuz " bytes, data not '\\0'", rem);
1290 winpr_HexDump(TAG, WLOG_TRACE, str, rem);
1291 }
1292
1293 if (!Stream_SafeSeek(s, rem))
1294 goto fail;
1295 }
1296 }
1297
1298 WLog_DBG(TAG, "LogonInfoV2: SessionId: 0x%08" PRIX32 " UserName: [%s] Domain: [%s]",
1299 info->sessionId, info->username, info->domain);
1300 return TRUE;
1301fail:
1302 return FALSE;
1303}
1304
1305static BOOL rdp_recv_logon_plain_notify(rdpRdp* rdp, wStream* s)
1306{
1307 WINPR_UNUSED(rdp);
1308 if (!Stream_CheckAndLogRequiredLength(TAG, s, 576))
1309 return FALSE;
1310
1311 Stream_Seek(s, 576); /* pad (576 bytes) */
1312 WLog_DBG(TAG, "LogonPlainNotify");
1313 return TRUE;
1314}
1315
1316static BOOL rdp_recv_logon_error_info(rdpRdp* rdp, wStream* s, logon_info_ex* info)
1317{
1318 freerdp* instance = nullptr;
1319 UINT32 errorNotificationType = 0;
1320 UINT32 errorNotificationData = 0;
1321
1322 WINPR_ASSERT(rdp);
1323 WINPR_ASSERT(rdp->context);
1324 WINPR_ASSERT(s);
1325 WINPR_ASSERT(info);
1326
1327 instance = rdp->context->instance;
1328 WINPR_ASSERT(instance);
1329
1330 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
1331 return FALSE;
1332
1333 Stream_Read_UINT32(s, errorNotificationType); /* errorNotificationType (4 bytes) */
1334 Stream_Read_UINT32(s, errorNotificationData); /* errorNotificationData (4 bytes) */
1335 WLog_DBG(TAG, "LogonErrorInfo: Data: 0x%08" PRIX32 " Type: 0x%08" PRIX32 "",
1336 errorNotificationData, errorNotificationType);
1337 if (instance->LogonErrorInfo)
1338 {
1339 const int rc =
1340 instance->LogonErrorInfo(instance, errorNotificationData, errorNotificationType);
1341 if (rc < 0)
1342 return FALSE;
1343 }
1344 info->ErrorNotificationType = errorNotificationType;
1345 info->ErrorNotificationData = errorNotificationData;
1346 return TRUE;
1347}
1348
1349static BOOL rdp_recv_logon_info_extended(rdpRdp* rdp, wStream* s, logon_info_ex* info)
1350{
1351 UINT32 cbFieldData = 0;
1352 UINT32 fieldsPresent = 0;
1353 UINT16 Length = 0;
1354
1355 WINPR_ASSERT(rdp);
1356 WINPR_ASSERT(s);
1357 WINPR_ASSERT(info);
1358
1359 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
1360 {
1361 WLog_WARN(TAG, "received short logon info extended, need 6 bytes, got %" PRIuz,
1362 Stream_GetRemainingLength(s));
1363 return FALSE;
1364 }
1365
1366 Stream_Read_UINT16(s, Length); /* Length (2 bytes) */
1367 Stream_Read_UINT32(s, fieldsPresent); /* fieldsPresent (4 bytes) */
1368
1369 if ((Length < 6) || (!Stream_CheckAndLogRequiredLength(TAG, s, (Length - 6U))))
1370 {
1371 WLog_WARN(TAG,
1372 "received short logon info extended, need %" PRIu16 " - 6 bytes, got %" PRIuz,
1373 Length, Stream_GetRemainingLength(s));
1374 return FALSE;
1375 }
1376
1377 WLog_DBG(TAG, "LogonInfoExtended: fieldsPresent: 0x%08" PRIX32 "", fieldsPresent);
1378
1379 /* logonFields */
1380
1381 if (fieldsPresent & LOGON_EX_AUTORECONNECTCOOKIE)
1382 {
1383 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
1384 return FALSE;
1385
1386 info->haveCookie = TRUE;
1387 Stream_Read_UINT32(s, cbFieldData); /* cbFieldData (4 bytes) */
1388
1389 if (!Stream_CheckAndLogRequiredLength(TAG, s, cbFieldData))
1390 return FALSE;
1391
1392 if (!rdp_read_server_auto_reconnect_cookie(rdp, s, info))
1393 return FALSE;
1394 }
1395
1396 if (fieldsPresent & LOGON_EX_LOGONERRORS)
1397 {
1398 info->haveErrorInfo = TRUE;
1399
1400 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
1401 return FALSE;
1402
1403 Stream_Read_UINT32(s, cbFieldData); /* cbFieldData (4 bytes) */
1404
1405 if (!Stream_CheckAndLogRequiredLength(TAG, s, cbFieldData))
1406 return FALSE;
1407
1408 if (!rdp_recv_logon_error_info(rdp, s, info))
1409 return FALSE;
1410 }
1411
1412 if (!Stream_CheckAndLogRequiredLength(TAG, s, 570))
1413 return FALSE;
1414
1415 Stream_Seek(s, 570); /* pad (570 bytes) */
1416 return TRUE;
1417}
1418
1419BOOL rdp_recv_save_session_info(rdpRdp* rdp, wStream* s)
1420{
1421 UINT32 infoType = 0;
1422 BOOL status = FALSE;
1423
1424 rdpContext* context = rdp->context;
1425 rdpUpdate* update = rdp->context->update;
1426
1427 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
1428 return FALSE;
1429
1430 Stream_Read_UINT32(s, infoType); /* infoType (4 bytes) */
1431
1432 switch (infoType)
1433 {
1434 case INFO_TYPE_LOGON:
1435 {
1436 logon_info logonInfo = WINPR_C_ARRAY_INIT;
1437 status = rdp_recv_logon_info_v1(rdp, s, &logonInfo);
1438
1439 if (status && update->SaveSessionInfo)
1440 status = update->SaveSessionInfo(context, infoType, &logonInfo);
1441
1442 rdp_free_logon_info(&logonInfo);
1443 }
1444 break;
1445
1446 case INFO_TYPE_LOGON_LONG:
1447 {
1448 logon_info logonInfo = WINPR_C_ARRAY_INIT;
1449 status = rdp_recv_logon_info_v2(rdp, s, &logonInfo);
1450
1451 if (status && update->SaveSessionInfo)
1452 status = update->SaveSessionInfo(context, infoType, &logonInfo);
1453
1454 rdp_free_logon_info(&logonInfo);
1455 }
1456 break;
1457
1458 case INFO_TYPE_LOGON_PLAIN_NOTIFY:
1459 status = rdp_recv_logon_plain_notify(rdp, s);
1460
1461 if (status && update->SaveSessionInfo)
1462 status = update->SaveSessionInfo(context, infoType, nullptr);
1463
1464 break;
1465
1466 case INFO_TYPE_LOGON_EXTENDED_INF:
1467 {
1468 logon_info_ex logonInfoEx = WINPR_C_ARRAY_INIT;
1469 status = rdp_recv_logon_info_extended(rdp, s, &logonInfoEx);
1470
1471 if (status && update->SaveSessionInfo)
1472 status = update->SaveSessionInfo(context, infoType, &logonInfoEx);
1473 }
1474 break;
1475
1476 default:
1477 WLog_WARN(TAG, "Unhandled saveSessionInfo type 0x%" PRIx32 "", infoType);
1478 status = TRUE;
1479 break;
1480 }
1481
1482 if (!status)
1483 {
1484 WLog_WARN(TAG, "SaveSessionInfo error: infoType: %s (%" PRIu32 ")",
1485 freerdp_session_logon_type_str(infoType), infoType);
1486 }
1487
1488 return status;
1489}
1490
1491static BOOL rdp_write_logon_info_v1(wStream* s, const logon_info* info)
1492{
1493 const size_t charLen = 52 / sizeof(WCHAR);
1494 const size_t userCharLen = 512 / sizeof(WCHAR);
1495
1496 size_t sz = 4 + 52 + 4 + 512 + 4;
1497
1498 if (!Stream_EnsureRemainingCapacity(s, sz))
1499 return FALSE;
1500
1501 /* domain */
1502 {
1503 WINPR_ASSERT(info);
1504 if (!info->domain || !info->username)
1505 return FALSE;
1506 const size_t len = strnlen(info->domain, charLen + 1);
1507 if (len > charLen)
1508 return FALSE;
1509
1510 const SSIZE_T wclen = ConvertUtf8NToWChar(info->domain, len, nullptr, 0);
1511 if (wclen < 0)
1512 return FALSE;
1513 const size_t wzerolen = WINPR_ASSERTING_INT_CAST(size_t, wclen) + 1ull;
1514 const size_t wlen = wzerolen * sizeof(WCHAR);
1515 if (wlen > UINT32_MAX)
1516 return FALSE;
1517
1518 Stream_Write_UINT32(s, (UINT32)wlen);
1519 if (Stream_Write_UTF16_String_From_UTF8(s, wzerolen, info->domain, len, TRUE) < 0)
1520 return FALSE;
1521 }
1522
1523 /* username */
1524 {
1525 const size_t len = strnlen(info->username, userCharLen + 1);
1526 if (len > userCharLen)
1527 return FALSE;
1528
1529 const SSIZE_T wclen = ConvertUtf8NToWChar(info->username, len, nullptr, 0);
1530 if (wclen < 0)
1531 return FALSE;
1532 const size_t wzerolen = WINPR_ASSERTING_INT_CAST(size_t, wclen) + 1ull;
1533 const size_t wlen = wzerolen * sizeof(WCHAR);
1534 if (wlen > UINT32_MAX)
1535 return FALSE;
1536
1537 Stream_Write_UINT32(s, (UINT32)wlen);
1538
1539 if (Stream_Write_UTF16_String_From_UTF8(s, wzerolen, info->username, len, TRUE) < 0)
1540 return FALSE;
1541 }
1542
1543 /* sessionId */
1544 Stream_Write_UINT32(s, info->sessionId);
1545 return TRUE;
1546}
1547
1548static BOOL rdp_write_logon_info_v2(wStream* s, const logon_info* info)
1549{
1550 size_t domainLen = 0;
1551 size_t usernameLen = 0;
1552 size_t domainStrLen = 0;
1553 size_t usernameStrLen = 0;
1554
1555 if (!Stream_EnsureRemainingCapacity(s, logonInfoV2TotalSize))
1556 return FALSE;
1557
1558 Stream_Write_UINT16(s, SAVE_SESSION_PDU_VERSION_ONE);
1559 /* [MS-RDPBCGR] 2.2.10.1.1.2 Logon Info Version 2 (TS_LOGON_INFO_VERSION_2)
1560 * should be logonInfoV2TotalSize
1561 * but even MS server 2019 sends logonInfoV2Size
1562 */
1563 Stream_Write_UINT32(s, logonInfoV2Size);
1564 Stream_Write_UINT32(s, info->sessionId);
1565 if (info->domain)
1566 {
1567 domainStrLen = strnlen(info->domain, 256); /* lmcons.h UNLEN */
1568 const SSIZE_T wlen = ConvertUtf8NToWChar(info->domain, domainStrLen, nullptr, 0);
1569 if (wlen < 0)
1570 return FALSE;
1571 domainLen = WINPR_ASSERTING_INT_CAST(size_t, wlen);
1572 }
1573 if (domainLen >= (UINT32_MAX - 1) / sizeof(WCHAR))
1574 return FALSE;
1575 Stream_Write_UINT32(s, (UINT32)(domainLen + 1) * sizeof(WCHAR));
1576
1577 if (info->username)
1578 {
1579 usernameStrLen = strnlen(info->username, 256); /* lmcons.h UNLEN */
1580 const SSIZE_T wlen = ConvertUtf8NToWChar(info->username, usernameStrLen, nullptr, 0);
1581 if (wlen < 0)
1582 return FALSE;
1583 usernameLen = WINPR_ASSERTING_INT_CAST(size_t, wlen);
1584 }
1585 if (usernameLen >= (UINT32_MAX - 1) / sizeof(WCHAR))
1586 return FALSE;
1587 Stream_Write_UINT32(s, (UINT32)(usernameLen + 1) * sizeof(WCHAR));
1588 Stream_Seek(s, logonInfoV2ReservedSize);
1589 if (Stream_Write_UTF16_String_From_UTF8(s, domainLen + 1, info->domain, domainStrLen, TRUE) < 0)
1590 return FALSE;
1591 if (Stream_Write_UTF16_String_From_UTF8(s, usernameLen + 1, info->username, usernameStrLen,
1592 TRUE) < 0)
1593 return FALSE;
1594 return TRUE;
1595}
1596
1597static BOOL rdp_write_logon_info_plain(wStream* s)
1598{
1599 if (!Stream_EnsureRemainingCapacity(s, 576))
1600 return FALSE;
1601
1602 Stream_Zero(s, 576);
1603 return TRUE;
1604}
1605
1606static BOOL rdp_write_logon_info_ex(wStream* s, const logon_info_ex* info)
1607{
1608 UINT32 FieldsPresent = 0;
1609 UINT16 Size = 2 + 4 + 570;
1610
1611 if (info->haveCookie)
1612 {
1613 FieldsPresent |= LOGON_EX_AUTORECONNECTCOOKIE;
1614 Size += 28;
1615 }
1616
1617 if (info->haveErrorInfo)
1618 {
1619 FieldsPresent |= LOGON_EX_LOGONERRORS;
1620 Size += 8;
1621 }
1622
1623 if (!Stream_EnsureRemainingCapacity(s, Size))
1624 return FALSE;
1625
1626 Stream_Write_UINT16(s, Size);
1627 Stream_Write_UINT32(s, FieldsPresent);
1628
1629 if (info->haveCookie)
1630 {
1631 Stream_Write_UINT32(s, 28); /* cbFieldData (4 bytes) */
1632 Stream_Write_UINT32(s, 28); /* cbLen (4 bytes) */
1633 Stream_Write_UINT32(s, AUTO_RECONNECT_VERSION_1); /* Version (4 bytes) */
1634 Stream_Write_UINT32(s, info->LogonId); /* LogonId (4 bytes) */
1635 Stream_Write(s, info->ArcRandomBits, 16); /* ArcRandomBits (16 bytes) */
1636 }
1637
1638 if (info->haveErrorInfo)
1639 {
1640 Stream_Write_UINT32(s, 8); /* cbFieldData (4 bytes) */
1641 Stream_Write_UINT32(s, info->ErrorNotificationType); /* ErrorNotificationType (4 bytes) */
1642 Stream_Write_UINT32(s, info->ErrorNotificationData); /* ErrorNotificationData (4 bytes) */
1643 }
1644
1645 Stream_Seek(s, 570);
1646 return TRUE;
1647}
1648
1649BOOL rdp_send_save_session_info(rdpContext* context, UINT32 type, const void* data)
1650{
1651 UINT16 sec_flags = 0;
1652 BOOL status = 0;
1653
1654 WINPR_ASSERT(context);
1655 rdpRdp* rdp = context->rdp;
1656 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
1657
1658 if (!s)
1659 return FALSE;
1660
1661 Stream_Write_UINT32(s, type);
1662
1663 switch (type)
1664 {
1665 case INFO_TYPE_LOGON:
1666 status = rdp_write_logon_info_v1(s, (const logon_info*)data);
1667 break;
1668
1669 case INFO_TYPE_LOGON_LONG:
1670 status = rdp_write_logon_info_v2(s, (const logon_info*)data);
1671 break;
1672
1673 case INFO_TYPE_LOGON_PLAIN_NOTIFY:
1674 status = rdp_write_logon_info_plain(s);
1675 break;
1676
1677 case INFO_TYPE_LOGON_EXTENDED_INF:
1678 status = rdp_write_logon_info_ex(s, (const logon_info_ex*)data);
1679 break;
1680
1681 default:
1682 WLog_ERR(TAG, "saveSessionInfo type 0x%" PRIx32 " not handled", type);
1683 status = FALSE;
1684 break;
1685 }
1686
1687 if (status)
1688 status =
1689 rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SAVE_SESSION_INFO, rdp->mcs->userId, sec_flags);
1690 else
1691 Stream_Release(s);
1692
1693 return status;
1694}
1695
1696BOOL rdp_send_server_status_info(rdpContext* context, UINT32 status)
1697{
1698 UINT16 sec_flags = 0;
1699 wStream* s = nullptr;
1700 rdpRdp* rdp = context->rdp;
1701 s = rdp_data_pdu_init(rdp, &sec_flags);
1702
1703 if (!s)
1704 return FALSE;
1705
1706 Stream_Write_UINT32(s, status);
1707 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_STATUS_INFO, rdp->mcs->userId, sec_flags);
1708}
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:3799
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:3805
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