FreeRDP
Loading...
Searching...
No Matches
libfreerdp/core/gateway/rpc.c
1/*
2 * FreeRDP: A Remote Desktop Protocol Implementation
3 * RPC over HTTP
4 *
5 * Copyright 2012 Fujitsu Technology Solutions GmbH
6 * Copyright 2012 Dmitrij Jasnov <dmitrij.jasnov@ts.fujitsu.com>
7 * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 */
21
22#include <freerdp/config.h>
23
24#include "../settings.h"
25
26#include <winpr/crt.h>
27#include <winpr/assert.h>
28#include <winpr/cast.h>
29#include <winpr/tchar.h>
30#include <winpr/synch.h>
31#include <winpr/dsparse.h>
32#include <winpr/crypto.h>
33
34#include <freerdp/log.h>
35
36#ifdef FREERDP_HAVE_VALGRIND_MEMCHECK_H
37#include <valgrind/memcheck.h>
38#endif
39
40#include "../proxy.h"
41#include "http.h"
42#include "../credssp_auth.h"
43#include "ncacn_http.h"
44#include "rpc_bind.h"
45#include "rpc_fault.h"
46#include "rpc_client.h"
47
48#include "rpc.h"
49#include "rts.h"
50
51#define TAG FREERDP_TAG("core.gateway.rpc")
52
53static const char* PTYPE_STRINGS[] = { "PTYPE_REQUEST", "PTYPE_PING",
54 "PTYPE_RESPONSE", "PTYPE_FAULT",
55 "PTYPE_WORKING", "PTYPE_NOCALL",
56 "PTYPE_REJECT", "PTYPE_ACK",
57 "PTYPE_CL_CANCEL", "PTYPE_FACK",
58 "PTYPE_CANCEL_ACK", "PTYPE_BIND",
59 "PTYPE_BIND_ACK", "PTYPE_BIND_NAK",
60 "PTYPE_ALTER_CONTEXT", "PTYPE_ALTER_CONTEXT_RESP",
61 "PTYPE_RPC_AUTH_3", "PTYPE_SHUTDOWN",
62 "PTYPE_CO_CANCEL", "PTYPE_ORPHANED",
63 "PTYPE_RTS", "" };
64
65static const char* client_in_state_str(CLIENT_IN_CHANNEL_STATE state)
66{
67 // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
68 const char* str = "CLIENT_IN_CHANNEL_STATE_UNKNOWN";
69
70 switch (state)
71 {
72 case CLIENT_IN_CHANNEL_STATE_INITIAL:
73 str = "CLIENT_IN_CHANNEL_STATE_INITIAL";
74 break;
75
76 case CLIENT_IN_CHANNEL_STATE_CONNECTED:
77 str = "CLIENT_IN_CHANNEL_STATE_CONNECTED";
78 break;
79
80 case CLIENT_IN_CHANNEL_STATE_SECURITY:
81 str = "CLIENT_IN_CHANNEL_STATE_SECURITY";
82 break;
83
84 case CLIENT_IN_CHANNEL_STATE_NEGOTIATED:
85 str = "CLIENT_IN_CHANNEL_STATE_NEGOTIATED";
86 break;
87
88 case CLIENT_IN_CHANNEL_STATE_OPENED:
89 str = "CLIENT_IN_CHANNEL_STATE_OPENED";
90 break;
91
92 case CLIENT_IN_CHANNEL_STATE_OPENED_A4W:
93 str = "CLIENT_IN_CHANNEL_STATE_OPENED_A4W";
94 break;
95
96 case CLIENT_IN_CHANNEL_STATE_FINAL:
97 str = "CLIENT_IN_CHANNEL_STATE_FINAL";
98 break;
99 default:
100 break;
101 }
102 return str;
103}
104
105static const char* client_out_state_str(CLIENT_OUT_CHANNEL_STATE state)
106{
107 // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
108 const char* str = "CLIENT_OUT_CHANNEL_STATE_UNKNOWN";
109
110 switch (state)
111 {
112 case CLIENT_OUT_CHANNEL_STATE_INITIAL:
113 str = "CLIENT_OUT_CHANNEL_STATE_INITIAL";
114 break;
115
116 case CLIENT_OUT_CHANNEL_STATE_CONNECTED:
117 str = "CLIENT_OUT_CHANNEL_STATE_CONNECTED";
118 break;
119
120 case CLIENT_OUT_CHANNEL_STATE_SECURITY:
121 str = "CLIENT_OUT_CHANNEL_STATE_SECURITY";
122 break;
123
124 case CLIENT_OUT_CHANNEL_STATE_NEGOTIATED:
125 str = "CLIENT_OUT_CHANNEL_STATE_NEGOTIATED";
126 break;
127
128 case CLIENT_OUT_CHANNEL_STATE_OPENED:
129 str = "CLIENT_OUT_CHANNEL_STATE_OPENED";
130 break;
131
132 case CLIENT_OUT_CHANNEL_STATE_OPENED_A6W:
133 str = "CLIENT_OUT_CHANNEL_STATE_OPENED_A6W";
134 break;
135
136 case CLIENT_OUT_CHANNEL_STATE_OPENED_A10W:
137 str = "CLIENT_OUT_CHANNEL_STATE_OPENED_A10W";
138 break;
139
140 case CLIENT_OUT_CHANNEL_STATE_OPENED_B3W:
141 str = "CLIENT_OUT_CHANNEL_STATE_OPENED_B3W";
142 break;
143
144 case CLIENT_OUT_CHANNEL_STATE_RECYCLED:
145 str = "CLIENT_OUT_CHANNEL_STATE_RECYCLED";
146 break;
147
148 case CLIENT_OUT_CHANNEL_STATE_FINAL:
149 str = "CLIENT_OUT_CHANNEL_STATE_FINAL";
150 break;
151 default:
152 break;
153 }
154 return str;
155}
156
157const char* rpc_vc_state_str(VIRTUAL_CONNECTION_STATE state)
158{
159 // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
160 const char* str = "VIRTUAL_CONNECTION_STATE_UNKNOWN";
161
162 switch (state)
163 {
164 case VIRTUAL_CONNECTION_STATE_INITIAL:
165 str = "VIRTUAL_CONNECTION_STATE_INITIAL";
166 break;
167
168 case VIRTUAL_CONNECTION_STATE_OUT_CHANNEL_WAIT:
169 str = "VIRTUAL_CONNECTION_STATE_OUT_CHANNEL_WAIT";
170 break;
171
172 case VIRTUAL_CONNECTION_STATE_WAIT_A3W:
173 str = "VIRTUAL_CONNECTION_STATE_WAIT_A3W";
174 break;
175
176 case VIRTUAL_CONNECTION_STATE_WAIT_C2:
177 str = "VIRTUAL_CONNECTION_STATE_WAIT_C2";
178 break;
179
180 case VIRTUAL_CONNECTION_STATE_OPENED:
181 str = "VIRTUAL_CONNECTION_STATE_OPENED";
182 break;
183
184 case VIRTUAL_CONNECTION_STATE_FINAL:
185 str = "VIRTUAL_CONNECTION_STATE_FINAL";
186 break;
187 default:
188 break;
189 }
190 return str;
191}
192
193/*
194 * [MS-RPCH]: Remote Procedure Call over HTTP Protocol Specification:
195 * http://msdn.microsoft.com/en-us/library/cc243950/
196 *
197 *
198 *
199 * Connection Establishment
200 *
201 * Client Outbound Proxy Inbound Proxy Server
202 * | | | |
203 * |-----------------IN Channel Request--------------->| |
204 * |---OUT Channel Request-->| |<-Legacy Server Response-|
205 * | |<--------------Legacy Server Response--------------|
206 * | | | |
207 * |---------CONN_A1-------->| | |
208 * |----------------------CONN_B1--------------------->| |
209 * | |----------------------CONN_A2--------------------->|
210 * | | | |
211 * |<--OUT Channel Response--| |---------CONN_B2-------->|
212 * |<--------CONN_A3---------| | |
213 * | |<---------------------CONN_C1----------------------|
214 * | | |<--------CONN_B3---------|
215 * |<--------CONN_C2---------| | |
216 * | | | |
217 *
218 */
219
220void rpc_pdu_header_print(wLog* log, const rpcconn_hdr_t* header)
221{
222 WINPR_ASSERT(header);
223
224 WLog_Print(log, WLOG_INFO, "rpc_vers: %" PRIu8 "", header->common.rpc_vers);
225 WLog_Print(log, WLOG_INFO, "rpc_vers_minor: %" PRIu8 "", header->common.rpc_vers_minor);
226
227 if (header->common.ptype > PTYPE_RTS)
228 WLog_Print(log, WLOG_INFO, "ptype: %s (%" PRIu8 ")", "PTYPE_UNKNOWN", header->common.ptype);
229 else
230 WLog_Print(log, WLOG_INFO, "ptype: %s (%" PRIu8 ")", PTYPE_STRINGS[header->common.ptype],
231 header->common.ptype);
232
233 WLog_Print(log, WLOG_INFO, "pfc_flags (0x%02" PRIX8 ") = {", header->common.pfc_flags);
234
235 if (header->common.pfc_flags & PFC_FIRST_FRAG)
236 WLog_Print(log, WLOG_INFO, " PFC_FIRST_FRAG");
237
238 if (header->common.pfc_flags & PFC_LAST_FRAG)
239 WLog_Print(log, WLOG_INFO, " PFC_LAST_FRAG");
240
241 if (header->common.pfc_flags & PFC_PENDING_CANCEL)
242 WLog_Print(log, WLOG_INFO, " PFC_PENDING_CANCEL");
243
244 if (header->common.pfc_flags & PFC_RESERVED_1)
245 WLog_Print(log, WLOG_INFO, " PFC_RESERVED_1");
246
247 if (header->common.pfc_flags & PFC_CONC_MPX)
248 WLog_Print(log, WLOG_INFO, " PFC_CONC_MPX");
249
250 if (header->common.pfc_flags & PFC_DID_NOT_EXECUTE)
251 WLog_Print(log, WLOG_INFO, " PFC_DID_NOT_EXECUTE");
252
253 if (header->common.pfc_flags & PFC_OBJECT_UUID)
254 WLog_Print(log, WLOG_INFO, " PFC_OBJECT_UUID");
255
256 WLog_Print(log, WLOG_INFO, " }");
257 WLog_Print(log, WLOG_INFO,
258 "packed_drep[4]: %02" PRIX8 " %02" PRIX8 " %02" PRIX8 " %02" PRIX8 "",
259 header->common.packed_drep[0], header->common.packed_drep[1],
260 header->common.packed_drep[2], header->common.packed_drep[3]);
261 WLog_Print(log, WLOG_INFO, "frag_length: %" PRIu16 "", header->common.frag_length);
262 WLog_Print(log, WLOG_INFO, "auth_length: %" PRIu16 "", header->common.auth_length);
263 WLog_Print(log, WLOG_INFO, "call_id: %" PRIu32 "", header->common.call_id);
264
265 if (header->common.ptype == PTYPE_RESPONSE)
266 {
267 WLog_Print(log, WLOG_INFO, "alloc_hint: %" PRIu32 "", header->response.alloc_hint);
268 WLog_Print(log, WLOG_INFO, "p_cont_id: %" PRIu16 "", header->response.p_cont_id);
269 WLog_Print(log, WLOG_INFO, "cancel_count: %" PRIu8 "", header->response.cancel_count);
270 WLog_Print(log, WLOG_INFO, "reserved: %" PRIu8 "", header->response.reserved);
271 }
272}
273
274rpcconn_common_hdr_t rpc_pdu_header_init(const rdpRpc* rpc)
275{
276 rpcconn_common_hdr_t header = WINPR_C_ARRAY_INIT;
277 WINPR_ASSERT(rpc);
278
279 header.rpc_vers = rpc->rpc_vers;
280 header.rpc_vers_minor = rpc->rpc_vers_minor;
281 header.packed_drep[0] = rpc->packed_drep[0];
282 header.packed_drep[1] = rpc->packed_drep[1];
283 header.packed_drep[2] = rpc->packed_drep[2];
284 header.packed_drep[3] = rpc->packed_drep[3];
285 return header;
286}
287
288size_t rpc_offset_align(size_t* offset, size_t alignment)
289{
290 size_t pad = 0;
291 pad = *offset;
292 *offset = (*offset + alignment - 1) & ~(alignment - 1);
293 pad = *offset - pad;
294 return pad;
295}
296
297size_t rpc_offset_pad(size_t* offset, size_t pad)
298{
299 *offset += pad;
300 return pad;
301}
302
303/*
304 * PDU Segments:
305 * ________________________________
306 * | |
307 * | PDU Header |
308 * |________________________________|
309 * | |
310 * | |
311 * | PDU Body |
312 * | |
313 * |________________________________|
314 * | |
315 * | Security Trailer |
316 * |________________________________|
317 * | |
318 * | Authentication Token |
319 * |________________________________|
320 */
321
322/*
323 * PDU Structure with verification trailer
324 *
325 * MUST only appear in a request PDU!
326 * ________________________________
327 * | |
328 * | PDU Header |
329 * |________________________________| _______
330 * | | /|\
331 * | | |
332 * | Stub Data | |
333 * | | |
334 * |________________________________| |
335 * | | PDU Body
336 * | Stub Pad | |
337 * |________________________________| |
338 * | | |
339 * | Verification Trailer | |
340 * |________________________________| |
341 * | | |
342 * | Authentication Pad | |
343 * |________________________________| __\|/__
344 * | |
345 * | Security Trailer |
346 * |________________________________|
347 * | |
348 * | Authentication Token |
349 * |________________________________|
350 *
351 */
352
353/*
354 * Security Trailer:
355 *
356 * The sec_trailer structure MUST be placed at the end of the PDU, including past stub data,
357 * when present. The sec_trailer structure MUST be 4-byte aligned with respect to the beginning
358 * of the PDU. Padding octets MUST be used to align the sec_trailer structure if its natural
359 * beginning is not already 4-byte aligned.
360 *
361 * All PDUs that carry sec_trailer information share certain common fields:
362 * frag_length and auth_length. The beginning of the sec_trailer structure for each PDU MUST be
363 * calculated to start from offset (frag_length – auth_length – 8) from the beginning of the PDU.
364 *
365 * Immediately after the sec_trailer structure, there MUST be a BLOB carrying the authentication
366 * information produced by the security provider. This BLOB is called the authentication token and
367 * MUST be of size auth_length. The size MUST also be equal to the length from the first octet
368 * immediately after the sec_trailer structure all the way to the end of the fragment;
369 * the two values MUST be the same.
370 *
371 * A client or a server that (during composing of a PDU) has allocated more space for the
372 * authentication token than the security provider fills in SHOULD fill in the rest of
373 * the allocated space with zero octets. These zero octets are still considered to belong
374 * to the authentication token part of the PDU.
375 *
376 */
377
378BOOL rpc_get_stub_data_info(rdpRpc* rpc, const rpcconn_hdr_t* header, size_t* poffset,
379 size_t* length)
380{
381 size_t used = 0;
382 size_t offset = 0;
383 BOOL rc = FALSE;
384 UINT32 frag_length = 0;
385 UINT32 auth_length = 0;
386 UINT32 auth_pad_length = 0;
387 UINT32 sec_trailer_offset = 0;
388 const rpc_sec_trailer* sec_trailer = nullptr;
389
390 WINPR_ASSERT(rpc);
391 WINPR_ASSERT(header);
392 WINPR_ASSERT(poffset);
393 WINPR_ASSERT(length);
394
395 offset = RPC_COMMON_FIELDS_LENGTH;
396
397 switch (header->common.ptype)
398 {
399 case PTYPE_RESPONSE:
400 offset += 8;
401 rpc_offset_align(&offset, 8);
402 sec_trailer = &header->response.auth_verifier;
403 break;
404
405 case PTYPE_REQUEST:
406 offset += 4;
407 rpc_offset_align(&offset, 8);
408 sec_trailer = &header->request.auth_verifier;
409 break;
410
411 case PTYPE_RTS:
412 offset += 4;
413 break;
414
415 default:
416 WLog_Print(rpc->log, WLOG_ERROR, "Unknown PTYPE: 0x%02" PRIX8 "", header->common.ptype);
417 goto fail;
418 }
419
420 frag_length = header->common.frag_length;
421 auth_length = header->common.auth_length;
422
423 if (poffset)
424 *poffset = offset;
425
426 /* The fragment must be larger than the authentication trailer */
427 used = offset + auth_length + 8ull;
428 if (sec_trailer)
429 {
430 auth_pad_length = sec_trailer->auth_pad_length;
431 used += sec_trailer->auth_pad_length;
432 }
433
434 if (frag_length < used)
435 goto fail;
436
437 if (!length)
438 return TRUE;
439
440 sec_trailer_offset = frag_length - auth_length - 8;
441
442 /*
443 * According to [MS-RPCE], auth_pad_length is the number of padding
444 * octets used to 4-byte align the security trailer, but in practice
445 * we get values up to 15, which indicates 16-byte alignment.
446 */
447
448 if ((frag_length - (sec_trailer_offset + 8)) != auth_length)
449 {
450 WLog_Print(rpc->log, WLOG_ERROR,
451 "invalid auth_length: actual: %" PRIu32 ", expected: %" PRIu32 "", auth_length,
452 (frag_length - (sec_trailer_offset + 8)));
453 }
454
455 *length = sec_trailer_offset - auth_pad_length - offset;
456
457 rc = TRUE;
458fail:
459 return rc;
460}
461
462SSIZE_T rpc_channel_read(RpcChannel* channel, wStream* s, size_t length)
463{
464 int status = 0;
465
466 if (!channel || (length > INT32_MAX))
467 return -1;
468
469 ERR_clear_error();
470 status = BIO_read(channel->tls->bio, Stream_Pointer(s), (INT32)length);
471
472 if (status > 0)
473 {
474 Stream_Seek(s, (size_t)status);
475 return status;
476 }
477
478 if (BIO_should_retry(channel->tls->bio))
479 return 0;
480
481 WLog_Print(channel->rpc->log, WLOG_ERROR, "rpc_channel_read: Out of retries");
482 return -1;
483}
484
485SSIZE_T rpc_channel_write_int(RpcChannel* channel, const BYTE* data, size_t length,
486 const char* file, size_t line, const char* fkt)
487{
488 WINPR_ASSERT(channel);
489 WINPR_ASSERT(channel->rpc);
490
491 const DWORD level = WLOG_TRACE;
492 if (WLog_IsLevelActive(channel->rpc->log, level))
493 {
494 WLog_PrintTextMessage(channel->rpc->log, level, line, file, fkt,
495 "Sending [%s] %" PRIuz " bytes", fkt, length);
496 }
497
498 return freerdp_tls_write_all(channel->tls, data, length);
499}
500
501BOOL rpc_in_channel_transition_to_state(RpcInChannel* inChannel, CLIENT_IN_CHANNEL_STATE state)
502{
503 WINPR_ASSERT(inChannel);
504 inChannel->State = state;
505 WLog_Print(inChannel->common.rpc->log, WLOG_DEBUG, "%s", client_in_state_str(state));
506 return TRUE;
507}
508
509static int rpc_channel_rpch_init(RpcClient* client, RpcChannel* channel, const char* inout,
510 const GUID* guid)
511{
512 HttpContext* http = nullptr;
513 rdpSettings* settings = nullptr;
514 UINT32 timeout = 0;
515
516 if (!client || !channel || !inout || !client->context || !client->context->settings)
517 return -1;
518
519 settings = client->context->settings;
520 channel->auth = credssp_auth_new(client->context);
521 if (!rts_generate_cookie((BYTE*)&channel->Cookie))
522 return -1;
523 channel->client = client;
524
525 if (!channel->auth)
526 return -1;
527
528 channel->http = http_context_new();
529
530 if (!channel->http)
531 return -1;
532
533 http = channel->http;
534
535 {
536 if (!http_context_set_pragma(http, "ResourceTypeUuid=44e265dd-7daf-42cd-8560-3cdb6e7a2729"))
537 return -1;
538
539 if (guid)
540 {
541 RPC_CSTR strguid = nullptr;
542 RPC_STATUS rpcStatus = UuidToStringA(guid, &strguid);
543
544 if (rpcStatus != RPC_S_OK)
545 return -1;
546
547 const BOOL rc = http_context_append_pragma(http, "SessionId=%s", strguid);
548 RpcStringFreeA(&strguid);
549 if (!rc)
550 return -1;
551 }
552 if (timeout)
553 {
554 if (!http_context_append_pragma(http, "MinConnTimeout=%" PRIu32, timeout))
555 return -1;
556 }
557
558 if (!http_context_set_rdg_correlation_id(http, guid) ||
559 !http_context_set_rdg_connection_id(http, guid))
560 return -1;
561 }
562
563 /* TODO: "/rpcwithcert/rpcproxy.dll". */
564 if (!http_context_set_method(http, inout) ||
565 !http_context_set_uri(http, "/rpc/rpcproxy.dll?localhost:3388") ||
566 !http_context_set_accept(http, "application/rpc") ||
567 !http_context_set_cache_control(http, "no-cache") ||
568 !http_context_set_connection(http, "Keep-Alive") ||
569 !http_context_set_user_agent(http, "MSRPC") ||
570 !http_context_set_host(http, settings->GatewayHostname))
571 return -1;
572
573 return 1;
574}
575
576static int rpc_in_channel_init(rdpRpc* rpc, RpcInChannel* inChannel, const GUID* guid)
577{
578 WINPR_ASSERT(rpc);
579 WINPR_ASSERT(inChannel);
580
581 inChannel->common.rpc = rpc;
582 inChannel->State = CLIENT_IN_CHANNEL_STATE_INITIAL;
583 inChannel->BytesSent = 0;
584 inChannel->SenderAvailableWindow = rpc->ReceiveWindow;
585 inChannel->PingOriginator.ConnectionTimeout = 30;
586 inChannel->PingOriginator.KeepAliveInterval = 0;
587
588 if (rpc_channel_rpch_init(rpc->client, &inChannel->common, "RPC_IN_DATA", guid) < 0)
589 return -1;
590
591 return 1;
592}
593
594static RpcInChannel* rpc_in_channel_new(rdpRpc* rpc, const GUID* guid)
595{
596 RpcInChannel* inChannel = (RpcInChannel*)calloc(1, sizeof(RpcInChannel));
597
598 if (inChannel)
599 {
600 rpc_in_channel_init(rpc, inChannel, guid);
601 }
602
603 return inChannel;
604}
605
606void rpc_channel_free(RpcChannel* channel)
607{
608 if (!channel)
609 return;
610
611 credssp_auth_free(channel->auth);
612 http_context_free(channel->http);
613 freerdp_tls_free(channel->tls);
614 free(channel);
615}
616
617BOOL rpc_out_channel_transition_to_state(RpcOutChannel* outChannel, CLIENT_OUT_CHANNEL_STATE state)
618{
619 WINPR_ASSERT(outChannel);
620
621 outChannel->State = state;
622 WLog_Print(outChannel->common.rpc->log, WLOG_DEBUG, "%s", client_out_state_str(state));
623 return TRUE;
624}
625
626static int rpc_out_channel_init(rdpRpc* rpc, RpcOutChannel* outChannel, const GUID* guid)
627{
628 WINPR_ASSERT(rpc);
629 WINPR_ASSERT(outChannel);
630
631 outChannel->common.rpc = rpc;
632 outChannel->State = CLIENT_OUT_CHANNEL_STATE_INITIAL;
633 outChannel->BytesReceived = 0;
634 outChannel->ReceiverAvailableWindow = rpc->ReceiveWindow;
635 outChannel->ReceiveWindow = rpc->ReceiveWindow;
636 outChannel->ReceiveWindowSize = rpc->ReceiveWindow;
637 outChannel->AvailableWindowAdvertised = rpc->ReceiveWindow;
638
639 if (rpc_channel_rpch_init(rpc->client, &outChannel->common, "RPC_OUT_DATA", guid) < 0)
640 return -1;
641
642 return 1;
643}
644
645RpcOutChannel* rpc_out_channel_new(rdpRpc* rpc, const GUID* guid)
646{
647 RpcOutChannel* outChannel = (RpcOutChannel*)calloc(1, sizeof(RpcOutChannel));
648
649 if (outChannel)
650 {
651 rpc_out_channel_init(rpc, outChannel, guid);
652 }
653
654 return outChannel;
655}
656
657BOOL rpc_virtual_connection_transition_to_state(rdpRpc* rpc, RpcVirtualConnection* connection,
658 VIRTUAL_CONNECTION_STATE state)
659{
660 WINPR_ASSERT(connection);
661 WINPR_ASSERT(rpc);
662 connection->State = state;
663 WLog_Print(rpc->log, WLOG_DEBUG, "%s", rpc_vc_state_str(state));
664 return TRUE;
665}
666
667static void rpc_virtual_connection_free(RpcVirtualConnection* connection)
668{
669 if (!connection)
670 return;
671
672 if (connection->DefaultInChannel)
673 rpc_channel_free(&connection->DefaultInChannel->common);
674 if (connection->NonDefaultInChannel)
675 rpc_channel_free(&connection->NonDefaultInChannel->common);
676 if (connection->DefaultOutChannel)
677 rpc_channel_free(&connection->DefaultOutChannel->common);
678 if (connection->NonDefaultOutChannel)
679 rpc_channel_free(&connection->NonDefaultOutChannel->common);
680 free(connection);
681}
682
683static RpcVirtualConnection* rpc_virtual_connection_new(rdpRpc* rpc)
684{
685 WINPR_ASSERT(rpc);
686
687 RpcVirtualConnection* connection =
688 (RpcVirtualConnection*)calloc(1, sizeof(RpcVirtualConnection));
689
690 if (!connection)
691 return nullptr;
692
693 if (!rts_generate_cookie((BYTE*)&(connection->Cookie)))
694 goto fail;
695 if (!rts_generate_cookie((BYTE*)&(connection->AssociationGroupId)))
696 goto fail;
697 connection->State = VIRTUAL_CONNECTION_STATE_INITIAL;
698
699 connection->DefaultInChannel = rpc_in_channel_new(rpc, &connection->Cookie);
700
701 if (!connection->DefaultInChannel)
702 goto fail;
703
704 connection->DefaultOutChannel = rpc_out_channel_new(rpc, &connection->Cookie);
705
706 if (!connection->DefaultOutChannel)
707 goto fail;
708
709 return connection;
710fail:
711 rpc_virtual_connection_free(connection);
712 return nullptr;
713}
714
715static BOOL rpc_channel_tls_connect(RpcChannel* channel, UINT32 timeout)
716{
717 if (!channel || !channel->client || !channel->client->context ||
718 !channel->client->context->settings)
719 return FALSE;
720
721 rdpContext* context = channel->client->context;
722 WINPR_ASSERT(context);
723
724 rdpSettings* settings = context->settings;
725 WINPR_ASSERT(settings);
726
727 const char* proxyUsername = freerdp_settings_get_string(settings, FreeRDP_ProxyUsername);
728 const char* proxyPassword = freerdp_settings_get_string(settings, FreeRDP_ProxyPassword);
729
730 rdpTransport* transport = freerdp_get_transport(context);
731 rdpTransportLayer* layer =
732 transport_connect_layer(transport, channel->client->host, channel->client->port, timeout);
733
734 if (!layer)
735 return FALSE;
736
737 BIO* layerBio = BIO_new(BIO_s_transport_layer());
738 if (!layerBio)
739 {
740 transport_layer_free(layer);
741 return FALSE;
742 }
743 BIO_set_data(layerBio, layer);
744
745 BIO* bufferedBio = BIO_new(BIO_s_buffered_socket());
746 if (!bufferedBio)
747 {
748 BIO_free_all(layerBio);
749 return FALSE;
750 }
751
752 bufferedBio = BIO_push(bufferedBio, layerBio);
753
754 if (!BIO_set_nonblock(bufferedBio, TRUE))
755 {
756 BIO_free_all(bufferedBio);
757 return FALSE;
758 }
759
760 if (channel->client->isProxy)
761 {
762 WINPR_ASSERT(settings->GatewayPort <= UINT16_MAX);
763 if (!proxy_connect(context, bufferedBio, proxyUsername, proxyPassword,
764 settings->GatewayHostname, (UINT16)settings->GatewayPort))
765 {
766 BIO_free_all(bufferedBio);
767 return FALSE;
768 }
769 }
770
771 channel->bio = bufferedBio;
772 rdpTls* tls = channel->tls = freerdp_tls_new(context);
773
774 if (!tls)
775 return FALSE;
776
777 tls->hostname = settings->GatewayHostname;
778 tls->port = WINPR_ASSERTING_INT_CAST(int32_t, MIN(UINT16_MAX, settings->GatewayPort));
779 tls->isGatewayTransport = TRUE;
780 int tlsStatus = freerdp_tls_connect(tls, bufferedBio);
781
782 if (tlsStatus < 1)
783 {
784 if (tlsStatus < 0)
785 {
786 freerdp_set_last_error_if_not(context, FREERDP_ERROR_TLS_CONNECT_FAILED);
787 }
788 else
789 {
790 freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_CANCELLED);
791 }
792
793 return FALSE;
794 }
795
796 return TRUE;
797}
798
799static int rpc_in_channel_connect(RpcInChannel* inChannel, UINT32 timeout)
800{
801 rdpContext* context = nullptr;
802
803 if (!inChannel || !inChannel->common.client || !inChannel->common.client->context)
804 return -1;
805
806 context = inChannel->common.client->context;
807
808 /* Connect IN Channel */
809
810 if (!rpc_channel_tls_connect(&inChannel->common, timeout))
811 return -1;
812
813 rpc_in_channel_transition_to_state(inChannel, CLIENT_IN_CHANNEL_STATE_CONNECTED);
814
815 if (!rpc_ncacn_http_auth_init(context, &inChannel->common))
816 return -1;
817
818 /* Send IN Channel Request */
819
820 if (!rpc_ncacn_http_send_in_channel_request(&inChannel->common))
821 {
822 WLog_Print(inChannel->common.rpc->log, WLOG_ERROR,
823 "rpc_ncacn_http_send_in_channel_request failure");
824 return -1;
825 }
826
827 if (!rpc_in_channel_transition_to_state(inChannel, CLIENT_IN_CHANNEL_STATE_SECURITY))
828 return -1;
829
830 return 1;
831}
832
833static int rpc_out_channel_connect(RpcOutChannel* outChannel, UINT32 timeout)
834{
835 rdpContext* context = nullptr;
836
837 if (!outChannel || !outChannel->common.client || !outChannel->common.client->context)
838 return -1;
839
840 context = outChannel->common.client->context;
841
842 /* Connect OUT Channel */
843
844 if (!rpc_channel_tls_connect(&outChannel->common, timeout))
845 return -1;
846
847 rpc_out_channel_transition_to_state(outChannel, CLIENT_OUT_CHANNEL_STATE_CONNECTED);
848
849 if (!rpc_ncacn_http_auth_init(context, &outChannel->common))
850 return FALSE;
851
852 /* Send OUT Channel Request */
853
854 if (!rpc_ncacn_http_send_out_channel_request(&outChannel->common, FALSE))
855 {
856 WLog_Print(outChannel->common.rpc->log, WLOG_ERROR,
857 "rpc_ncacn_http_send_out_channel_request failure");
858 return FALSE;
859 }
860
861 rpc_out_channel_transition_to_state(outChannel, CLIENT_OUT_CHANNEL_STATE_SECURITY);
862 return 1;
863}
864
865int rpc_out_channel_replacement_connect(RpcOutChannel* outChannel, uint32_t timeout)
866{
867 rdpContext* context = nullptr;
868
869 if (!outChannel || !outChannel->common.client || !outChannel->common.client->context)
870 return -1;
871
872 context = outChannel->common.client->context;
873
874 /* Connect OUT Channel */
875
876 if (!rpc_channel_tls_connect(&outChannel->common, timeout))
877 return -1;
878
879 rpc_out_channel_transition_to_state(outChannel, CLIENT_OUT_CHANNEL_STATE_CONNECTED);
880
881 if (!rpc_ncacn_http_auth_init(context, (RpcChannel*)outChannel))
882 return FALSE;
883
884 /* Send OUT Channel Request */
885
886 if (!rpc_ncacn_http_send_out_channel_request(&outChannel->common, TRUE))
887 {
888 WLog_Print(outChannel->common.rpc->log, WLOG_ERROR,
889 "rpc_ncacn_http_send_out_channel_request failure");
890 return FALSE;
891 }
892
893 rpc_out_channel_transition_to_state(outChannel, CLIENT_OUT_CHANNEL_STATE_SECURITY);
894 return 1;
895}
896
897BOOL rpc_connect(rdpRpc* rpc, UINT32 timeout)
898{
899 RpcInChannel* inChannel = nullptr;
900 RpcOutChannel* outChannel = nullptr;
901 RpcVirtualConnection* connection = nullptr;
902 rpc->VirtualConnection = rpc_virtual_connection_new(rpc);
903
904 if (!rpc->VirtualConnection)
905 return FALSE;
906
907 connection = rpc->VirtualConnection;
908 inChannel = connection->DefaultInChannel;
909 outChannel = connection->DefaultOutChannel;
910 rpc_virtual_connection_transition_to_state(rpc, connection, VIRTUAL_CONNECTION_STATE_INITIAL);
911
912 if (rpc_in_channel_connect(inChannel, timeout) < 0)
913 return FALSE;
914
915 if (rpc_out_channel_connect(outChannel, timeout) < 0)
916 return FALSE;
917
918 return TRUE;
919}
920
921rdpRpc* rpc_new(rdpTransport* transport)
922{
923 rdpContext* context = transport_get_context(transport);
924 rdpRpc* rpc = nullptr;
925
926 WINPR_ASSERT(context);
927
928 rpc = (rdpRpc*)calloc(1, sizeof(rdpRpc));
929
930 if (!rpc)
931 return nullptr;
932
933 rpc->log = WLog_Get(TAG);
934 rpc->State = RPC_CLIENT_STATE_INITIAL;
935 rpc->transport = transport;
936 rpc->SendSeqNum = 0;
937 rpc->auth = credssp_auth_new(context);
938
939 if (!rpc->auth)
940 goto out_free;
941
942 rpc->PipeCallId = 0;
943 rpc->StubCallId = 0;
944 rpc->StubFragCount = 0;
945 rpc->rpc_vers = 5;
946 rpc->rpc_vers_minor = 0;
947 /* little-endian data representation */
948 rpc->packed_drep[0] = 0x10;
949 rpc->packed_drep[1] = 0x00;
950 rpc->packed_drep[2] = 0x00;
951 rpc->packed_drep[3] = 0x00;
952 rpc->max_xmit_frag = 0x0FF8;
953 rpc->max_recv_frag = 0x0FF8;
954 rpc->ReceiveWindow = 0x00010000;
955 rpc->ChannelLifetime = 0x40000000;
956 rpc->KeepAliveInterval = 300000;
957 rpc->CurrentKeepAliveInterval = rpc->KeepAliveInterval;
958 rpc->CurrentKeepAliveTime = 0;
959 rpc->CallId = 2;
960 rpc->client = rpc_client_new(context, rpc->max_recv_frag);
961
962 if (!rpc->client)
963 goto out_free;
964
965 return rpc;
966out_free:
967 WINPR_PRAGMA_DIAG_PUSH
968 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
969 rpc_free(rpc);
970 WINPR_PRAGMA_DIAG_POP
971 return nullptr;
972}
973
974void rpc_free(rdpRpc* rpc)
975{
976 if (rpc)
977 {
978 rpc_client_free(rpc->client);
979 credssp_auth_free(rpc->auth);
980 rpc_virtual_connection_free(rpc->VirtualConnection);
981 free(rpc);
982 }
983}
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.
rpcconn_common_hdr_t
Definition libfreerdp/core/gateway/rpc.h:40
rpcconn_hdr_t
Definition libfreerdp/core/gateway/rpc.h:538