2018 lines
63 KiB
C
2018 lines
63 KiB
C
/**
|
||
* FreeRDP: A Remote Desktop Protocol Implementation
|
||
* FreeRDP Proxy Server
|
||
*
|
||
* Copyright 2021 Armin Novak <armin.novak@thincast.com>
|
||
* Copyright 2021 Thincast Technologies GmbH
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
|
||
#include <freerdp/config.h>
|
||
|
||
#include <winpr/assert.h>
|
||
#include <winpr/string.h>
|
||
#include <winpr/print.h>
|
||
|
||
#include "pf_channel_rdpdr.h"
|
||
#include "pf_channel_smartcard.h"
|
||
|
||
#include <freerdp/server/proxy/proxy_log.h>
|
||
#include <freerdp/channels/rdpdr.h>
|
||
#include <freerdp/channels/channels.h>
|
||
#include <freerdp/utils/rdpdr_utils.h>
|
||
|
||
#define RTAG PROXY_TAG("channel.rdpdr")
|
||
|
||
#define SCARD_DEVICE_ID UINT32_MAX
|
||
|
||
typedef struct
|
||
{
|
||
InterceptContextMapEntry base;
|
||
wStream* s;
|
||
wStream* buffer;
|
||
UINT16 versionMajor;
|
||
UINT16 versionMinor;
|
||
UINT32 clientID;
|
||
UINT32 computerNameLen;
|
||
BOOL computerNameUnicode;
|
||
union
|
||
{
|
||
WCHAR* wc;
|
||
char* c;
|
||
void* v;
|
||
} computerName;
|
||
UINT32 SpecialDeviceCount;
|
||
UINT32 capabilityVersions[6];
|
||
} pf_channel_common_context;
|
||
|
||
typedef enum
|
||
{
|
||
STATE_CLIENT_EXPECT_SERVER_ANNOUNCE_REQUEST = 0x01,
|
||
STATE_CLIENT_EXPECT_SERVER_CORE_CAPABILITY_REQUEST = 0x02,
|
||
STATE_CLIENT_EXPECT_SERVER_CLIENT_ID_CONFIRM = 0x04,
|
||
STATE_CLIENT_CHANNEL_RUNNING = 0x10
|
||
} pf_channel_client_state;
|
||
|
||
typedef struct
|
||
{
|
||
pf_channel_common_context common;
|
||
pf_channel_client_state state;
|
||
UINT32 flags;
|
||
UINT16 maxMajorVersion;
|
||
UINT16 maxMinorVersion;
|
||
wQueue* queue;
|
||
wLog* log;
|
||
} pf_channel_client_context;
|
||
|
||
typedef enum
|
||
{
|
||
STATE_SERVER_INITIAL,
|
||
STATE_SERVER_EXPECT_CLIENT_ANNOUNCE_REPLY,
|
||
STATE_SERVER_EXPECT_CLIENT_NAME_REQUEST,
|
||
STATE_SERVER_EXPECT_EXPECT_CLIENT_CAPABILITY_RESPONE,
|
||
STATE_SERVER_CHANNEL_RUNNING
|
||
} pf_channel_server_state;
|
||
|
||
typedef struct
|
||
{
|
||
pf_channel_common_context common;
|
||
pf_channel_server_state state;
|
||
DWORD SessionId;
|
||
HANDLE handle;
|
||
wArrayList* blockedDevices;
|
||
wLog* log;
|
||
} pf_channel_server_context;
|
||
|
||
#define proxy_client "[proxy<-->client]"
|
||
#define proxy_server "[proxy<-->server]"
|
||
|
||
#define proxy_client_rx proxy_client " receive"
|
||
#define proxy_client_tx proxy_client " send"
|
||
#define proxy_server_rx proxy_server " receive"
|
||
#define proxy_server_tx proxy_server " send"
|
||
|
||
#define SERVER_RX_LOG(log, lvl, fmt, ...) WLog_Print(log, lvl, proxy_client_rx fmt, ##__VA_ARGS__)
|
||
#define CLIENT_RX_LOG(log, lvl, fmt, ...) WLog_Print(log, lvl, proxy_server_rx fmt, ##__VA_ARGS__)
|
||
#define SERVER_TX_LOG(log, lvl, fmt, ...) WLog_Print(log, lvl, proxy_client_tx fmt, ##__VA_ARGS__)
|
||
#define CLIENT_TX_LOG(log, lvl, fmt, ...) WLog_Print(log, lvl, proxy_server_tx fmt, ##__VA_ARGS__)
|
||
#define RX_LOG(srv, lvl, fmt, ...) \
|
||
do \
|
||
{ \
|
||
if (srv) \
|
||
{ \
|
||
SERVER_RX_LOG(lvl, fmt, ##__VA_ARGS__); \
|
||
} \
|
||
else \
|
||
{ \
|
||
CLIENT_RX_LOG(lvl, fmt, ##__VA_ARGS__); \
|
||
} \
|
||
} while (0)
|
||
|
||
#define SERVER_RXTX_LOG(send, log, lvl, fmt, ...) \
|
||
do \
|
||
{ \
|
||
if (send) \
|
||
{ \
|
||
SERVER_TX_LOG(log, lvl, fmt, ##__VA_ARGS__); \
|
||
} \
|
||
else \
|
||
{ \
|
||
SERVER_RX_LOG(log, lvl, fmt, ##__VA_ARGS__); \
|
||
} \
|
||
} while (0)
|
||
|
||
#define Stream_CheckAndLogRequiredLengthSrv(log, s, len) \
|
||
Stream_CheckAndLogRequiredLengthWLogEx(log, WLOG_WARN, s, len, 1, \
|
||
proxy_client_rx " %s(%s:%" PRIuz ")", __func__, \
|
||
__FILE__, (size_t)__LINE__)
|
||
#define Stream_CheckAndLogRequiredLengthClient(log, s, len) \
|
||
Stream_CheckAndLogRequiredLengthWLogEx(log, WLOG_WARN, s, len, 1, \
|
||
proxy_server_rx " %s(%s:%" PRIuz ")", __func__, \
|
||
__FILE__, (size_t)__LINE__)
|
||
#define Stream_CheckAndLogRequiredLengthRx(srv, log, s, len) \
|
||
Stream_CheckAndLogRequiredLengthRx_(srv, log, s, len, 1, __func__, __FILE__, __LINE__)
|
||
static BOOL Stream_CheckAndLogRequiredLengthRx_(BOOL srv, wLog* log, wStream* s, size_t nmemb,
|
||
size_t size, const char* fkt, const char* file,
|
||
size_t line)
|
||
{
|
||
const char* fmt =
|
||
srv ? proxy_server_rx " %s(%s:%" PRIuz ")" : proxy_client_rx " %s(%s:%" PRIuz ")";
|
||
|
||
return Stream_CheckAndLogRequiredLengthWLogEx(log, WLOG_WARN, s, nmemb, size, fmt, fkt, file,
|
||
line);
|
||
}
|
||
|
||
static const char* rdpdr_server_state_to_string(pf_channel_server_state state)
|
||
{
|
||
switch (state)
|
||
{
|
||
case STATE_SERVER_INITIAL:
|
||
return "STATE_SERVER_INITIAL";
|
||
case STATE_SERVER_EXPECT_CLIENT_ANNOUNCE_REPLY:
|
||
return "STATE_SERVER_EXPECT_CLIENT_ANNOUNCE_REPLY";
|
||
case STATE_SERVER_EXPECT_CLIENT_NAME_REQUEST:
|
||
return "STATE_SERVER_EXPECT_CLIENT_NAME_REQUEST";
|
||
case STATE_SERVER_EXPECT_EXPECT_CLIENT_CAPABILITY_RESPONE:
|
||
return "STATE_SERVER_EXPECT_EXPECT_CLIENT_CAPABILITY_RESPONE";
|
||
case STATE_SERVER_CHANNEL_RUNNING:
|
||
return "STATE_SERVER_CHANNEL_RUNNING";
|
||
default:
|
||
return "STATE_SERVER_UNKNOWN";
|
||
}
|
||
}
|
||
|
||
static const char* rdpdr_client_state_to_string(pf_channel_client_state state)
|
||
{
|
||
switch (state)
|
||
{
|
||
case STATE_CLIENT_EXPECT_SERVER_ANNOUNCE_REQUEST:
|
||
return "STATE_CLIENT_EXPECT_SERVER_ANNOUNCE_REQUEST";
|
||
case STATE_CLIENT_EXPECT_SERVER_CORE_CAPABILITY_REQUEST:
|
||
return "STATE_CLIENT_EXPECT_SERVER_CORE_CAPABILITY_REQUEST";
|
||
case STATE_CLIENT_EXPECT_SERVER_CLIENT_ID_CONFIRM:
|
||
return "STATE_CLIENT_EXPECT_SERVER_CLIENT_ID_CONFIRM";
|
||
case STATE_CLIENT_CHANNEL_RUNNING:
|
||
return "STATE_CLIENT_CHANNEL_RUNNING";
|
||
default:
|
||
return "STATE_CLIENT_UNKNOWN";
|
||
}
|
||
}
|
||
|
||
static wStream* rdpdr_get_send_buffer(pf_channel_common_context* rdpdr, UINT16 component,
|
||
UINT16 PacketID, size_t capacity)
|
||
{
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(rdpdr->s);
|
||
if (!Stream_SetPosition(rdpdr->s, 0))
|
||
return NULL;
|
||
if (!Stream_EnsureCapacity(rdpdr->s, capacity + 4))
|
||
return NULL;
|
||
Stream_Write_UINT16(rdpdr->s, component);
|
||
Stream_Write_UINT16(rdpdr->s, PacketID);
|
||
return rdpdr->s;
|
||
}
|
||
|
||
static wStream* rdpdr_client_get_send_buffer(pf_channel_client_context* rdpdr, UINT16 component,
|
||
UINT16 PacketID, size_t capacity)
|
||
{
|
||
WINPR_ASSERT(rdpdr);
|
||
return rdpdr_get_send_buffer(&rdpdr->common, component, PacketID, capacity);
|
||
}
|
||
|
||
static wStream* rdpdr_server_get_send_buffer(pf_channel_server_context* rdpdr, UINT16 component,
|
||
UINT16 PacketID, size_t capacity)
|
||
{
|
||
WINPR_ASSERT(rdpdr);
|
||
return rdpdr_get_send_buffer(&rdpdr->common, component, PacketID, capacity);
|
||
}
|
||
|
||
static UINT rdpdr_client_send(wLog* log, pClientContext* pc, wStream* s)
|
||
{
|
||
UINT16 channelId = 0;
|
||
|
||
WINPR_ASSERT(log);
|
||
WINPR_ASSERT(pc);
|
||
WINPR_ASSERT(s);
|
||
WINPR_ASSERT(pc->context.instance);
|
||
|
||
if (!pc->connected)
|
||
{
|
||
CLIENT_TX_LOG(log, WLOG_WARN, "Ignoring channel %s message, not connected!",
|
||
RDPDR_SVC_CHANNEL_NAME);
|
||
return CHANNEL_RC_OK;
|
||
}
|
||
|
||
channelId = freerdp_channels_get_id_by_name(pc->context.instance, RDPDR_SVC_CHANNEL_NAME);
|
||
/* Ignore unmappable channels. Might happen when the channel was already down and
|
||
* some delayed message is tried to be sent. */
|
||
if ((channelId == 0) || (channelId == UINT16_MAX))
|
||
return ERROR_INTERNAL_ERROR;
|
||
|
||
Stream_SealLength(s);
|
||
rdpdr_dump_send_packet(log, WLOG_TRACE, s, proxy_server_tx);
|
||
WINPR_ASSERT(pc->context.instance->SendChannelData);
|
||
if (!pc->context.instance->SendChannelData(pc->context.instance, channelId, Stream_Buffer(s),
|
||
Stream_Length(s)))
|
||
return ERROR_EVT_CHANNEL_NOT_FOUND;
|
||
return CHANNEL_RC_OK;
|
||
}
|
||
|
||
static UINT rdpdr_seal_send_free_request(pf_channel_server_context* context, wStream* s)
|
||
{
|
||
BOOL status = 0;
|
||
size_t len = 0;
|
||
|
||
WINPR_ASSERT(context);
|
||
WINPR_ASSERT(context->handle);
|
||
WINPR_ASSERT(s);
|
||
|
||
Stream_SealLength(s);
|
||
len = Stream_Length(s);
|
||
WINPR_ASSERT(len <= UINT32_MAX);
|
||
|
||
rdpdr_dump_send_packet(context->log, WLOG_TRACE, s, proxy_client_tx);
|
||
status = WTSVirtualChannelWrite(context->handle, (char*)Stream_Buffer(s), (ULONG)len, NULL);
|
||
return (status) ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR;
|
||
}
|
||
|
||
static BOOL rdpdr_process_server_header(BOOL server, wLog* log, wStream* s, UINT16 component,
|
||
UINT16 PacketId, size_t expect)
|
||
{
|
||
UINT16 rpacketid = 0;
|
||
UINT16 rcomponent = 0;
|
||
|
||
WINPR_ASSERT(s);
|
||
if (!Stream_CheckAndLogRequiredLengthRx(server, log, s, 4))
|
||
{
|
||
RX_LOG(server, log, WLOG_WARN, "RDPDR_HEADER[%s | %s]: expected length 4, got %" PRIuz,
|
||
rdpdr_component_string(component), rdpdr_packetid_string(PacketId),
|
||
Stream_GetRemainingLength(s));
|
||
return FALSE;
|
||
}
|
||
|
||
Stream_Read_UINT16(s, rcomponent);
|
||
Stream_Read_UINT16(s, rpacketid);
|
||
|
||
if (rcomponent != component)
|
||
{
|
||
RX_LOG(server, log, WLOG_WARN, "RDPDR_HEADER[%s | %s]: got component %s",
|
||
rdpdr_component_string(component), rdpdr_packetid_string(PacketId),
|
||
rdpdr_component_string(rcomponent));
|
||
return FALSE;
|
||
}
|
||
|
||
if (rpacketid != PacketId)
|
||
{
|
||
RX_LOG(server, log, WLOG_WARN, "RDPDR_HEADER[%s | %s]: got PacketID %s",
|
||
rdpdr_component_string(component), rdpdr_packetid_string(PacketId),
|
||
rdpdr_packetid_string(rpacketid));
|
||
return FALSE;
|
||
}
|
||
|
||
if (!Stream_CheckAndLogRequiredLengthRx(server, log, s, expect))
|
||
{
|
||
RX_LOG(server, log, WLOG_WARN,
|
||
"RDPDR_HEADER[%s | %s] not enought data, expected %" PRIuz ", "
|
||
"got %" PRIuz,
|
||
rdpdr_component_string(component), rdpdr_packetid_string(PacketId), expect,
|
||
Stream_GetRemainingLength(s));
|
||
return ERROR_INVALID_DATA;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
static BOOL rdpdr_check_version(BOOL server, wLog* log, UINT16 versionMajor, UINT16 versionMinor,
|
||
UINT16 component, UINT16 PacketId)
|
||
{
|
||
if (versionMajor != RDPDR_VERSION_MAJOR)
|
||
{
|
||
RX_LOG(server, log, WLOG_WARN, "[%s | %s] expected MajorVersion %" PRIu16 ", got %" PRIu16,
|
||
rdpdr_component_string(component), rdpdr_packetid_string(PacketId),
|
||
RDPDR_VERSION_MAJOR, versionMajor);
|
||
return FALSE;
|
||
}
|
||
switch (versionMinor)
|
||
{
|
||
case RDPDR_VERSION_MINOR_RDP50:
|
||
case RDPDR_VERSION_MINOR_RDP51:
|
||
case RDPDR_VERSION_MINOR_RDP52:
|
||
case RDPDR_VERSION_MINOR_RDP6X:
|
||
case RDPDR_VERSION_MINOR_RDP10X:
|
||
break;
|
||
default:
|
||
{
|
||
RX_LOG(server, log, WLOG_WARN, "[%s | %s] unsupported MinorVersion %" PRIu16,
|
||
rdpdr_component_string(component), rdpdr_packetid_string(PacketId),
|
||
versionMinor);
|
||
return FALSE;
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
static UINT rdpdr_process_server_announce_request(pf_channel_client_context* rdpdr, wStream* s)
|
||
{
|
||
const UINT16 component = RDPDR_CTYP_CORE;
|
||
const UINT16 packetid = PAKID_CORE_SERVER_ANNOUNCE;
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
|
||
if (!rdpdr_process_server_header(FALSE, rdpdr->log, s, component, packetid, 8))
|
||
return ERROR_INVALID_DATA;
|
||
|
||
Stream_Read_UINT16(s, rdpdr->common.versionMajor);
|
||
Stream_Read_UINT16(s, rdpdr->common.versionMinor);
|
||
|
||
if (!rdpdr_check_version(FALSE, rdpdr->log, rdpdr->common.versionMajor,
|
||
rdpdr->common.versionMinor, component, packetid))
|
||
return ERROR_INVALID_DATA;
|
||
|
||
/* Limit maximum channel protocol version to the one set by proxy server */
|
||
if (rdpdr->common.versionMajor > rdpdr->maxMajorVersion)
|
||
{
|
||
rdpdr->common.versionMajor = rdpdr->maxMajorVersion;
|
||
rdpdr->common.versionMinor = rdpdr->maxMinorVersion;
|
||
}
|
||
else if (rdpdr->common.versionMinor > rdpdr->maxMinorVersion)
|
||
rdpdr->common.versionMinor = rdpdr->maxMinorVersion;
|
||
|
||
Stream_Read_UINT32(s, rdpdr->common.clientID);
|
||
return CHANNEL_RC_OK;
|
||
}
|
||
|
||
static UINT rdpdr_server_send_announce_request(pf_channel_server_context* context)
|
||
{
|
||
wStream* s =
|
||
rdpdr_server_get_send_buffer(context, RDPDR_CTYP_CORE, PAKID_CORE_SERVER_ANNOUNCE, 8);
|
||
if (!s)
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
|
||
Stream_Write_UINT16(s, context->common.versionMajor); /* VersionMajor (2 bytes) */
|
||
Stream_Write_UINT16(s, context->common.versionMinor); /* VersionMinor (2 bytes) */
|
||
Stream_Write_UINT32(s, context->common.clientID); /* ClientId (4 bytes) */
|
||
return rdpdr_seal_send_free_request(context, s);
|
||
}
|
||
|
||
static UINT rdpdr_process_client_announce_reply(pf_channel_server_context* rdpdr, wStream* s)
|
||
{
|
||
const UINT16 component = RDPDR_CTYP_CORE;
|
||
const UINT16 packetid = PAKID_CORE_CLIENTID_CONFIRM;
|
||
UINT16 versionMajor = 0;
|
||
UINT16 versionMinor = 0;
|
||
UINT32 clientID = 0;
|
||
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
|
||
if (!rdpdr_process_server_header(TRUE, rdpdr->log, s, component, packetid, 8))
|
||
return ERROR_INVALID_DATA;
|
||
|
||
Stream_Read_UINT16(s, versionMajor);
|
||
Stream_Read_UINT16(s, versionMinor);
|
||
|
||
if (!rdpdr_check_version(TRUE, rdpdr->log, versionMajor, versionMinor, component, packetid))
|
||
return ERROR_INVALID_DATA;
|
||
|
||
if ((rdpdr->common.versionMajor != versionMajor) ||
|
||
(rdpdr->common.versionMinor != versionMinor))
|
||
{
|
||
SERVER_RX_LOG(
|
||
rdpdr->log, WLOG_WARN,
|
||
"[%s | %s] downgrading version from %" PRIu16 ".%" PRIu16 " to %" PRIu16 ".%" PRIu16,
|
||
rdpdr_component_string(component), rdpdr_packetid_string(packetid),
|
||
rdpdr->common.versionMajor, rdpdr->common.versionMinor, versionMajor, versionMinor);
|
||
rdpdr->common.versionMajor = versionMajor;
|
||
rdpdr->common.versionMinor = versionMinor;
|
||
}
|
||
Stream_Read_UINT32(s, clientID);
|
||
if (rdpdr->common.clientID != clientID)
|
||
{
|
||
SERVER_RX_LOG(rdpdr->log, WLOG_WARN,
|
||
"[%s | %s] changing clientID 0x%08" PRIu32 " to 0x%08" PRIu32,
|
||
rdpdr_component_string(component), rdpdr_packetid_string(packetid),
|
||
rdpdr->common.clientID, clientID);
|
||
rdpdr->common.clientID = clientID;
|
||
}
|
||
|
||
return CHANNEL_RC_OK;
|
||
}
|
||
|
||
static UINT rdpdr_send_client_announce_reply(pClientContext* pc, pf_channel_client_context* rdpdr)
|
||
{
|
||
wStream* s =
|
||
rdpdr_client_get_send_buffer(rdpdr, RDPDR_CTYP_CORE, PAKID_CORE_CLIENTID_CONFIRM, 8);
|
||
if (!s)
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
|
||
Stream_Write_UINT16(s, rdpdr->common.versionMajor);
|
||
Stream_Write_UINT16(s, rdpdr->common.versionMinor);
|
||
Stream_Write_UINT32(s, rdpdr->common.clientID);
|
||
return rdpdr_client_send(rdpdr->log, pc, s);
|
||
}
|
||
|
||
static UINT rdpdr_process_client_name_request(pf_channel_server_context* rdpdr, wStream* s,
|
||
pClientContext* pc)
|
||
{
|
||
UINT32 unicodeFlag = 0;
|
||
UINT32 codePage = 0;
|
||
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
WINPR_ASSERT(pc);
|
||
|
||
if (!rdpdr_process_server_header(TRUE, rdpdr->log, s, RDPDR_CTYP_CORE, PAKID_CORE_CLIENT_NAME,
|
||
12))
|
||
return ERROR_INVALID_DATA;
|
||
|
||
Stream_Read_UINT32(s, unicodeFlag);
|
||
rdpdr->common.computerNameUnicode = (unicodeFlag & 1);
|
||
|
||
Stream_Read_UINT32(s, codePage);
|
||
WINPR_UNUSED(codePage); /* Field is ignored */
|
||
Stream_Read_UINT32(s, rdpdr->common.computerNameLen);
|
||
if (!Stream_CheckAndLogRequiredLengthSrv(rdpdr->log, s, rdpdr->common.computerNameLen))
|
||
{
|
||
SERVER_RX_LOG(
|
||
rdpdr->log, WLOG_WARN, "[%s | %s]: missing data, got %" PRIu32 ", expected %" PRIu32,
|
||
rdpdr_component_string(RDPDR_CTYP_CORE), rdpdr_packetid_string(PAKID_CORE_CLIENT_NAME),
|
||
Stream_GetRemainingLength(s), rdpdr->common.computerNameLen);
|
||
return ERROR_INVALID_DATA;
|
||
}
|
||
void* tmp = realloc(rdpdr->common.computerName.v, rdpdr->common.computerNameLen);
|
||
if (!tmp)
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
rdpdr->common.computerName.v = tmp;
|
||
|
||
Stream_Read(s, rdpdr->common.computerName.v, rdpdr->common.computerNameLen);
|
||
|
||
pc->computerNameLen = rdpdr->common.computerNameLen;
|
||
pc->computerNameUnicode = rdpdr->common.computerNameUnicode;
|
||
tmp = realloc(pc->computerName.v, pc->computerNameLen);
|
||
if (!tmp)
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
pc->computerName.v = tmp;
|
||
memcpy(pc->computerName.v, rdpdr->common.computerName.v, pc->computerNameLen);
|
||
|
||
return CHANNEL_RC_OK;
|
||
}
|
||
|
||
static UINT rdpdr_send_client_name_request(pClientContext* pc, pf_channel_client_context* rdpdr)
|
||
{
|
||
wStream* s = NULL;
|
||
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(pc);
|
||
|
||
{
|
||
void* tmp = realloc(rdpdr->common.computerName.v, pc->computerNameLen);
|
||
if (!tmp)
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
rdpdr->common.computerName.v = tmp;
|
||
rdpdr->common.computerNameLen = pc->computerNameLen;
|
||
rdpdr->common.computerNameUnicode = pc->computerNameUnicode;
|
||
memcpy(rdpdr->common.computerName.v, pc->computerName.v, pc->computerNameLen);
|
||
}
|
||
s = rdpdr_client_get_send_buffer(rdpdr, RDPDR_CTYP_CORE, PAKID_CORE_CLIENT_NAME,
|
||
12U + rdpdr->common.computerNameLen);
|
||
if (!s)
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
|
||
Stream_Write_UINT32(s, rdpdr->common.computerNameUnicode
|
||
? 1
|
||
: 0); /* unicodeFlag, 0 for ASCII and 1 for Unicode */
|
||
Stream_Write_UINT32(s, 0); /* codePage, must be set to zero */
|
||
Stream_Write_UINT32(s, rdpdr->common.computerNameLen);
|
||
Stream_Write(s, rdpdr->common.computerName.v, rdpdr->common.computerNameLen);
|
||
return rdpdr_client_send(rdpdr->log, pc, s);
|
||
}
|
||
|
||
#define rdpdr_ignore_capset(srv, log, s, header) \
|
||
rdpdr_ignore_capset_((srv), (log), (s), header, __func__)
|
||
static UINT rdpdr_ignore_capset_(BOOL srv, wLog* log, wStream* s,
|
||
const RDPDR_CAPABILITY_HEADER* header, const char* fkt)
|
||
{
|
||
WINPR_ASSERT(s);
|
||
WINPR_ASSERT(header);
|
||
|
||
Stream_Seek(s, header->CapabilityLength);
|
||
return CHANNEL_RC_OK;
|
||
}
|
||
|
||
static UINT rdpdr_client_process_general_capset(pf_channel_client_context* rdpdr, wStream* s,
|
||
const RDPDR_CAPABILITY_HEADER* header)
|
||
{
|
||
WINPR_UNUSED(rdpdr);
|
||
return rdpdr_ignore_capset(FALSE, rdpdr->log, s, header);
|
||
}
|
||
|
||
static UINT rdpdr_process_printer_capset(pf_channel_client_context* rdpdr, wStream* s,
|
||
const RDPDR_CAPABILITY_HEADER* header)
|
||
{
|
||
WINPR_UNUSED(rdpdr);
|
||
return rdpdr_ignore_capset(FALSE, rdpdr->log, s, header);
|
||
}
|
||
|
||
static UINT rdpdr_process_port_capset(pf_channel_client_context* rdpdr, wStream* s,
|
||
const RDPDR_CAPABILITY_HEADER* header)
|
||
{
|
||
WINPR_UNUSED(rdpdr);
|
||
return rdpdr_ignore_capset(FALSE, rdpdr->log, s, header);
|
||
}
|
||
|
||
static UINT rdpdr_process_drive_capset(pf_channel_client_context* rdpdr, wStream* s,
|
||
const RDPDR_CAPABILITY_HEADER* header)
|
||
{
|
||
WINPR_UNUSED(rdpdr);
|
||
return rdpdr_ignore_capset(FALSE, rdpdr->log, s, header);
|
||
}
|
||
|
||
static UINT rdpdr_process_smartcard_capset(pf_channel_client_context* rdpdr, wStream* s,
|
||
const RDPDR_CAPABILITY_HEADER* header)
|
||
{
|
||
WINPR_UNUSED(rdpdr);
|
||
return rdpdr_ignore_capset(FALSE, rdpdr->log, s, header);
|
||
}
|
||
|
||
static UINT rdpdr_process_server_core_capability_request(pf_channel_client_context* rdpdr,
|
||
wStream* s)
|
||
{
|
||
UINT status = CHANNEL_RC_OK;
|
||
UINT16 numCapabilities = 0;
|
||
|
||
WINPR_ASSERT(rdpdr);
|
||
|
||
if (!rdpdr_process_server_header(FALSE, rdpdr->log, s, RDPDR_CTYP_CORE,
|
||
PAKID_CORE_SERVER_CAPABILITY, 4))
|
||
return ERROR_INVALID_DATA;
|
||
|
||
Stream_Read_UINT16(s, numCapabilities);
|
||
Stream_Seek(s, 2); /* pad (2 bytes) */
|
||
|
||
for (UINT16 i = 0; i < numCapabilities; i++)
|
||
{
|
||
RDPDR_CAPABILITY_HEADER header = { 0 };
|
||
UINT error = rdpdr_read_capset_header(rdpdr->log, s, &header);
|
||
if (error != CHANNEL_RC_OK)
|
||
return error;
|
||
|
||
if (header.CapabilityType < ARRAYSIZE(rdpdr->common.capabilityVersions))
|
||
{
|
||
if (rdpdr->common.capabilityVersions[header.CapabilityType] > header.Version)
|
||
rdpdr->common.capabilityVersions[header.CapabilityType] = header.Version;
|
||
|
||
WLog_Print(rdpdr->log, WLOG_TRACE,
|
||
"capability %s got version %" PRIu32 ", will use version %" PRIu32,
|
||
rdpdr_cap_type_string(header.CapabilityType), header.Version,
|
||
rdpdr->common.capabilityVersions[header.CapabilityType]);
|
||
}
|
||
|
||
switch (header.CapabilityType)
|
||
{
|
||
case CAP_GENERAL_TYPE:
|
||
status = rdpdr_client_process_general_capset(rdpdr, s, &header);
|
||
break;
|
||
|
||
case CAP_PRINTER_TYPE:
|
||
status = rdpdr_process_printer_capset(rdpdr, s, &header);
|
||
break;
|
||
|
||
case CAP_PORT_TYPE:
|
||
status = rdpdr_process_port_capset(rdpdr, s, &header);
|
||
break;
|
||
|
||
case CAP_DRIVE_TYPE:
|
||
status = rdpdr_process_drive_capset(rdpdr, s, &header);
|
||
break;
|
||
|
||
case CAP_SMARTCARD_TYPE:
|
||
status = rdpdr_process_smartcard_capset(rdpdr, s, &header);
|
||
break;
|
||
|
||
default:
|
||
WLog_Print(rdpdr->log, WLOG_WARN,
|
||
"unknown capability 0x%04" PRIx16 ", length %" PRIu16
|
||
", version %" PRIu32,
|
||
header.CapabilityType, header.CapabilityLength, header.Version);
|
||
Stream_Seek(s, header.CapabilityLength);
|
||
break;
|
||
}
|
||
|
||
if (status != CHANNEL_RC_OK)
|
||
return status;
|
||
}
|
||
|
||
return CHANNEL_RC_OK;
|
||
}
|
||
|
||
static BOOL rdpdr_write_general_capset(wLog* log, pf_channel_common_context* rdpdr, wStream* s)
|
||
{
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
|
||
const RDPDR_CAPABILITY_HEADER header = { CAP_GENERAL_TYPE, 44,
|
||
rdpdr->capabilityVersions[CAP_GENERAL_TYPE] };
|
||
if (rdpdr_write_capset_header(log, s, &header) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
Stream_Write_UINT32(s, 0); /* osType, ignored on receipt */
|
||
Stream_Write_UINT32(s, 0); /* osVersion, should be ignored */
|
||
Stream_Write_UINT16(s, rdpdr->versionMajor); /* protocolMajorVersion, must be set to 1 */
|
||
Stream_Write_UINT16(s, rdpdr->versionMinor); /* protocolMinorVersion */
|
||
Stream_Write_UINT32(s, 0x0000FFFF); /* ioCode1 */
|
||
Stream_Write_UINT32(s, 0); /* ioCode2, must be set to zero, reserved for future use */
|
||
Stream_Write_UINT32(s, RDPDR_DEVICE_REMOVE_PDUS | RDPDR_CLIENT_DISPLAY_NAME_PDU |
|
||
RDPDR_USER_LOGGEDON_PDU); /* extendedPDU */
|
||
Stream_Write_UINT32(s, ENABLE_ASYNCIO); /* extraFlags1 */
|
||
Stream_Write_UINT32(s, 0); /* extraFlags2, must be set to zero, reserved for future use */
|
||
Stream_Write_UINT32(s, rdpdr->SpecialDeviceCount); /* SpecialTypeDeviceCap, number of special
|
||
devices to be redirected before logon */
|
||
return TRUE;
|
||
}
|
||
|
||
static BOOL rdpdr_write_printer_capset(wLog* log, pf_channel_common_context* rdpdr, wStream* s)
|
||
{
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
|
||
const RDPDR_CAPABILITY_HEADER header = { CAP_PRINTER_TYPE, 8,
|
||
rdpdr->capabilityVersions[CAP_PRINTER_TYPE] };
|
||
if (rdpdr_write_capset_header(log, s, &header) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
return TRUE;
|
||
}
|
||
|
||
static BOOL rdpdr_write_port_capset(wLog* log, pf_channel_common_context* rdpdr, wStream* s)
|
||
{
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
|
||
const RDPDR_CAPABILITY_HEADER header = { CAP_PORT_TYPE, 8,
|
||
rdpdr->capabilityVersions[CAP_PORT_TYPE] };
|
||
if (rdpdr_write_capset_header(log, s, &header) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
return TRUE;
|
||
}
|
||
|
||
static BOOL rdpdr_write_drive_capset(wLog* log, pf_channel_common_context* rdpdr, wStream* s)
|
||
{
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
|
||
const RDPDR_CAPABILITY_HEADER header = { CAP_DRIVE_TYPE, 8,
|
||
rdpdr->capabilityVersions[CAP_DRIVE_TYPE] };
|
||
if (rdpdr_write_capset_header(log, s, &header) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
return TRUE;
|
||
}
|
||
|
||
static BOOL rdpdr_write_smartcard_capset(wLog* log, pf_channel_common_context* rdpdr, wStream* s)
|
||
{
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
|
||
const RDPDR_CAPABILITY_HEADER header = { CAP_SMARTCARD_TYPE, 8,
|
||
rdpdr->capabilityVersions[CAP_SMARTCARD_TYPE] };
|
||
if (rdpdr_write_capset_header(log, s, &header) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
return TRUE;
|
||
}
|
||
|
||
static UINT rdpdr_send_server_capability_request(pf_channel_server_context* rdpdr)
|
||
{
|
||
wStream* s =
|
||
rdpdr_server_get_send_buffer(rdpdr, RDPDR_CTYP_CORE, PAKID_CORE_SERVER_CAPABILITY, 8);
|
||
if (!s)
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
Stream_Write_UINT16(s, 5); /* numCapabilities */
|
||
Stream_Write_UINT16(s, 0); /* pad */
|
||
if (!rdpdr_write_general_capset(rdpdr->log, &rdpdr->common, s))
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
if (!rdpdr_write_printer_capset(rdpdr->log, &rdpdr->common, s))
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
if (!rdpdr_write_port_capset(rdpdr->log, &rdpdr->common, s))
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
if (!rdpdr_write_drive_capset(rdpdr->log, &rdpdr->common, s))
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
if (!rdpdr_write_smartcard_capset(rdpdr->log, &rdpdr->common, s))
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
return rdpdr_seal_send_free_request(rdpdr, s);
|
||
}
|
||
|
||
static UINT rdpdr_process_client_capability_response(pf_channel_server_context* rdpdr, wStream* s)
|
||
{
|
||
const UINT16 component = RDPDR_CTYP_CORE;
|
||
const UINT16 packetid = PAKID_CORE_CLIENT_CAPABILITY;
|
||
UINT status = CHANNEL_RC_OK;
|
||
UINT16 numCapabilities = 0;
|
||
WINPR_ASSERT(rdpdr);
|
||
|
||
if (!rdpdr_process_server_header(TRUE, rdpdr->log, s, component, packetid, 4))
|
||
return ERROR_INVALID_DATA;
|
||
|
||
Stream_Read_UINT16(s, numCapabilities);
|
||
Stream_Seek_UINT16(s); /* padding */
|
||
|
||
for (UINT16 x = 0; x < numCapabilities; x++)
|
||
{
|
||
RDPDR_CAPABILITY_HEADER header = { 0 };
|
||
UINT error = rdpdr_read_capset_header(rdpdr->log, s, &header);
|
||
if (error != CHANNEL_RC_OK)
|
||
return error;
|
||
if (header.CapabilityType < ARRAYSIZE(rdpdr->common.capabilityVersions))
|
||
{
|
||
if (rdpdr->common.capabilityVersions[header.CapabilityType] > header.Version)
|
||
rdpdr->common.capabilityVersions[header.CapabilityType] = header.Version;
|
||
|
||
WLog_Print(rdpdr->log, WLOG_TRACE,
|
||
"capability %s got version %" PRIu32 ", will use version %" PRIu32,
|
||
rdpdr_cap_type_string(header.CapabilityType), header.Version,
|
||
rdpdr->common.capabilityVersions[header.CapabilityType]);
|
||
}
|
||
|
||
switch (header.CapabilityType)
|
||
{
|
||
case CAP_GENERAL_TYPE:
|
||
status = rdpdr_ignore_capset(TRUE, rdpdr->log, s, &header);
|
||
break;
|
||
|
||
case CAP_PRINTER_TYPE:
|
||
status = rdpdr_ignore_capset(TRUE, rdpdr->log, s, &header);
|
||
break;
|
||
|
||
case CAP_PORT_TYPE:
|
||
status = rdpdr_ignore_capset(TRUE, rdpdr->log, s, &header);
|
||
break;
|
||
|
||
case CAP_DRIVE_TYPE:
|
||
status = rdpdr_ignore_capset(TRUE, rdpdr->log, s, &header);
|
||
break;
|
||
|
||
case CAP_SMARTCARD_TYPE:
|
||
status = rdpdr_ignore_capset(TRUE, rdpdr->log, s, &header);
|
||
break;
|
||
|
||
default:
|
||
SERVER_RX_LOG(rdpdr->log, WLOG_WARN,
|
||
"[%s | %s] invalid capability type 0x%04" PRIx16,
|
||
rdpdr_component_string(component), rdpdr_packetid_string(packetid),
|
||
header.CapabilityType);
|
||
status = ERROR_INVALID_DATA;
|
||
break;
|
||
}
|
||
|
||
if (status != CHANNEL_RC_OK)
|
||
break;
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
static UINT rdpdr_send_client_capability_response(pClientContext* pc,
|
||
pf_channel_client_context* rdpdr)
|
||
{
|
||
wStream* s = NULL;
|
||
|
||
WINPR_ASSERT(rdpdr);
|
||
s = rdpdr_client_get_send_buffer(rdpdr, RDPDR_CTYP_CORE, PAKID_CORE_CLIENT_CAPABILITY, 4);
|
||
if (!s)
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
|
||
Stream_Write_UINT16(s, 5); /* numCapabilities */
|
||
Stream_Write_UINT16(s, 0); /* pad */
|
||
if (!rdpdr_write_general_capset(rdpdr->log, &rdpdr->common, s))
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
if (!rdpdr_write_printer_capset(rdpdr->log, &rdpdr->common, s))
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
if (!rdpdr_write_port_capset(rdpdr->log, &rdpdr->common, s))
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
if (!rdpdr_write_drive_capset(rdpdr->log, &rdpdr->common, s))
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
if (!rdpdr_write_smartcard_capset(rdpdr->log, &rdpdr->common, s))
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
return rdpdr_client_send(rdpdr->log, pc, s);
|
||
}
|
||
|
||
static UINT rdpdr_send_server_clientid_confirm(pf_channel_server_context* rdpdr)
|
||
{
|
||
wStream* s = NULL;
|
||
|
||
s = rdpdr_server_get_send_buffer(rdpdr, RDPDR_CTYP_CORE, PAKID_CORE_CLIENTID_CONFIRM, 8);
|
||
if (!s)
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
Stream_Write_UINT16(s, rdpdr->common.versionMajor);
|
||
Stream_Write_UINT16(s, rdpdr->common.versionMinor);
|
||
Stream_Write_UINT32(s, rdpdr->common.clientID);
|
||
return rdpdr_seal_send_free_request(rdpdr, s);
|
||
}
|
||
|
||
static UINT rdpdr_process_server_clientid_confirm(pf_channel_client_context* rdpdr, wStream* s)
|
||
{
|
||
UINT16 versionMajor = 0;
|
||
UINT16 versionMinor = 0;
|
||
UINT32 clientID = 0;
|
||
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
|
||
if (!rdpdr_process_server_header(FALSE, rdpdr->log, s, RDPDR_CTYP_CORE,
|
||
PAKID_CORE_CLIENTID_CONFIRM, 8))
|
||
return ERROR_INVALID_DATA;
|
||
|
||
Stream_Read_UINT16(s, versionMajor);
|
||
Stream_Read_UINT16(s, versionMinor);
|
||
if (!rdpdr_check_version(FALSE, rdpdr->log, versionMajor, versionMinor, RDPDR_CTYP_CORE,
|
||
PAKID_CORE_CLIENTID_CONFIRM))
|
||
return ERROR_INVALID_DATA;
|
||
|
||
Stream_Read_UINT32(s, clientID);
|
||
|
||
if ((versionMajor != rdpdr->common.versionMajor) ||
|
||
(versionMinor != rdpdr->common.versionMinor))
|
||
{
|
||
CLIENT_RX_LOG(rdpdr->log, WLOG_WARN,
|
||
"[%s | %s] Version mismatch, sent %" PRIu16 ".%" PRIu16
|
||
", downgraded to %" PRIu16 ".%" PRIu16,
|
||
rdpdr_component_string(RDPDR_CTYP_CORE),
|
||
rdpdr_packetid_string(PAKID_CORE_CLIENTID_CONFIRM),
|
||
rdpdr->common.versionMajor, rdpdr->common.versionMinor, versionMajor,
|
||
versionMinor);
|
||
rdpdr->common.versionMajor = versionMajor;
|
||
rdpdr->common.versionMinor = versionMinor;
|
||
}
|
||
|
||
if (clientID != rdpdr->common.clientID)
|
||
{
|
||
CLIENT_RX_LOG(rdpdr->log, WLOG_WARN,
|
||
"[%s | %s] clientID mismatch, sent 0x%08" PRIx32 ", changed to 0x%08" PRIx32,
|
||
rdpdr_component_string(RDPDR_CTYP_CORE),
|
||
rdpdr_packetid_string(PAKID_CORE_CLIENTID_CONFIRM), rdpdr->common.clientID,
|
||
clientID);
|
||
rdpdr->common.clientID = clientID;
|
||
}
|
||
|
||
return CHANNEL_RC_OK;
|
||
}
|
||
|
||
static BOOL
|
||
rdpdr_process_server_capability_request_or_clientid_confirm(pf_channel_client_context* rdpdr,
|
||
wStream* s)
|
||
{
|
||
const UINT32 mask = STATE_CLIENT_EXPECT_SERVER_CLIENT_ID_CONFIRM |
|
||
STATE_CLIENT_EXPECT_SERVER_CORE_CAPABILITY_REQUEST;
|
||
const UINT16 rcomponent = RDPDR_CTYP_CORE;
|
||
UINT16 component = 0;
|
||
UINT16 packetid = 0;
|
||
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
|
||
if ((rdpdr->flags & mask) == mask)
|
||
{
|
||
CLIENT_RX_LOG(rdpdr->log, WLOG_WARN, "already past this state, abort!");
|
||
return FALSE;
|
||
}
|
||
|
||
if (!Stream_CheckAndLogRequiredLengthClient(rdpdr->log, s, 4))
|
||
return FALSE;
|
||
|
||
Stream_Read_UINT16(s, component);
|
||
if (rcomponent != component)
|
||
{
|
||
CLIENT_RX_LOG(rdpdr->log, WLOG_WARN, "got component %s, expected %s",
|
||
rdpdr_component_string(component), rdpdr_component_string(rcomponent));
|
||
return FALSE;
|
||
}
|
||
Stream_Read_UINT16(s, packetid);
|
||
Stream_Rewind(s, 4);
|
||
|
||
switch (packetid)
|
||
{
|
||
case PAKID_CORE_SERVER_CAPABILITY:
|
||
if (rdpdr->flags & STATE_CLIENT_EXPECT_SERVER_CORE_CAPABILITY_REQUEST)
|
||
{
|
||
CLIENT_RX_LOG(rdpdr->log, WLOG_WARN, "got duplicate packetid %s",
|
||
rdpdr_packetid_string(packetid));
|
||
return FALSE;
|
||
}
|
||
rdpdr->flags |= STATE_CLIENT_EXPECT_SERVER_CORE_CAPABILITY_REQUEST;
|
||
return rdpdr_process_server_core_capability_request(rdpdr, s) == CHANNEL_RC_OK;
|
||
case PAKID_CORE_CLIENTID_CONFIRM:
|
||
default:
|
||
if (rdpdr->flags & STATE_CLIENT_EXPECT_SERVER_CLIENT_ID_CONFIRM)
|
||
{
|
||
CLIENT_RX_LOG(rdpdr->log, WLOG_WARN, "got duplicate packetid %s",
|
||
rdpdr_packetid_string(packetid));
|
||
return FALSE;
|
||
}
|
||
rdpdr->flags |= STATE_CLIENT_EXPECT_SERVER_CLIENT_ID_CONFIRM;
|
||
return rdpdr_process_server_clientid_confirm(rdpdr, s) == CHANNEL_RC_OK;
|
||
}
|
||
}
|
||
|
||
#if defined(WITH_PROXY_EMULATE_SMARTCARD)
|
||
static UINT rdpdr_send_emulated_scard_device_list_announce_request(pClientContext* pc,
|
||
pf_channel_client_context* rdpdr)
|
||
{
|
||
wStream* s = NULL;
|
||
|
||
s = rdpdr_client_get_send_buffer(rdpdr, RDPDR_CTYP_CORE, PAKID_CORE_DEVICELIST_ANNOUNCE, 24);
|
||
if (!s)
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
|
||
Stream_Write_UINT32(s, 1); /* deviceCount -> our emulated smartcard only */
|
||
Stream_Write_UINT32(s, RDPDR_DTYP_SMARTCARD); /* deviceType */
|
||
Stream_Write_UINT32(
|
||
s, SCARD_DEVICE_ID); /* deviceID -> reserve highest value for the emulated smartcard */
|
||
Stream_Write(s, "SCARD\0\0\0", 8);
|
||
Stream_Write_UINT32(s, 6);
|
||
Stream_Write(s, "SCARD\0", 6);
|
||
|
||
return rdpdr_client_send(rdpdr->log, pc, s);
|
||
}
|
||
|
||
static UINT rdpdr_send_emulated_scard_device_remove(pClientContext* pc,
|
||
pf_channel_client_context* rdpdr)
|
||
{
|
||
wStream* s = NULL;
|
||
|
||
s = rdpdr_client_get_send_buffer(rdpdr, RDPDR_CTYP_CORE, PAKID_CORE_DEVICELIST_REMOVE, 24);
|
||
if (!s)
|
||
return CHANNEL_RC_NO_MEMORY;
|
||
|
||
Stream_Write_UINT32(s, 1); /* deviceCount -> our emulated smartcard only */
|
||
Stream_Write_UINT32(
|
||
s, SCARD_DEVICE_ID); /* deviceID -> reserve highest value for the emulated smartcard */
|
||
|
||
return rdpdr_client_send(rdpdr->log, pc, s);
|
||
}
|
||
|
||
static UINT rdpdr_process_server_device_announce_response(pf_channel_client_context* rdpdr,
|
||
wStream* s)
|
||
{
|
||
const UINT16 component = RDPDR_CTYP_CORE;
|
||
const UINT16 packetid = PAKID_CORE_DEVICE_REPLY;
|
||
UINT32 deviceID = 0;
|
||
UINT32 resultCode = 0;
|
||
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
|
||
if (!rdpdr_process_server_header(TRUE, rdpdr->log, s, component, packetid, 8))
|
||
return ERROR_INVALID_DATA;
|
||
|
||
Stream_Read_UINT32(s, deviceID);
|
||
Stream_Read_UINT32(s, resultCode);
|
||
|
||
if (deviceID != SCARD_DEVICE_ID)
|
||
{
|
||
CLIENT_RX_LOG(rdpdr->log, WLOG_WARN,
|
||
"[%s | %s] deviceID mismatch, sent 0x%08" PRIx32 ", changed to 0x%08" PRIx32,
|
||
rdpdr_component_string(component), rdpdr_packetid_string(packetid),
|
||
SCARD_DEVICE_ID, deviceID);
|
||
}
|
||
else if (resultCode != 0)
|
||
{
|
||
CLIENT_RX_LOG(rdpdr->log, WLOG_WARN,
|
||
"[%s | %s] deviceID 0x%08" PRIx32 " resultCode=0x%08" PRIx32,
|
||
rdpdr_component_string(component), rdpdr_packetid_string(packetid), deviceID,
|
||
resultCode);
|
||
}
|
||
else
|
||
CLIENT_RX_LOG(rdpdr->log, WLOG_DEBUG,
|
||
"[%s | %s] deviceID 0x%08" PRIx32 " resultCode=0x%08" PRIx32
|
||
" -> emulated smartcard redirected!",
|
||
rdpdr_component_string(component), rdpdr_packetid_string(packetid), deviceID,
|
||
resultCode);
|
||
|
||
return CHANNEL_RC_OK;
|
||
}
|
||
#endif
|
||
|
||
static BOOL pf_channel_rdpdr_rewrite_device_list_to(wStream* s, UINT32 fromVersion,
|
||
UINT32 toVersion)
|
||
{
|
||
BOOL rc = FALSE;
|
||
if (fromVersion == toVersion)
|
||
return TRUE;
|
||
|
||
const size_t cap = Stream_GetRemainingLength(s);
|
||
wStream* clone = Stream_New(NULL, cap);
|
||
if (!clone)
|
||
goto fail;
|
||
const size_t pos = Stream_GetPosition(s);
|
||
Stream_Copy(s, clone, cap);
|
||
Stream_SealLength(clone);
|
||
|
||
Stream_SetPosition(clone, 0);
|
||
Stream_SetPosition(s, pos);
|
||
|
||
/* Skip device count */
|
||
if (!Stream_SafeSeek(s, 4))
|
||
goto fail;
|
||
|
||
UINT32 count = 0;
|
||
if (Stream_GetRemainingLength(clone) < 4)
|
||
goto fail;
|
||
Stream_Read_UINT32(clone, count);
|
||
|
||
for (UINT32 x = 0; x < count; x++)
|
||
{
|
||
RdpdrDevice device = { 0 };
|
||
const size_t charCount = ARRAYSIZE(device.PreferredDosName);
|
||
if (Stream_GetRemainingLength(clone) < 20)
|
||
goto fail;
|
||
|
||
Stream_Read_UINT32(clone, device.DeviceType); /* DeviceType (4 bytes) */
|
||
Stream_Read_UINT32(clone, device.DeviceId); /* DeviceId (4 bytes) */
|
||
Stream_Read(clone, device.PreferredDosName, charCount); /* PreferredDosName (8 bytes) */
|
||
Stream_Read_UINT32(clone, device.DeviceDataLength); /* DeviceDataLength (4 bytes) */
|
||
device.DeviceData = Stream_Pointer(clone);
|
||
if (!Stream_SafeSeek(clone, device.DeviceDataLength))
|
||
goto fail;
|
||
|
||
if (!Stream_EnsureRemainingCapacity(s, 20))
|
||
goto fail;
|
||
Stream_Write_UINT32(s, device.DeviceType);
|
||
Stream_Write_UINT32(s, device.DeviceId);
|
||
Stream_Write(s, device.PreferredDosName, charCount);
|
||
|
||
if (device.DeviceType == RDPDR_DTYP_FILESYSTEM)
|
||
{
|
||
if (toVersion == DRIVE_CAPABILITY_VERSION_01)
|
||
Stream_Write_UINT32(s, 0); /* No unicode name */
|
||
else
|
||
{
|
||
const size_t datalen = charCount * sizeof(WCHAR);
|
||
if (!Stream_EnsureRemainingCapacity(s, datalen + sizeof(UINT32)))
|
||
goto fail;
|
||
Stream_Write_UINT32(s, datalen);
|
||
|
||
const SSIZE_T rcw = Stream_Write_UTF16_String_From_UTF8(
|
||
s, charCount, device.PreferredDosName, charCount - 1, TRUE);
|
||
if (rcw < 0)
|
||
goto fail;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Stream_Write_UINT32(s, device.DeviceDataLength);
|
||
if (!Stream_EnsureRemainingCapacity(s, device.DeviceDataLength))
|
||
goto fail;
|
||
Stream_Write(s, device.DeviceData, device.DeviceDataLength);
|
||
}
|
||
}
|
||
|
||
Stream_SealLength(s);
|
||
rc = TRUE;
|
||
|
||
fail:
|
||
Stream_Free(clone, TRUE);
|
||
return rc;
|
||
}
|
||
|
||
static BOOL pf_channel_rdpdr_rewrite_device_list(pf_channel_client_context* rdpdr,
|
||
pServerContext* ps, wStream* s, BOOL toServer)
|
||
{
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(ps);
|
||
|
||
const size_t pos = Stream_GetPosition(s);
|
||
UINT16 component = 0;
|
||
UINT16 packetid = 0;
|
||
Stream_SetPosition(s, 0);
|
||
|
||
if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, 4))
|
||
return FALSE;
|
||
|
||
Stream_Read_UINT16(s, component);
|
||
Stream_Read_UINT16(s, packetid);
|
||
if ((component != RDPDR_CTYP_CORE) || (packetid != PAKID_CORE_DEVICELIST_ANNOUNCE))
|
||
{
|
||
Stream_SetPosition(s, pos);
|
||
return TRUE;
|
||
}
|
||
|
||
const pf_channel_server_context* srv =
|
||
HashTable_GetItemValue(ps->interceptContextMap, RDPDR_SVC_CHANNEL_NAME);
|
||
if (!srv)
|
||
{
|
||
WLog_Print(rdpdr->log, WLOG_ERROR, "No channel %s in intercep map", RDPDR_SVC_CHANNEL_NAME);
|
||
return FALSE;
|
||
}
|
||
|
||
UINT32 from = srv->common.capabilityVersions[CAP_DRIVE_TYPE];
|
||
UINT32 to = rdpdr->common.capabilityVersions[CAP_DRIVE_TYPE];
|
||
if (toServer)
|
||
{
|
||
from = rdpdr->common.capabilityVersions[CAP_DRIVE_TYPE];
|
||
to = srv->common.capabilityVersions[CAP_DRIVE_TYPE];
|
||
}
|
||
if (!pf_channel_rdpdr_rewrite_device_list_to(s, from, to))
|
||
return FALSE;
|
||
|
||
Stream_SetPosition(s, pos);
|
||
return TRUE;
|
||
}
|
||
|
||
static BOOL pf_channel_rdpdr_client_send_to_server(pf_channel_client_context* rdpdr,
|
||
pServerContext* ps, wStream* s)
|
||
{
|
||
WINPR_ASSERT(rdpdr);
|
||
if (ps)
|
||
{
|
||
UINT16 server_channel_id = WTSChannelGetId(ps->context.peer, RDPDR_SVC_CHANNEL_NAME);
|
||
|
||
/* Ignore messages for channels that can not be mapped.
|
||
* The client might not have enabled support for this specific channel,
|
||
* so just drop the message. */
|
||
if (server_channel_id == 0)
|
||
return TRUE;
|
||
|
||
if (!pf_channel_rdpdr_rewrite_device_list(rdpdr, ps, s, TRUE))
|
||
return FALSE;
|
||
size_t len = Stream_Length(s);
|
||
Stream_SetPosition(s, len);
|
||
rdpdr_dump_send_packet(rdpdr->log, WLOG_TRACE, s, proxy_client_tx);
|
||
WINPR_ASSERT(ps->context.peer);
|
||
WINPR_ASSERT(ps->context.peer->SendChannelData);
|
||
return ps->context.peer->SendChannelData(ps->context.peer, server_channel_id,
|
||
Stream_Buffer(s), len);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
static BOOL pf_channel_send_client_queue(pClientContext* pc, pf_channel_client_context* rdpdr);
|
||
|
||
#if defined(WITH_PROXY_EMULATE_SMARTCARD)
|
||
static BOOL rdpdr_process_server_loggedon_request(pServerContext* ps, pClientContext* pc,
|
||
pf_channel_client_context* rdpdr, wStream* s,
|
||
UINT16 component, UINT16 packetid)
|
||
{
|
||
WINPR_ASSERT(rdpdr);
|
||
WLog_Print(rdpdr->log, WLOG_DEBUG, "[%s | %s]", rdpdr_component_string(component),
|
||
rdpdr_packetid_string(packetid));
|
||
if (rdpdr_send_emulated_scard_device_remove(pc, rdpdr) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
if (rdpdr_send_emulated_scard_device_list_announce_request(pc, rdpdr) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
return pf_channel_rdpdr_client_send_to_server(rdpdr, ps, s);
|
||
}
|
||
|
||
static BOOL filter_smartcard_io_requests(pf_channel_client_context* rdpdr, wStream* s,
|
||
UINT16* pPacketid)
|
||
{
|
||
BOOL rc = FALSE;
|
||
UINT16 component = 0;
|
||
UINT16 packetid = 0;
|
||
UINT32 deviceID = 0;
|
||
size_t pos = 0;
|
||
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(pPacketid);
|
||
|
||
if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, 4))
|
||
return FALSE;
|
||
|
||
pos = Stream_GetPosition(s);
|
||
Stream_Read_UINT16(s, component);
|
||
Stream_Read_UINT16(s, packetid);
|
||
|
||
if (Stream_GetRemainingLength(s) >= 4)
|
||
Stream_Read_UINT32(s, deviceID);
|
||
|
||
WLog_Print(rdpdr->log, WLOG_DEBUG, "got: [%s | %s]: [0x%08" PRIx32 "]",
|
||
rdpdr_component_string(component), rdpdr_packetid_string(packetid), deviceID);
|
||
|
||
if (component != RDPDR_CTYP_CORE)
|
||
goto fail;
|
||
|
||
switch (packetid)
|
||
{
|
||
case PAKID_CORE_SERVER_ANNOUNCE:
|
||
case PAKID_CORE_CLIENTID_CONFIRM:
|
||
case PAKID_CORE_CLIENT_NAME:
|
||
case PAKID_CORE_DEVICELIST_ANNOUNCE:
|
||
case PAKID_CORE_DEVICELIST_REMOVE:
|
||
case PAKID_CORE_SERVER_CAPABILITY:
|
||
case PAKID_CORE_CLIENT_CAPABILITY:
|
||
WLog_Print(rdpdr->log, WLOG_WARN, "Filtering client -> server message [%s | %s]",
|
||
rdpdr_component_string(component), rdpdr_packetid_string(packetid));
|
||
*pPacketid = packetid;
|
||
break;
|
||
case PAKID_CORE_USER_LOGGEDON:
|
||
*pPacketid = packetid;
|
||
break;
|
||
case PAKID_CORE_DEVICE_REPLY:
|
||
case PAKID_CORE_DEVICE_IOREQUEST:
|
||
if (deviceID != SCARD_DEVICE_ID)
|
||
goto fail;
|
||
*pPacketid = packetid;
|
||
break;
|
||
default:
|
||
if (deviceID != SCARD_DEVICE_ID)
|
||
goto fail;
|
||
WLog_Print(rdpdr->log, WLOG_WARN,
|
||
"Got [%s | %s] for deviceID 0x%08" PRIx32 ", TODO: Not handled!",
|
||
rdpdr_component_string(component), rdpdr_packetid_string(packetid),
|
||
deviceID);
|
||
goto fail;
|
||
}
|
||
|
||
rc = TRUE;
|
||
|
||
fail:
|
||
Stream_SetPosition(s, pos);
|
||
return rc;
|
||
}
|
||
#endif
|
||
|
||
BOOL pf_channel_send_client_queue(pClientContext* pc, pf_channel_client_context* rdpdr)
|
||
{
|
||
UINT16 channelId = 0;
|
||
|
||
WINPR_ASSERT(pc);
|
||
WINPR_ASSERT(rdpdr);
|
||
|
||
if (rdpdr->state != STATE_CLIENT_CHANNEL_RUNNING)
|
||
return FALSE;
|
||
channelId = freerdp_channels_get_id_by_name(pc->context.instance, RDPDR_SVC_CHANNEL_NAME);
|
||
if ((channelId == 0) || (channelId == UINT16_MAX))
|
||
return TRUE;
|
||
|
||
Queue_Lock(rdpdr->queue);
|
||
while (Queue_Count(rdpdr->queue) > 0)
|
||
{
|
||
wStream* s = Queue_Dequeue(rdpdr->queue);
|
||
if (!s)
|
||
continue;
|
||
|
||
size_t len = Stream_Length(s);
|
||
Stream_SetPosition(s, len);
|
||
|
||
rdpdr_dump_send_packet(rdpdr->log, WLOG_TRACE, s, proxy_server_tx " (queue) ");
|
||
WINPR_ASSERT(pc->context.instance->SendChannelData);
|
||
if (!pc->context.instance->SendChannelData(pc->context.instance, channelId,
|
||
Stream_Buffer(s), len))
|
||
{
|
||
CLIENT_TX_LOG(rdpdr->log, WLOG_ERROR, "xxxxxx TODO: Failed to send data!");
|
||
}
|
||
Stream_Free(s, TRUE);
|
||
}
|
||
Queue_Unlock(rdpdr->queue);
|
||
return TRUE;
|
||
}
|
||
|
||
static BOOL rdpdr_handle_server_announce_request(pClientContext* pc,
|
||
pf_channel_client_context* rdpdr, wStream* s)
|
||
{
|
||
WINPR_ASSERT(pc);
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
|
||
if (rdpdr_process_server_announce_request(rdpdr, s) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
if (rdpdr_send_client_announce_reply(pc, rdpdr) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
if (rdpdr_send_client_name_request(pc, rdpdr) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
rdpdr->state = STATE_CLIENT_EXPECT_SERVER_CORE_CAPABILITY_REQUEST;
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL pf_channel_rdpdr_client_handle(pClientContext* pc, UINT16 channelId, const char* channel_name,
|
||
const BYTE* xdata, size_t xsize, UINT32 flags, size_t totalSize)
|
||
{
|
||
pf_channel_client_context* rdpdr = NULL;
|
||
pServerContext* ps = NULL;
|
||
wStream* s = NULL;
|
||
#if defined(WITH_PROXY_EMULATE_SMARTCARD)
|
||
UINT16 packetid = 0;
|
||
#endif
|
||
|
||
WINPR_ASSERT(pc);
|
||
WINPR_ASSERT(pc->pdata);
|
||
WINPR_ASSERT(pc->interceptContextMap);
|
||
WINPR_ASSERT(channel_name);
|
||
WINPR_ASSERT(xdata);
|
||
|
||
ps = pc->pdata->ps;
|
||
|
||
rdpdr = HashTable_GetItemValue(pc->interceptContextMap, channel_name);
|
||
if (!rdpdr)
|
||
{
|
||
CLIENT_RX_LOG(WLog_Get(RTAG), WLOG_ERROR,
|
||
"Channel %s [0x%04" PRIx16 "] missing context in interceptContextMap",
|
||
channel_name, channelId);
|
||
return FALSE;
|
||
}
|
||
s = rdpdr->common.buffer;
|
||
if (flags & CHANNEL_FLAG_FIRST)
|
||
Stream_SetPosition(s, 0);
|
||
if (!Stream_EnsureRemainingCapacity(s, xsize))
|
||
{
|
||
CLIENT_RX_LOG(rdpdr->log, WLOG_ERROR,
|
||
"Channel %s [0x%04" PRIx16 "] not enough memory [need %" PRIuz "]",
|
||
channel_name, channelId, xsize);
|
||
return FALSE;
|
||
}
|
||
Stream_Write(s, xdata, xsize);
|
||
if ((flags & CHANNEL_FLAG_LAST) == 0)
|
||
return TRUE;
|
||
|
||
Stream_SealLength(s);
|
||
Stream_SetPosition(s, 0);
|
||
if (Stream_Length(s) != totalSize)
|
||
{
|
||
CLIENT_RX_LOG(rdpdr->log, WLOG_WARN,
|
||
"Received invalid %s channel data (server -> proxy), expected %" PRIuz
|
||
"bytes, got %" PRIuz,
|
||
channel_name, totalSize, Stream_Length(s));
|
||
return FALSE;
|
||
}
|
||
|
||
rdpdr_dump_received_packet(rdpdr->log, WLOG_TRACE, s, proxy_server_rx);
|
||
switch (rdpdr->state)
|
||
{
|
||
case STATE_CLIENT_EXPECT_SERVER_ANNOUNCE_REQUEST:
|
||
if (!rdpdr_handle_server_announce_request(pc, rdpdr, s))
|
||
return FALSE;
|
||
break;
|
||
case STATE_CLIENT_EXPECT_SERVER_CORE_CAPABILITY_REQUEST:
|
||
if (!rdpdr_process_server_capability_request_or_clientid_confirm(rdpdr, s))
|
||
return FALSE;
|
||
rdpdr->state = STATE_CLIENT_EXPECT_SERVER_CLIENT_ID_CONFIRM;
|
||
break;
|
||
case STATE_CLIENT_EXPECT_SERVER_CLIENT_ID_CONFIRM:
|
||
if (!rdpdr_process_server_capability_request_or_clientid_confirm(rdpdr, s))
|
||
return FALSE;
|
||
if (rdpdr_send_client_capability_response(pc, rdpdr) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
#if defined(WITH_PROXY_EMULATE_SMARTCARD)
|
||
if (pf_channel_smartcard_client_emulate(pc))
|
||
{
|
||
if (rdpdr_send_emulated_scard_device_list_announce_request(pc, rdpdr) !=
|
||
CHANNEL_RC_OK)
|
||
return FALSE;
|
||
rdpdr->state = STATE_CLIENT_CHANNEL_RUNNING;
|
||
}
|
||
else
|
||
#endif
|
||
{
|
||
rdpdr->state = STATE_CLIENT_CHANNEL_RUNNING;
|
||
pf_channel_send_client_queue(pc, rdpdr);
|
||
}
|
||
|
||
break;
|
||
case STATE_CLIENT_CHANNEL_RUNNING:
|
||
#if defined(WITH_PROXY_EMULATE_SMARTCARD)
|
||
if (!pf_channel_smartcard_client_emulate(pc) ||
|
||
!filter_smartcard_io_requests(rdpdr, s, &packetid))
|
||
return pf_channel_rdpdr_client_send_to_server(rdpdr, ps, s);
|
||
else
|
||
{
|
||
switch (packetid)
|
||
{
|
||
case PAKID_CORE_USER_LOGGEDON:
|
||
return rdpdr_process_server_loggedon_request(ps, pc, rdpdr, s,
|
||
RDPDR_CTYP_CORE, packetid);
|
||
case PAKID_CORE_DEVICE_IOREQUEST:
|
||
{
|
||
wStream* out = rdpdr_client_get_send_buffer(
|
||
rdpdr, RDPDR_CTYP_CORE, PAKID_CORE_DEVICE_IOCOMPLETION, 0);
|
||
WINPR_ASSERT(out);
|
||
|
||
if (!rdpdr_process_server_header(FALSE, rdpdr->log, s, RDPDR_CTYP_CORE,
|
||
PAKID_CORE_DEVICE_IOREQUEST, 20))
|
||
return FALSE;
|
||
|
||
if (!pf_channel_smartcard_client_handle(rdpdr->log, pc, s, out,
|
||
rdpdr_client_send))
|
||
return FALSE;
|
||
}
|
||
break;
|
||
case PAKID_CORE_SERVER_ANNOUNCE:
|
||
pf_channel_rdpdr_client_reset(pc);
|
||
if (!rdpdr_handle_server_announce_request(pc, rdpdr, s))
|
||
return FALSE;
|
||
break;
|
||
case PAKID_CORE_SERVER_CAPABILITY:
|
||
rdpdr->state = STATE_CLIENT_EXPECT_SERVER_CORE_CAPABILITY_REQUEST;
|
||
rdpdr->flags = 0;
|
||
return pf_channel_rdpdr_client_handle(pc, channelId, channel_name, xdata,
|
||
xsize, flags, totalSize);
|
||
case PAKID_CORE_DEVICE_REPLY:
|
||
break;
|
||
default:
|
||
CLIENT_RX_LOG(
|
||
rdpdr->log, WLOG_ERROR,
|
||
"Channel %s [0x%04" PRIx16
|
||
"] we´ve reached an impossible state %s! [%s] aliens invaded!",
|
||
channel_name, channelId, rdpdr_client_state_to_string(rdpdr->state),
|
||
rdpdr_packetid_string(packetid));
|
||
return FALSE;
|
||
}
|
||
}
|
||
break;
|
||
#else
|
||
return pf_channel_rdpdr_client_send_to_server(rdpdr, ps, s);
|
||
#endif
|
||
default:
|
||
CLIENT_RX_LOG(rdpdr->log, WLOG_ERROR,
|
||
"Channel %s [0x%04" PRIx16
|
||
"] we´ve reached an impossible state %s! aliens invaded!",
|
||
channel_name, channelId, rdpdr_client_state_to_string(rdpdr->state));
|
||
return FALSE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
static void pf_channel_rdpdr_common_context_free(pf_channel_common_context* common)
|
||
{
|
||
if (!common)
|
||
return;
|
||
free(common->computerName.v);
|
||
Stream_Free(common->s, TRUE);
|
||
Stream_Free(common->buffer, TRUE);
|
||
}
|
||
|
||
static void pf_channel_rdpdr_client_context_free(InterceptContextMapEntry* base)
|
||
{
|
||
pf_channel_client_context* entry = (pf_channel_client_context*)base;
|
||
if (!entry)
|
||
return;
|
||
|
||
pf_channel_rdpdr_common_context_free(&entry->common);
|
||
Queue_Free(entry->queue);
|
||
free(entry);
|
||
}
|
||
|
||
static BOOL pf_channel_rdpdr_common_context_new(pf_channel_common_context* common,
|
||
void (*fkt)(InterceptContextMapEntry*))
|
||
{
|
||
if (!common)
|
||
return FALSE;
|
||
common->base.free = fkt;
|
||
common->s = Stream_New(NULL, 1024);
|
||
if (!common->s)
|
||
return FALSE;
|
||
common->buffer = Stream_New(NULL, 1024);
|
||
if (!common->buffer)
|
||
return FALSE;
|
||
common->computerNameUnicode = 1;
|
||
common->computerName.v = NULL;
|
||
common->versionMajor = RDPDR_VERSION_MAJOR;
|
||
common->versionMinor = RDPDR_VERSION_MINOR_RDP10X;
|
||
common->clientID = SCARD_DEVICE_ID;
|
||
|
||
const UINT32 versions[] = { 0,
|
||
GENERAL_CAPABILITY_VERSION_02,
|
||
PRINT_CAPABILITY_VERSION_01,
|
||
PORT_CAPABILITY_VERSION_01,
|
||
DRIVE_CAPABILITY_VERSION_02,
|
||
SMARTCARD_CAPABILITY_VERSION_01 };
|
||
|
||
memcpy(common->capabilityVersions, versions, sizeof(common->capabilityVersions));
|
||
return TRUE;
|
||
}
|
||
|
||
static BOOL pf_channel_rdpdr_client_pass_message(pServerContext* ps, pClientContext* pc,
|
||
UINT16 channelId, const char* channel_name,
|
||
wStream* s)
|
||
{
|
||
pf_channel_client_context* rdpdr = NULL;
|
||
|
||
WINPR_ASSERT(ps);
|
||
WINPR_ASSERT(pc);
|
||
|
||
rdpdr = HashTable_GetItemValue(pc->interceptContextMap, channel_name);
|
||
if (!rdpdr)
|
||
return TRUE; /* Ignore data for channels not available on proxy -> server connection */
|
||
WINPR_ASSERT(rdpdr->queue);
|
||
|
||
if (!pf_channel_rdpdr_rewrite_device_list(rdpdr, ps, s, FALSE))
|
||
return FALSE;
|
||
if (!Queue_Enqueue(rdpdr->queue, s))
|
||
return FALSE;
|
||
pf_channel_send_client_queue(pc, rdpdr);
|
||
return TRUE;
|
||
}
|
||
|
||
#if defined(WITH_PROXY_EMULATE_SMARTCARD)
|
||
static BOOL filter_smartcard_device_list_remove(pf_channel_server_context* rdpdr, wStream* s)
|
||
{
|
||
size_t pos = 0;
|
||
UINT32 count = 0;
|
||
|
||
WINPR_ASSERT(rdpdr);
|
||
if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, sizeof(UINT32)))
|
||
return TRUE;
|
||
pos = Stream_GetPosition(s);
|
||
Stream_Read_UINT32(s, count);
|
||
|
||
if (count == 0)
|
||
return TRUE;
|
||
|
||
if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(rdpdr->log, s, count, sizeof(UINT32)))
|
||
return TRUE;
|
||
|
||
for (UINT32 x = 0; x < count; x++)
|
||
{
|
||
UINT32 deviceID = 0;
|
||
BYTE* dst = Stream_Pointer(s);
|
||
Stream_Read_UINT32(s, deviceID);
|
||
if (deviceID == SCARD_DEVICE_ID)
|
||
{
|
||
ArrayList_Remove(rdpdr->blockedDevices, (void*)(size_t)deviceID);
|
||
|
||
/* This is the only device, filter it! */
|
||
if (count == 1)
|
||
return TRUE;
|
||
|
||
/* Remove this device from the list */
|
||
memmove(dst, Stream_ConstPointer(s), (count - x - 1) * sizeof(UINT32));
|
||
|
||
count--;
|
||
Stream_SetPosition(s, pos);
|
||
Stream_Write_UINT32(s, count);
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
static BOOL filter_smartcard_device_io_request(pf_channel_server_context* rdpdr, wStream* s)
|
||
{
|
||
UINT32 DeviceID = 0;
|
||
WINPR_ASSERT(rdpdr);
|
||
WINPR_ASSERT(s);
|
||
Stream_Read_UINT32(s, DeviceID);
|
||
return ArrayList_Contains(rdpdr->blockedDevices, (void*)(size_t)DeviceID);
|
||
}
|
||
|
||
static BOOL filter_smartcard_device_list_announce(pf_channel_server_context* rdpdr, wStream* s)
|
||
{
|
||
UINT32 count = 0;
|
||
|
||
WINPR_ASSERT(rdpdr);
|
||
if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, sizeof(UINT32)))
|
||
return TRUE;
|
||
const size_t pos = Stream_GetPosition(s);
|
||
Stream_Read_UINT32(s, count);
|
||
|
||
if (count == 0)
|
||
return TRUE;
|
||
|
||
for (UINT32 x = 0; x < count; x++)
|
||
{
|
||
UINT32 DeviceType = 0;
|
||
UINT32 DeviceId = 0;
|
||
char PreferredDosName[8];
|
||
UINT32 DeviceDataLength = 0;
|
||
BYTE* dst = Stream_Pointer(s);
|
||
if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, 20))
|
||
return TRUE;
|
||
Stream_Read_UINT32(s, DeviceType);
|
||
Stream_Read_UINT32(s, DeviceId);
|
||
Stream_Read(s, PreferredDosName, ARRAYSIZE(PreferredDosName));
|
||
Stream_Read_UINT32(s, DeviceDataLength);
|
||
if (!Stream_SafeSeek(s, DeviceDataLength))
|
||
return TRUE;
|
||
if (DeviceType == RDPDR_DTYP_SMARTCARD)
|
||
{
|
||
ArrayList_Append(rdpdr->blockedDevices, (void*)(size_t)DeviceId);
|
||
if (count == 1)
|
||
return TRUE;
|
||
|
||
WLog_Print(rdpdr->log, WLOG_INFO, "Filtering smartcard device 0x%08" PRIx32 "",
|
||
DeviceId);
|
||
|
||
memmove(dst, Stream_ConstPointer(s), Stream_GetRemainingLength(s));
|
||
Stream_SetPosition(s, pos);
|
||
Stream_Write_UINT32(s, count - 1);
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
static BOOL filter_smartcard_device_list_announce_request(pf_channel_server_context* rdpdr,
|
||
wStream* s)
|
||
{
|
||
BOOL rc = TRUE;
|
||
size_t pos = 0;
|
||
UINT16 component = 0;
|
||
UINT16 packetid = 0;
|
||
|
||
WINPR_ASSERT(rdpdr);
|
||
if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, 8))
|
||
return FALSE;
|
||
|
||
pos = Stream_GetPosition(s);
|
||
|
||
Stream_Read_UINT16(s, component);
|
||
Stream_Read_UINT16(s, packetid);
|
||
|
||
if (component != RDPDR_CTYP_CORE)
|
||
goto fail;
|
||
|
||
switch (packetid)
|
||
{
|
||
case PAKID_CORE_DEVICELIST_ANNOUNCE:
|
||
if (filter_smartcard_device_list_announce(rdpdr, s))
|
||
goto fail;
|
||
break;
|
||
case PAKID_CORE_DEVICELIST_REMOVE:
|
||
if (filter_smartcard_device_list_remove(rdpdr, s))
|
||
goto fail;
|
||
break;
|
||
case PAKID_CORE_DEVICE_IOREQUEST:
|
||
if (filter_smartcard_device_io_request(rdpdr, s))
|
||
goto fail;
|
||
break;
|
||
|
||
case PAKID_CORE_SERVER_ANNOUNCE:
|
||
case PAKID_CORE_CLIENTID_CONFIRM:
|
||
case PAKID_CORE_CLIENT_NAME:
|
||
case PAKID_CORE_DEVICE_REPLY:
|
||
case PAKID_CORE_SERVER_CAPABILITY:
|
||
case PAKID_CORE_CLIENT_CAPABILITY:
|
||
case PAKID_CORE_USER_LOGGEDON:
|
||
WLog_Print(rdpdr->log, WLOG_WARN, "Filtering client -> server message [%s | %s]",
|
||
rdpdr_component_string(component), rdpdr_packetid_string(packetid));
|
||
goto fail;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
rc = FALSE;
|
||
fail:
|
||
Stream_SetPosition(s, pos);
|
||
return rc;
|
||
}
|
||
#endif
|
||
|
||
static void* stream_copy(const void* obj)
|
||
{
|
||
const wStream* src = obj;
|
||
wStream* dst = Stream_New(NULL, Stream_Capacity(src));
|
||
if (!dst)
|
||
return NULL;
|
||
memcpy(Stream_Buffer(dst), Stream_ConstBuffer(src), Stream_Capacity(dst));
|
||
Stream_SetLength(dst, Stream_Length(src));
|
||
Stream_SetPosition(dst, Stream_GetPosition(src));
|
||
return dst;
|
||
}
|
||
|
||
static void stream_free(void* obj)
|
||
{
|
||
wStream* s = obj;
|
||
Stream_Free(s, TRUE);
|
||
}
|
||
|
||
static const char* pf_channel_rdpdr_client_context(void* arg)
|
||
{
|
||
pClientContext* pc = arg;
|
||
if (!pc)
|
||
return "pc=null";
|
||
if (!pc->pdata)
|
||
return "pc->pdata=null";
|
||
return pc->pdata->session_id;
|
||
}
|
||
|
||
BOOL pf_channel_rdpdr_client_new(pClientContext* pc)
|
||
{
|
||
wObject* obj = NULL;
|
||
pf_channel_client_context* rdpdr = NULL;
|
||
|
||
WINPR_ASSERT(pc);
|
||
WINPR_ASSERT(pc->interceptContextMap);
|
||
|
||
rdpdr = calloc(1, sizeof(pf_channel_client_context));
|
||
if (!rdpdr)
|
||
return FALSE;
|
||
rdpdr->log = WLog_Get(RTAG);
|
||
WINPR_ASSERT(rdpdr->log);
|
||
|
||
WLog_SetContext(rdpdr->log, pf_channel_rdpdr_client_context, pc);
|
||
if (!pf_channel_rdpdr_common_context_new(&rdpdr->common, pf_channel_rdpdr_client_context_free))
|
||
goto fail;
|
||
|
||
rdpdr->maxMajorVersion = RDPDR_VERSION_MAJOR;
|
||
rdpdr->maxMinorVersion = RDPDR_VERSION_MINOR_RDP10X;
|
||
rdpdr->state = STATE_CLIENT_EXPECT_SERVER_ANNOUNCE_REQUEST;
|
||
|
||
rdpdr->queue = Queue_New(TRUE, 0, 0);
|
||
if (!rdpdr->queue)
|
||
goto fail;
|
||
obj = Queue_Object(rdpdr->queue);
|
||
WINPR_ASSERT(obj);
|
||
obj->fnObjectNew = stream_copy;
|
||
obj->fnObjectFree = stream_free;
|
||
if (!HashTable_Insert(pc->interceptContextMap, RDPDR_SVC_CHANNEL_NAME, rdpdr))
|
||
goto fail;
|
||
// NOLINTNEXTLINE(clang-analyzer-unix.Malloc): HashTable_Insert takes ownership of rdpdr
|
||
return TRUE;
|
||
fail:
|
||
pf_channel_rdpdr_client_context_free(&rdpdr->common.base);
|
||
return FALSE;
|
||
}
|
||
|
||
void pf_channel_rdpdr_client_free(pClientContext* pc)
|
||
{
|
||
WINPR_ASSERT(pc);
|
||
WINPR_ASSERT(pc->interceptContextMap);
|
||
HashTable_Remove(pc->interceptContextMap, RDPDR_SVC_CHANNEL_NAME);
|
||
}
|
||
|
||
static void pf_channel_rdpdr_server_context_free(InterceptContextMapEntry* base)
|
||
{
|
||
pf_channel_server_context* entry = (pf_channel_server_context*)base;
|
||
if (!entry)
|
||
return;
|
||
|
||
(void)WTSVirtualChannelClose(entry->handle);
|
||
pf_channel_rdpdr_common_context_free(&entry->common);
|
||
ArrayList_Free(entry->blockedDevices);
|
||
free(entry);
|
||
}
|
||
|
||
static const char* pf_channel_rdpdr_server_context(void* arg)
|
||
{
|
||
pServerContext* ps = arg;
|
||
if (!ps)
|
||
return "ps=null";
|
||
if (!ps->pdata)
|
||
return "ps->pdata=null";
|
||
return ps->pdata->session_id;
|
||
}
|
||
|
||
BOOL pf_channel_rdpdr_server_new(pServerContext* ps)
|
||
{
|
||
pf_channel_server_context* rdpdr = NULL;
|
||
PULONG pSessionId = NULL;
|
||
DWORD BytesReturned = 0;
|
||
|
||
WINPR_ASSERT(ps);
|
||
WINPR_ASSERT(ps->interceptContextMap);
|
||
|
||
rdpdr = calloc(1, sizeof(pf_channel_server_context));
|
||
if (!rdpdr)
|
||
return FALSE;
|
||
rdpdr->log = WLog_Get(RTAG);
|
||
WINPR_ASSERT(rdpdr->log);
|
||
WLog_SetContext(rdpdr->log, pf_channel_rdpdr_server_context, ps);
|
||
|
||
if (!pf_channel_rdpdr_common_context_new(&rdpdr->common, pf_channel_rdpdr_server_context_free))
|
||
goto fail;
|
||
rdpdr->state = STATE_SERVER_INITIAL;
|
||
|
||
rdpdr->blockedDevices = ArrayList_New(FALSE);
|
||
if (!rdpdr->blockedDevices)
|
||
goto fail;
|
||
|
||
rdpdr->SessionId = WTS_CURRENT_SESSION;
|
||
if (WTSQuerySessionInformationA(ps->vcm, WTS_CURRENT_SESSION, WTSSessionId, (LPSTR*)&pSessionId,
|
||
&BytesReturned))
|
||
{
|
||
rdpdr->SessionId = (DWORD)*pSessionId;
|
||
WTSFreeMemory(pSessionId);
|
||
}
|
||
|
||
rdpdr->handle = WTSVirtualChannelOpenEx(rdpdr->SessionId, RDPDR_SVC_CHANNEL_NAME, 0);
|
||
if (rdpdr->handle == 0)
|
||
goto fail;
|
||
if (!HashTable_Insert(ps->interceptContextMap, RDPDR_SVC_CHANNEL_NAME, rdpdr))
|
||
goto fail;
|
||
|
||
// NOLINTNEXTLINE(clang-analyzer-unix.Malloc): HashTable_Insert takes ownership of rdpdr
|
||
return TRUE;
|
||
fail:
|
||
pf_channel_rdpdr_server_context_free(&rdpdr->common.base);
|
||
return FALSE;
|
||
}
|
||
|
||
void pf_channel_rdpdr_server_free(pServerContext* ps)
|
||
{
|
||
WINPR_ASSERT(ps);
|
||
WINPR_ASSERT(ps->interceptContextMap);
|
||
HashTable_Remove(ps->interceptContextMap, RDPDR_SVC_CHANNEL_NAME);
|
||
}
|
||
|
||
static pf_channel_server_context* get_channel(pServerContext* ps, BOOL send)
|
||
{
|
||
pf_channel_server_context* rdpdr = NULL;
|
||
WINPR_ASSERT(ps);
|
||
WINPR_ASSERT(ps->interceptContextMap);
|
||
|
||
rdpdr = HashTable_GetItemValue(ps->interceptContextMap, RDPDR_SVC_CHANNEL_NAME);
|
||
if (!rdpdr)
|
||
{
|
||
SERVER_RXTX_LOG(send, WLog_Get(RTAG), WLOG_ERROR,
|
||
"Channel %s missing context in interceptContextMap",
|
||
RDPDR_SVC_CHANNEL_NAME);
|
||
return NULL;
|
||
}
|
||
|
||
return rdpdr;
|
||
}
|
||
|
||
BOOL pf_channel_rdpdr_server_handle(pServerContext* ps, UINT16 channelId, const char* channel_name,
|
||
const BYTE* xdata, size_t xsize, UINT32 flags, size_t totalSize)
|
||
{
|
||
wStream* s = NULL;
|
||
pClientContext* pc = NULL;
|
||
pf_channel_server_context* rdpdr = get_channel(ps, FALSE);
|
||
if (!rdpdr)
|
||
return FALSE;
|
||
|
||
WINPR_ASSERT(ps->pdata);
|
||
pc = ps->pdata->pc;
|
||
|
||
s = rdpdr->common.buffer;
|
||
|
||
if (flags & CHANNEL_FLAG_FIRST)
|
||
Stream_SetPosition(s, 0);
|
||
|
||
if (!Stream_EnsureRemainingCapacity(s, xsize))
|
||
return FALSE;
|
||
Stream_Write(s, xdata, xsize);
|
||
|
||
if ((flags & CHANNEL_FLAG_LAST) == 0)
|
||
return TRUE;
|
||
|
||
Stream_SealLength(s);
|
||
Stream_SetPosition(s, 0);
|
||
|
||
if (Stream_Length(s) != totalSize)
|
||
{
|
||
SERVER_RX_LOG(rdpdr->log, WLOG_WARN,
|
||
"Received invalid %s channel data (client -> proxy), expected %" PRIuz
|
||
"bytes, got %" PRIuz,
|
||
channel_name, totalSize, Stream_Length(s));
|
||
return FALSE;
|
||
}
|
||
|
||
rdpdr_dump_received_packet(rdpdr->log, WLOG_TRACE, s, proxy_client_rx);
|
||
switch (rdpdr->state)
|
||
{
|
||
case STATE_SERVER_EXPECT_CLIENT_ANNOUNCE_REPLY:
|
||
if (rdpdr_process_client_announce_reply(rdpdr, s) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
rdpdr->state = STATE_SERVER_EXPECT_CLIENT_NAME_REQUEST;
|
||
break;
|
||
case STATE_SERVER_EXPECT_CLIENT_NAME_REQUEST:
|
||
if (rdpdr_process_client_name_request(rdpdr, s, pc) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
if (rdpdr_send_server_capability_request(rdpdr) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
if (rdpdr_send_server_clientid_confirm(rdpdr) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
rdpdr->state = STATE_SERVER_EXPECT_EXPECT_CLIENT_CAPABILITY_RESPONE;
|
||
break;
|
||
case STATE_SERVER_EXPECT_EXPECT_CLIENT_CAPABILITY_RESPONE:
|
||
if (rdpdr_process_client_capability_response(rdpdr, s) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
rdpdr->state = STATE_SERVER_CHANNEL_RUNNING;
|
||
break;
|
||
case STATE_SERVER_CHANNEL_RUNNING:
|
||
#if defined(WITH_PROXY_EMULATE_SMARTCARD)
|
||
if (!pf_channel_smartcard_client_emulate(pc) ||
|
||
!filter_smartcard_device_list_announce_request(rdpdr, s))
|
||
{
|
||
if (!pf_channel_rdpdr_client_pass_message(ps, pc, channelId, channel_name, s))
|
||
return FALSE;
|
||
}
|
||
else
|
||
return pf_channel_smartcard_server_handle(ps, s);
|
||
#else
|
||
if (!pf_channel_rdpdr_client_pass_message(ps, pc, channelId, channel_name, s))
|
||
return FALSE;
|
||
#endif
|
||
break;
|
||
default:
|
||
case STATE_SERVER_INITIAL:
|
||
SERVER_RX_LOG(rdpdr->log, WLOG_WARN, "Invalid state %s",
|
||
rdpdr_server_state_to_string(rdpdr->state));
|
||
return FALSE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL pf_channel_rdpdr_server_announce(pServerContext* ps)
|
||
{
|
||
pf_channel_server_context* rdpdr = get_channel(ps, TRUE);
|
||
if (!rdpdr)
|
||
return FALSE;
|
||
|
||
WINPR_ASSERT(rdpdr->state == STATE_SERVER_INITIAL);
|
||
if (rdpdr_server_send_announce_request(rdpdr) != CHANNEL_RC_OK)
|
||
return FALSE;
|
||
rdpdr->state = STATE_SERVER_EXPECT_CLIENT_ANNOUNCE_REPLY;
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL pf_channel_rdpdr_client_reset(pClientContext* pc)
|
||
{
|
||
pf_channel_client_context* rdpdr = NULL;
|
||
|
||
WINPR_ASSERT(pc);
|
||
WINPR_ASSERT(pc->pdata);
|
||
WINPR_ASSERT(pc->interceptContextMap);
|
||
|
||
rdpdr = HashTable_GetItemValue(pc->interceptContextMap, RDPDR_SVC_CHANNEL_NAME);
|
||
if (!rdpdr)
|
||
return TRUE;
|
||
|
||
Queue_Clear(rdpdr->queue);
|
||
rdpdr->flags = 0;
|
||
rdpdr->state = STATE_CLIENT_EXPECT_SERVER_ANNOUNCE_REQUEST;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
static PfChannelResult pf_rdpdr_back_data(proxyData* pdata,
|
||
const pServerStaticChannelContext* channel,
|
||
const BYTE* xdata, size_t xsize, UINT32 flags,
|
||
size_t totalSize)
|
||
{
|
||
WINPR_ASSERT(pdata);
|
||
WINPR_ASSERT(channel);
|
||
|
||
if (!pf_channel_rdpdr_client_handle(pdata->pc, channel->back_channel_id, channel->channel_name,
|
||
xdata, xsize, flags, totalSize))
|
||
return PF_CHANNEL_RESULT_ERROR;
|
||
|
||
#if defined(WITH_PROXY_EMULATE_SMARTCARD)
|
||
if (pf_channel_smartcard_client_emulate(pdata->pc))
|
||
return PF_CHANNEL_RESULT_DROP;
|
||
#endif
|
||
return PF_CHANNEL_RESULT_DROP;
|
||
}
|
||
|
||
static PfChannelResult pf_rdpdr_front_data(proxyData* pdata,
|
||
const pServerStaticChannelContext* channel,
|
||
const BYTE* xdata, size_t xsize, UINT32 flags,
|
||
size_t totalSize)
|
||
{
|
||
WINPR_ASSERT(pdata);
|
||
WINPR_ASSERT(channel);
|
||
|
||
if (!pf_channel_rdpdr_server_handle(pdata->ps, channel->front_channel_id, channel->channel_name,
|
||
xdata, xsize, flags, totalSize))
|
||
return PF_CHANNEL_RESULT_ERROR;
|
||
|
||
#if defined(WITH_PROXY_EMULATE_SMARTCARD)
|
||
if (pf_channel_smartcard_client_emulate(pdata->pc))
|
||
return PF_CHANNEL_RESULT_DROP;
|
||
#endif
|
||
return PF_CHANNEL_RESULT_DROP;
|
||
}
|
||
|
||
BOOL pf_channel_setup_rdpdr(pServerContext* ps, pServerStaticChannelContext* channel)
|
||
{
|
||
channel->onBackData = pf_rdpdr_back_data;
|
||
channel->onFrontData = pf_rdpdr_front_data;
|
||
|
||
if (!pf_channel_rdpdr_server_new(ps))
|
||
return FALSE;
|
||
if (!pf_channel_rdpdr_server_announce(ps))
|
||
return FALSE;
|
||
|
||
return TRUE;
|
||
}
|