FreeRDP
Loading...
Searching...
No Matches
rdpear_main.c
1
19#include <krb5.h>
20#include <errno.h>
21
22#include <winpr/assert.h>
23#include <winpr/wtypes.h>
24
25#include <winpr/crt.h>
26#include <winpr/wlog.h>
27#include <winpr/print.h>
28#include <winpr/asn1.h>
29#include <winpr/sspi.h>
30#include <winpr/collections.h>
31#include <winpr/ndr.h>
32
33#include <rdpear-common/rdpear_common.h>
34#include <rdpear-common/rdpear_asn1.h>
35
36#include <freerdp/config.h>
37#include <freerdp/freerdp.h>
38#include <freerdp/addin.h>
39#include <freerdp/client/channels.h>
40#include <freerdp/channels/log.h>
41#include <freerdp/channels/rdpear.h>
42
43#define TAG CHANNELS_TAG("rdpear.client")
44
45#ifndef MAX_KEYTAB_NAME_LEN
46#define MAX_KEYTAB_NAME_LEN 1100 /* Defined in MIT krb5.h */
47#endif
48
49/* defined in libkrb5 */
50krb5_error_code encode_krb5_authenticator(const krb5_authenticator* rep, krb5_data** code_out);
51krb5_error_code encode_krb5_ap_rep(const krb5_ap_rep* rep, krb5_data** code_out);
52
53typedef struct
54{
56 rdpContext* rdp_context;
57 krb5_context krbContext;
58} RDPEAR_PLUGIN;
59
60static const BYTE payloadHeader[16] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
61 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
62
63static krb5_error_code RPC_ENCRYPTION_KEY_to_keyblock(krb5_context ctx,
64 const KERB_RPC_ENCRYPTION_KEY* key,
65 krb5_keyblock** pkeyblock)
66{
67 WINPR_ASSERT(ctx);
68 WINPR_ASSERT(key);
69 WINPR_ASSERT(pkeyblock);
70
71 if (!key->reserved3.length)
72 return KRB5KDC_ERR_NULL_KEY;
73
74 krb5_error_code rv =
75 krb5_init_keyblock(ctx, (krb5_enctype)key->reserved2, key->reserved3.length, pkeyblock);
76 if (rv)
77 return rv;
78
79 krb5_keyblock* keyblock = *pkeyblock;
80 memcpy(keyblock->contents, key->reserved3.value, key->reserved3.length);
81 return rv;
82}
83
85static BOOL rdpear_set_asn1_buffer(KERB_ASN1_DATA* asn1, const void* data, size_t len)
86{
87 WINPR_ASSERT(asn1);
88
89 if (len > UINT32_MAX)
90 return FALSE;
91
92 const WinPrNdrArrayHints hints = { (UINT32)len };
93 BYTE* buffer = winpr_ndr_pointer_new(winpr_ndr_uint8Array_descr(), &hints, len);
94 if (!buffer)
95 return FALSE;
96
97 if (len)
98 memcpy(buffer, data, len);
99 asn1->Asn1Buffer = buffer;
100 asn1->Asn1BufferHints = hints;
101 return TRUE;
102}
103
104static krb5_error_code kerb_do_checksum(krb5_context ctx, const KERB_RPC_ENCRYPTION_KEY* key,
105 krb5_keyusage kusage, krb5_cksumtype cksumtype,
106 const KERB_ASN1_DATA* plain, krb5_checksum* out)
107{
108 WINPR_ASSERT(ctx);
109 WINPR_ASSERT(key);
110 WINPR_ASSERT(plain);
111 WINPR_ASSERT(out);
112
113 krb5_keyblock* keyblock = nullptr;
114 krb5_data data = WINPR_C_ARRAY_INIT;
115
116 krb5_error_code rv = RPC_ENCRYPTION_KEY_to_keyblock(ctx, key, &keyblock);
117 if (rv)
118 return rv;
119
120 data.data = (char*)plain->Asn1Buffer;
121 data.length = plain->Asn1BufferHints.count;
122
123 rv = krb5_c_make_checksum(ctx, cksumtype, keyblock, kusage, &data, out);
124
125 krb5_free_keyblock(ctx, keyblock);
126 return rv;
127}
128
129static krb5_error_code kerb_do_encrypt(krb5_context ctx, const KERB_RPC_ENCRYPTION_KEY* key,
130 krb5_keyusage kusage, const KERB_ASN1_DATA* plain,
131 krb5_data* out)
132{
133 WINPR_ASSERT(ctx);
134 WINPR_ASSERT(key);
135 WINPR_ASSERT(plain);
136 WINPR_ASSERT(out);
137
138 out->data = nullptr;
139 out->length = 0;
140
141 krb5_keyblock* keyblock = nullptr;
142 krb5_data data = WINPR_C_ARRAY_INIT;
143 krb5_enc_data enc = WINPR_C_ARRAY_INIT;
144 size_t elen = 0;
145
146 krb5_error_code rv = RPC_ENCRYPTION_KEY_to_keyblock(ctx, key, &keyblock);
147 if (rv)
148 return rv;
149
150 data.data = (char*)plain->Asn1Buffer;
151 data.length = plain->Asn1BufferHints.count;
152
153 rv = krb5_c_encrypt_length(ctx, keyblock->enctype, data.length, &elen);
154 if (rv)
155 goto out;
156 if (!elen || (elen > UINT32_MAX))
157 {
158 rv = KRB5_PARSE_MALFORMED;
159 goto out;
160 }
161 enc.ciphertext.length = (unsigned int)elen;
162 enc.ciphertext.data = malloc(elen);
163 if (!enc.ciphertext.data)
164 {
165 rv = ENOMEM;
166 goto out;
167 }
168
169 rv = krb5_c_encrypt(ctx, keyblock, kusage, nullptr, &data, &enc);
170 if (rv)
171 {
172 free(enc.ciphertext.data);
173 goto out;
174 }
175
176 out->data = enc.ciphertext.data;
177 out->length = enc.ciphertext.length;
178out:
179 krb5_free_keyblock(ctx, keyblock);
180 return rv;
181}
182
183static krb5_error_code kerb_do_decrypt(krb5_context ctx, const KERB_RPC_ENCRYPTION_KEY* key,
184 krb5_keyusage kusage, const krb5_data* cipher,
185 KERB_ASN1_DATA* plain)
186{
187 WINPR_ASSERT(ctx);
188 WINPR_ASSERT(key);
189 WINPR_ASSERT(cipher);
190 WINPR_ASSERT(cipher->length);
191 WINPR_ASSERT(plain);
192
193 plain->Asn1Buffer = nullptr;
194 plain->Asn1BufferHints.count = 0;
195
196 krb5_keyblock* keyblock = nullptr;
197 krb5_data data = WINPR_C_ARRAY_INIT;
198 krb5_enc_data enc = WINPR_C_ARRAY_INIT;
199
200 krb5_error_code rv = RPC_ENCRYPTION_KEY_to_keyblock(ctx, key, &keyblock);
201 if (rv)
202 return rv;
203
204 enc.kvno = KRB5_PVNO;
205 enc.enctype = (krb5_enctype)key->reserved2;
206 enc.ciphertext.length = cipher->length;
207 enc.ciphertext.data = cipher->data;
208
209 data.length = cipher->length;
210 data.data = (char*)malloc(cipher->length);
211 if (!data.data)
212 {
213 rv = ENOMEM;
214 goto out;
215 }
216
217 rv = krb5_c_decrypt(ctx, keyblock, kusage, nullptr, &enc, &data);
218 if (!rv && !rdpear_set_asn1_buffer(plain, data.data, data.length))
219 rv = ENOMEM;
220 free(data.data);
221out:
222 krb5_free_keyblock(ctx, keyblock);
223 return rv;
224}
225
226static BOOL rdpear_send_payload(RDPEAR_PLUGIN* rdpear, IWTSVirtualChannelCallback* pChannelCallback,
227 RdpEarPackageType packageType, wStream* payload)
228{
229 GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
230 BOOL ret = FALSE;
231 wStream* finalStream = nullptr;
232 SecBuffer cryptedBuffer = WINPR_C_ARRAY_INIT;
233 wStream* unencodedContent = rdpear_encodePayload(packageType, payload);
234 if (!unencodedContent)
235 goto out;
236
237 const size_t unencodedLen = Stream_GetPosition(unencodedContent);
238
239#if UINT32_MAX < SIZE_MAX
240 if (unencodedLen > UINT32_MAX)
241 goto out;
242#endif
243
244 SecBuffer inBuffer = { (ULONG)unencodedLen, SECBUFFER_DATA, Stream_Buffer(unencodedContent) };
245
246 if (!freerdp_nla_encrypt(rdpear->rdp_context, &inBuffer, &cryptedBuffer))
247 goto out;
248
249 finalStream = Stream_New(nullptr, 200);
250 if (!finalStream)
251 goto out;
252 Stream_Write_UINT32(finalStream, 0x4EACC3C8); /* ProtocolMagic (4 bytes) */
253 Stream_Write_UINT32(finalStream, cryptedBuffer.cbBuffer); /* Length (4 bytes) */
254 Stream_Write_UINT32(finalStream, 0x00000000); /* Version (4 bytes) */
255 Stream_Write_UINT32(finalStream, 0x00000000); /* Reserved (4 bytes) */
256 Stream_Write_UINT64(finalStream, 0); /* TsPkgContext (8 bytes) */
257
258 /* payload */
259 if (!Stream_EnsureRemainingCapacity(finalStream, cryptedBuffer.cbBuffer))
260 goto out;
261
262 Stream_Write(finalStream, cryptedBuffer.pvBuffer, cryptedBuffer.cbBuffer);
263
264 const size_t pos = Stream_GetPosition(finalStream);
265#if UINT32_MAX < SIZE_MAX
266 if (pos > UINT32_MAX)
267 goto out;
268#endif
269
270 UINT status = callback->channel->Write(callback->channel, (ULONG)pos,
271 Stream_Buffer(finalStream), nullptr);
272 ret = (status == CHANNEL_RC_OK);
273 if (!ret)
274 WLog_DBG(TAG, "rdpear_send_payload=0x%x", status);
275out:
276 sspi_SecBufferFree(&cryptedBuffer);
277 Stream_Free(unencodedContent, TRUE);
278 Stream_Free(finalStream, TRUE);
279 return ret;
280}
281
282static UINT32 rdpear_kerb_version(UINT32 maxVersion, UINT32* pversion)
283{
284 WLog_DBG(TAG, "-> KerbNegotiateVersion(v=0x%x)", maxVersion);
285 *pversion = 0;
286 return 0;
287}
288
289static UINT32 rdpear_kerb_ComputeTgsChecksum(RDPEAR_PLUGIN* rdpear,
290 const ComputeTgsChecksumReq* req, KERB_ASN1_DATA* resp)
291{
292 krb5_checksum checksum = WINPR_C_ARRAY_INIT;
293 wStream* asn1Payload = nullptr;
294
295 UINT32 status = ERROR_INVALID_DATA;
296 WLog_DBG(TAG, "-> ComputeTgsChecksum");
297
298 krb5_error_code rv =
299 kerb_do_checksum(rdpear->krbContext, req->Key, KRB5_KEYUSAGE_TGS_REQ_AUTH_CKSUM,
300 (krb5_cksumtype)req->ChecksumType, req->requestBody, &checksum);
301 if (rv)
302 goto out;
303
304 asn1Payload = rdpear_enc_Checksum(req->ChecksumType, &checksum);
305 if (!asn1Payload)
306 goto out;
307
308 resp->Pdu = 8;
309 if (!rdpear_set_asn1_buffer(resp, Stream_Buffer(asn1Payload), Stream_GetPosition(asn1Payload)))
310 goto out;
311 status = 0;
312
313out:
314 krb5_free_checksum_contents(rdpear->krbContext, &checksum);
315 Stream_Free(asn1Payload, TRUE);
316 return status;
317}
318
319static UINT32 rdpear_kerb_BuildEncryptedAuthData(RDPEAR_PLUGIN* rdpear,
320 const BuildEncryptedAuthDataReq* req,
321 KERB_ASN1_DATA* asn1)
322{
323 krb5_data encrypted = WINPR_C_ARRAY_INIT;
324 wStream* asn1Payload = nullptr;
325 krb5_error_code rv = 0;
326
327 UINT32 status = ERROR_INVALID_DATA;
328 WLog_DBG(TAG, "-> BuildEncryptedAuthData");
329
330 rv = kerb_do_encrypt(rdpear->krbContext, req->Key, (krb5_keyusage)req->KeyUsage,
331 req->PlainAuthData, &encrypted);
332 if (rv)
333 goto out;
334
335 /* do the encoding */
336 asn1Payload = rdpear_enc_EncryptedData(req->Key->reserved2, &encrypted);
337 if (!asn1Payload)
338 goto out;
339
340 // WLog_DBG(TAG, "rdpear_kerb_BuildEncryptedAuthData resp=");
341 // winpr_HexDump(TAG, WLOG_DEBUG, Stream_Buffer(asn1Payload), Stream_GetPosition(asn1Payload));
342 asn1->Pdu = 6;
343 if (!rdpear_set_asn1_buffer(asn1, Stream_Buffer(asn1Payload), Stream_GetPosition(asn1Payload)))
344 goto out;
345 status = 0;
346
347out:
348 krb5_free_data_contents(rdpear->krbContext, &encrypted);
349 Stream_Free(asn1Payload, TRUE);
350 return status;
351}
352
353static char* KERB_RPC_UNICODESTR_to_charptr(const RPC_UNICODE_STRING* src)
354{
355 WINPR_ASSERT(src);
356 return ConvertWCharNToUtf8Alloc(src->Buffer, src->strLength, nullptr);
357}
358
359static BOOL extractAuthData(const KERB_ASN1_DATA* src, krb5_authdata* authData, BOOL* haveData)
360{
361 WinPrAsn1Decoder dec = WINPR_C_ARRAY_INIT;
362 WinPrAsn1Decoder dec2 = WINPR_C_ARRAY_INIT;
363 WinPrAsn1Decoder dec3 = WINPR_C_ARRAY_INIT;
364 WinPrAsn1Decoder_InitMem(&dec, WINPR_ASN1_DER, src->Asn1Buffer, src->Asn1BufferHints.count);
365 BOOL error = FALSE;
366 WinPrAsn1_INTEGER adType = 0;
367 WinPrAsn1_OctetString os = WINPR_C_ARRAY_INIT;
368
369 *haveData = FALSE;
370 if (!WinPrAsn1DecReadSequence(&dec, &dec2))
371 return FALSE;
372
373 wStream subStream = WinPrAsn1DecGetStream(&dec2);
374 if (!Stream_GetRemainingLength(&subStream))
375 return TRUE;
376
377 if (!WinPrAsn1DecReadSequence(&dec2, &dec3))
378 return FALSE;
379
380 if (!WinPrAsn1DecReadContextualInteger(&dec3, 0, &error, &adType) ||
381 !WinPrAsn1DecReadContextualOctetString(&dec3, 1, &error, &os, FALSE))
382 return FALSE;
383
384 if (os.len > UINT32_MAX)
385 return FALSE;
386
387 authData->ad_type = adType;
388 authData->length = (unsigned int)os.len;
389 authData->contents = os.data;
390 *haveData = TRUE;
391 return TRUE;
392}
393
394static BOOL extractChecksum(const KERB_ASN1_DATA* src, krb5_checksum* dst)
395{
396 WinPrAsn1Decoder dec = WINPR_C_ARRAY_INIT;
397 WinPrAsn1Decoder dec2 = WINPR_C_ARRAY_INIT;
398 WinPrAsn1Decoder_InitMem(&dec, WINPR_ASN1_DER, src->Asn1Buffer, src->Asn1BufferHints.count);
399 BOOL error = FALSE;
400 WinPrAsn1_OctetString os;
401
402 if (!WinPrAsn1DecReadSequence(&dec, &dec2))
403 return FALSE;
404
405 WinPrAsn1_INTEGER cksumtype = 0;
406 if (!WinPrAsn1DecReadContextualInteger(&dec2, 0, &error, &cksumtype) ||
407 !WinPrAsn1DecReadContextualOctetString(&dec2, 1, &error, &os, FALSE))
408 return FALSE;
409
410 if (os.len > UINT32_MAX)
411 return FALSE;
412 dst->checksum_type = cksumtype;
413 dst->length = (unsigned int)os.len;
414 dst->contents = os.data;
415 return TRUE;
416}
417
418#define FILETIME_TO_UNIX_OFFSET_S 11644473600LL
419
420static LONGLONG krb5_time_to_FILETIME(const krb5_timestamp* ts, krb5_int32 usec)
421{
422 WINPR_ASSERT(ts);
423 return (((*ts + FILETIME_TO_UNIX_OFFSET_S) * (1000LL * 1000LL) + usec) * 10LL);
424}
425
426static void krb5_free_principal_contents(krb5_context ctx, krb5_principal principal)
427{
428 WINPR_ASSERT(principal);
429 krb5_free_data_contents(ctx, &principal->realm);
430 krb5_free_data(ctx, principal->data);
431}
432
433static UINT32 rdpear_kerb_CreateApReqAuthenticator(RDPEAR_PLUGIN* rdpear,
436{
437 krb5_error_code rv = 0;
438 wStream* asn1EncodedAuth = nullptr;
439 krb5_data authenticator = WINPR_C_ARRAY_INIT;
440 krb5_data* der = nullptr;
441 krb5_keyblock* subkey = nullptr;
442 krb5_principal_data client = WINPR_C_ARRAY_INIT;
443
444 UINT32 status = ERROR_INVALID_DATA;
445 WLog_DBG(TAG, "-> CreateApReqAuthenticator");
446
447 krb5_authdata authdata = WINPR_C_ARRAY_INIT;
448 krb5_authdata* authDataPtr[2] = { &authdata, nullptr };
449 BOOL haveData = 0;
450
451 if (!extractAuthData(req->AuthData, &authdata, &haveData))
452 {
453 WLog_ERR(TAG, "error retrieving auth data");
454 winpr_HexDump(TAG, WLOG_DEBUG, req->AuthData->Asn1Buffer,
455 req->AuthData->Asn1BufferHints.count);
456 goto out;
457 }
458
459 if (req->SkewTime->QuadPart)
460 {
461 WLog_ERR(TAG, "!!!!! should handle SkewTime !!!!!");
462 }
463
464 if (req->SubKey)
465 {
466 rv = RPC_ENCRYPTION_KEY_to_keyblock(rdpear->krbContext, req->SubKey, &subkey);
467 if (rv)
468 {
469 WLog_ERR(TAG, "error importing subkey");
470 goto out;
471 }
472 }
473
474 krb5_authenticator authent = { .checksum = nullptr,
475 .subkey = nullptr,
476 .seq_number = req->SequenceNumber,
477 .authorization_data = haveData ? authDataPtr : nullptr };
478
479 client.type = req->ClientName->NameType;
480 if (req->ClientName->nameHints.count > INT32_MAX)
481 goto out;
482
483 client.length = (krb5_int32)req->ClientName->nameHints.count;
484 client.data = calloc(req->ClientName->nameHints.count, sizeof(krb5_data));
485 if (!client.data)
486 goto out;
487
488 for (int i = 0; i < client.length; i++)
489 {
490 krb5_data* cur = &client.data[i];
491 cur->data = KERB_RPC_UNICODESTR_to_charptr(&req->ClientName->Names[i]);
492 if (!cur->data)
493 goto out;
494 const size_t len = strnlen(cur->data, MAX_KEYTAB_NAME_LEN + 1);
495 if (len > MAX_KEYTAB_NAME_LEN)
496 {
497 WLog_ERR(TAG,
498 "Invalid ClientName length %d, limited to %" PRIuz
499 " characters. ClientName: (%s)",
500 MAX_KEYTAB_NAME_LEN, len, cur->data);
501 goto out;
502 }
503 cur->length = (unsigned int)len;
504 }
505 client.realm.data = KERB_RPC_UNICODESTR_to_charptr(req->ClientRealm);
506 if (!client.realm.data)
507 goto out;
508
509 const size_t len = strnlen(client.realm.data, MAX_KEYTAB_NAME_LEN + 1);
510 if (len > MAX_KEYTAB_NAME_LEN)
511 {
512 WLog_ERR(TAG, "Invalid realm length %d, limited to %" PRIuz "characters. Realm: (%s)",
513 MAX_KEYTAB_NAME_LEN, len, client.realm.data);
514 goto out;
515 }
516 client.realm.length = (unsigned int)len;
517 authent.client = &client;
518
519 krb5_checksum checksum;
520 krb5_checksum* pchecksum = nullptr;
521 if (req->GssChecksum)
522 {
523 if (!extractChecksum(req->GssChecksum, &checksum))
524 {
525 WLog_ERR(TAG, "Error getting the checksum");
526 goto out;
527 }
528 pchecksum = &checksum;
529 }
530 authent.checksum = pchecksum;
531
532 krb5_us_timeofday(rdpear->krbContext, &authent.ctime, &authent.cusec);
533
534 rv = encode_krb5_authenticator(&authent, &der);
535 if (rv)
536 {
537 WLog_ERR(TAG, "error encoding authenticator");
538 goto out;
539 }
540
541 KERB_ASN1_DATA plain_authent = { .Pdu = 0,
542 .Asn1Buffer = (BYTE*)der->data,
543 .Asn1BufferHints = { .count = der->length } };
544
545 rv = kerb_do_encrypt(rdpear->krbContext, req->EncryptionKey, (krb5_keyusage)req->KeyUsage,
546 &plain_authent, &authenticator);
547 if (rv)
548 {
549 WLog_ERR(TAG, "error encrypting authenticator");
550 goto out;
551 }
552
553 asn1EncodedAuth = rdpear_enc_EncryptedData(req->EncryptionKey->reserved2, &authenticator);
554 if (!asn1EncodedAuth)
555 {
556 WLog_ERR(TAG, "error encoding to ASN1");
557 rv = ENOMEM;
558 goto out;
559 }
560
561 // WLog_DBG(TAG, "authenticator=");
562 // winpr_HexDump(TAG, WLOG_DEBUG, Stream_Buffer(asn1EncodedAuth),
563 // Stream_GetPosition(asn1EncodedAuth));
564
565 if (!rdpear_set_asn1_buffer(&resp->Authenticator, Stream_Buffer(asn1EncodedAuth),
566 Stream_GetPosition(asn1EncodedAuth)))
567 goto out;
568 resp->AuthenticatorTime.QuadPart = krb5_time_to_FILETIME(&authent.ctime, authent.cusec);
569 status = 0;
570
571out:
572 /* Pdu is the slot of EncryptedData in the host's compiled Kerberos ASN.1 module: 6 up to
573 * Server 2022, 7 from Windows 11 24H2 / Server 2025, and an updated host rejects a mismatch.
574 * The host labels its GSS checksum with its own Checksum slot: 8 on the older module, blank
575 * on the newer one. */
576 resp->Authenticator.Pdu = (req->GssChecksum && (req->GssChecksum->Pdu == 8)) ? 6 : 7;
577 WLog_VRB(TAG, "host checksum PDU %" PRIu32 " -> authenticator PDU %" PRIu32,
578 req->GssChecksum ? req->GssChecksum->Pdu : 0, resp->Authenticator.Pdu);
579 resp->KerbProtocolError = rv;
580 krb5_free_principal_contents(rdpear->krbContext, &client);
581 krb5_free_data(rdpear->krbContext, der);
582 krb5_free_data_contents(rdpear->krbContext, &authenticator);
583 if (subkey)
584 krb5_free_keyblock(rdpear->krbContext, subkey);
585 Stream_Free(asn1EncodedAuth, TRUE);
586 return status;
587}
588
589static BOOL rdpear_findEncryptedData(const KERB_ASN1_DATA* src, int* penctype, krb5_data* data)
590{
591 WinPrAsn1Decoder dec = WINPR_C_ARRAY_INIT;
592 WinPrAsn1Decoder dec2 = WINPR_C_ARRAY_INIT;
593 WinPrAsn1Decoder_InitMem(&dec, WINPR_ASN1_DER, src->Asn1Buffer, src->Asn1BufferHints.count);
594 BOOL error = FALSE;
595 WinPrAsn1_INTEGER encType = 0;
596 WinPrAsn1_OctetString os = WINPR_C_ARRAY_INIT;
597
598 if (!WinPrAsn1DecReadSequence(&dec, &dec2) ||
599 !WinPrAsn1DecReadContextualInteger(&dec2, 0, &error, &encType) ||
600 !WinPrAsn1DecReadContextualOctetString(&dec2, 2, &error, &os, FALSE))
601 return FALSE;
602
603 if (os.len > UINT32_MAX)
604 return FALSE;
605 data->data = (char*)os.data;
606 data->length = (unsigned int)os.len;
607 *penctype = encType;
608 return TRUE;
609}
610
611static UINT32 rdpear_kerb_UnpackKdcReplyBody(RDPEAR_PLUGIN* rdpear,
612 const UnpackKdcReplyBodyReq* req,
614{
615 if (req->StrengthenKey)
616 {
617 WLog_ERR(TAG, "StrengthenKey not supported yet");
618 return ERROR_INVALID_DATA;
619 }
620
621 WLog_DBG(TAG, "-> UnpackKdcReplyBody: KeyUsage=0x%x PDU=0x%x", req->KeyUsage, req->Pdu);
622 // WLog_DBG(TAG, "encryptedPayload=");
623 // winpr_HexDump(TAG, WLOG_DEBUG, req->EncryptedData->Asn1Buffer,
624 // req->EncryptedData->Asn1BufferHints.count);
625
626 krb5_data asn1Data = WINPR_C_ARRAY_INIT;
627 int encType = 0;
628 if (!rdpear_findEncryptedData(req->EncryptedData, &encType, &asn1Data) || !asn1Data.length)
629 return ERROR_INVALID_DATA;
630
631 resp->KerbProtocolError = kerb_do_decrypt(
632 rdpear->krbContext, req->Key, (krb5_keyusage)req->KeyUsage, &asn1Data, &resp->ReplyBody);
633 resp->ReplyBody.Pdu = req->Pdu;
634
635 return 0;
636}
637
638static UINT32 rdpear_kerb_DecryptApReply(RDPEAR_PLUGIN* rdpear, const DecryptApReplyReq* req,
639 KERB_ASN1_DATA* resp)
640{
641 WLog_DBG(TAG, "-> DecryptApReply");
642 // winpr_HexDump(TAG, WLOG_DEBUG, req->EncryptedReply->Asn1Buffer,
643 // req->EncryptedReply->Asn1BufferHints.count);
644
645 krb5_data asn1Data = WINPR_C_ARRAY_INIT;
646 int encType = 0;
647 if (!rdpear_findEncryptedData(req->EncryptedReply, &encType, &asn1Data) || !asn1Data.length)
648 return ERROR_INVALID_DATA;
649
650 resp->Pdu = 0x31;
651 krb5_error_code rv = kerb_do_decrypt(rdpear->krbContext, req->Key, KRB5_KEYUSAGE_AP_REP_ENCPART,
652 &asn1Data, resp);
653 if (rv != 0)
654 {
655 WLog_ERR(TAG, "error decrypting");
656 return ERROR_INVALID_DATA;
657 }
658
659 // WLog_DBG(TAG, "response=");
660 // winpr_HexDump(TAG, WLOG_DEBUG, resp->Asn1Buffer, resp->Asn1BufferHints.count);
661 return 0;
662}
663
664static UINT32 rdpear_kerb_PackApReply(RDPEAR_PLUGIN* rdpear, const PackApReplyReq* req,
665 PackApReplyResp* resp)
666{
667 UINT32 status = ERROR_INVALID_DATA;
668 krb5_data asn1Data = WINPR_C_ARRAY_INIT;
669 krb5_data* out = nullptr;
670
671 WLog_DBG(TAG, "-> PackApReply");
672
673 krb5_error_code rv = kerb_do_encrypt(rdpear->krbContext, req->SessionKey,
674 KRB5_KEYUSAGE_AP_REP_ENCPART, req->ReplyBody, &asn1Data);
675 if (rv)
676 goto out;
677
678 krb5_ap_rep reply;
679 reply.enc_part.kvno = KRB5_PVNO;
680 reply.enc_part.enctype = (krb5_enctype)req->SessionKey->reserved2;
681 reply.enc_part.ciphertext.length = asn1Data.length;
682 reply.enc_part.ciphertext.data = asn1Data.data;
683
684 rv = encode_krb5_ap_rep(&reply, &out);
685 if (rv)
686 goto out;
687
688 resp->PackedReplyHints.count = out->length;
689 resp->PackedReply =
690 winpr_ndr_pointer_new(winpr_ndr_uint8Array_descr(), &resp->PackedReplyHints, out->length);
691 if (!resp->PackedReply)
692 goto out;
693 memcpy(resp->PackedReply, out->data, out->length);
694 status = 0;
695out:
696 krb5_free_data(rdpear->krbContext, out);
697 krb5_free_data_contents(rdpear->krbContext, &asn1Data);
698 return status;
699}
700
705static BOOL rdpear_kerb_call(RDPEAR_PLUGIN* rdpear, const KerbCredIsoRemoteInput* input,
707{
708 const KerbCredIsoRemoteInputUnion* in = &input->Input;
709 KerbCredIsoRemoteOutputUnion* out = &output->Output;
710
711 output->CallId = input->CallId;
712 switch (input->CallId)
713 {
714 case RemoteCallKerbNegotiateVersion:
715 output->Status = rdpear_kerb_version(in->NegotiateVersion, &out->NegotiateVersion);
716 return TRUE;
717 case RemoteCallKerbCreateApReqAuthenticator:
718 output->Status = rdpear_kerb_CreateApReqAuthenticator(
720 return TRUE;
721 case RemoteCallKerbDecryptApReply:
722 output->Status =
723 rdpear_kerb_DecryptApReply(rdpear, &in->DecryptApReply, &out->DecryptApReply);
724 return TRUE;
725 case RemoteCallKerbComputeTgsChecksum:
726 output->Status = rdpear_kerb_ComputeTgsChecksum(rdpear, &in->ComputeTgsChecksum,
727 &out->ComputeTgsChecksum);
728 return TRUE;
729 case RemoteCallKerbBuildEncryptedAuthData:
730 output->Status = rdpear_kerb_BuildEncryptedAuthData(rdpear, &in->BuildEncryptedAuthData,
732 return TRUE;
733 case RemoteCallKerbUnpackKdcReplyBody:
734 output->Status = rdpear_kerb_UnpackKdcReplyBody(rdpear, &in->UnpackKdcReplyBody,
735 &out->UnpackKdcReplyBody);
736 return TRUE;
737 case RemoteCallKerbPackApReply:
738 output->Status = rdpear_kerb_PackApReply(rdpear, &in->PackApReply, &out->PackApReply);
739 return TRUE;
740 default:
741 WLog_DBG(TAG, "Unhandled Kerberos callId=0x%x", input->CallId);
742 return FALSE;
743 }
744}
745
753static BOOL rdpear_ntlm_call(const NtlmCredIsoRemoteInput* input, NtlmCredIsoRemoteOutput* output)
754{
755 output->CallId = input->CallId;
756 switch (input->CallId)
757 {
758 case RemoteCallNtlmNegotiateVersion:
759 WLog_DBG(TAG, "-> NtlmNegotiateVersion(v=0x%x)", input->Input.NegotiateVersion);
760 output->Output.NegotiateVersion = 0;
761 output->Status = STATUS_SUCCESS;
762 return TRUE;
763 case RemoteCallNtlmLm20GetNtlm3ChallengeResponse:
764 case RemoteCallNtlmCalculateNtResponse:
765 case RemoteCallNtlmCalculateUserSessionKeyNt:
766 case RemoteCallNtlmCompareCredentials:
767 WLog_DBG(TAG, "-> NTLM callId=0x%x: no NTLM credentials", input->CallId);
768 output->Status = (UINT32)STATUS_NOT_SUPPORTED;
769 return TRUE;
770 default:
771 WLog_DBG(TAG, "Unhandled NTLM callId=0x%x", input->CallId);
772 return FALSE;
773 }
774}
775
776static UINT rdpear_decode_payload(RDPEAR_PLUGIN* rdpear, const WinPrAsn1_OctetString* packageName,
777 IWTSVirtualChannelCallback* pChannelCallback, wStream* s)
778{
779 UINT ret = ERROR_INVALID_DATA;
780 WinPrNdrDecoder* decoder = nullptr;
781 WinPrNdrEncoder* encoder = nullptr;
782 KerbCredIsoRemoteInput kerbInput = WINPR_C_ARRAY_INIT;
783 KerbCredIsoRemoteOutput kerbOutput = WINPR_C_ARRAY_INIT;
784 NtlmCredIsoRemoteInput ntlmInput = WINPR_C_ARRAY_INIT;
785 NtlmCredIsoRemoteOutput ntlmOutput = WINPR_C_ARRAY_INIT;
786 BOOL handled = FALSE;
787 BOOL encoded = FALSE;
788
789 const RdpEarPackageType packageType = rdpear_packageType_from_name(packageName);
790 if (packageType == RDPEAR_PACKAGE_UNKNOWN)
791 {
792 WLog_ERR(TAG, "unknown package type");
793 return ERROR_INVALID_DATA;
794 }
795
796 wStream* respStream = Stream_New(nullptr, 500);
797 if (!respStream)
798 return ERROR_INVALID_DATA;
799
800 if (!Stream_CheckAndLogRequiredLength(TAG, s, 16))
801 goto out;
802 Stream_Seek(s, 16); /* skip first 16 bytes */
803
805 if (!decoder)
806 goto out;
807
808 encoder = winpr_ndr_encoder_from_decoder(decoder);
809 if (!encoder)
810 goto out;
811
812 Stream_Write(respStream, payloadHeader, sizeof(payloadHeader));
813
814 if (packageType == RDPEAR_PACKAGE_KERBEROS)
815 {
816 if (!rdpear_kerb_input_read(decoder, s, &kerbInput))
817 goto out;
818
819 handled = rdpear_kerb_call(rdpear, &kerbInput, &kerbOutput);
820 encoded = rdpear_kerb_output_write(encoder, respStream, &kerbOutput);
821 }
822 else
823 {
824 if (!rdpear_ntlm_input_read(decoder, s, &ntlmInput))
825 goto out;
826
827 handled = rdpear_ntlm_call(&ntlmInput, &ntlmOutput);
828 encoded = rdpear_ntlm_output_write(encoder, respStream, &ntlmOutput);
829 }
830
831 if (!encoded)
832 {
833 WLog_DBG(TAG, "error encoding the reply");
834 goto out;
835 }
836
837 if (!rdpear_send_payload(rdpear, pChannelCallback, packageType, respStream))
838 {
839 WLog_DBG(TAG, "rdpear_send_payload !!!!!!!!");
840 goto out;
841 }
842
843 ret = handled ? CHANNEL_RC_OK : CHANNEL_RC_NOT_OPEN;
844out:
845 rdpear_kerb_input_free(&kerbInput);
846 rdpear_kerb_output_free(&kerbOutput);
847 rdpear_ntlm_input_free(&ntlmInput);
848 rdpear_ntlm_output_free(&ntlmOutput);
851 Stream_Free(respStream, TRUE);
852 return ret;
853}
854
855static UINT rdpear_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* s)
856{
857 GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
858 WINPR_ASSERT(callback);
859 UINT ret = ERROR_INVALID_DATA;
860
861 // winpr_HexDump(TAG, WLOG_DEBUG, Stream_PointerAs(s, BYTE), Stream_GetRemainingLength(s));
862
863 if (!Stream_CheckAndLogRequiredLength(TAG, s, 24))
864 return ERROR_INVALID_DATA;
865
866 UINT32 protocolMagic = Stream_Get_UINT32(s);
867 if (protocolMagic != 0x4EACC3C8)
868 return ERROR_INVALID_DATA;
869
870 UINT32 Length = Stream_Get_UINT32(s);
871 UINT32 Version = Stream_Get_UINT32(s);
872 if (Version != 0x00000000)
873 return ERROR_INVALID_DATA;
874
875 Stream_Seek(s, 4); /* Reserved (4 bytes) */
876 Stream_Seek(s, 8); /* TsPkgContext (8 bytes) */
877
878 if (!Stream_CheckAndLogRequiredLength(TAG, s, Length))
879 return ERROR_INVALID_DATA;
880
881 SecBuffer inBuffer = { Length, SECBUFFER_TOKEN, Stream_PointerAs(s, void) };
882 SecBuffer decrypted = WINPR_C_ARRAY_INIT;
883
884 RDPEAR_PLUGIN* rdpear = (RDPEAR_PLUGIN*)callback->plugin;
885 WINPR_ASSERT(rdpear);
886 if (!freerdp_nla_decrypt(rdpear->rdp_context, &inBuffer, &decrypted))
887 goto out;
888
889 WinPrAsn1Decoder dec = WINPR_C_ARRAY_INIT;
890 WinPrAsn1Decoder dec2 = WINPR_C_ARRAY_INIT;
891 wStream decodedStream = WINPR_C_ARRAY_INIT;
892 Stream_StaticInit(&decodedStream, decrypted.pvBuffer, decrypted.cbBuffer);
893 WinPrAsn1Decoder_Init(&dec, WINPR_ASN1_DER, &decodedStream);
894
895 if (!WinPrAsn1DecReadSequence(&dec, &dec2))
896 goto out;
897
898 WinPrAsn1_OctetString packageName = WINPR_C_ARRAY_INIT;
899 WinPrAsn1_OctetString payload = WINPR_C_ARRAY_INIT;
900 BOOL error = 0;
901 if (!WinPrAsn1DecReadContextualOctetString(&dec2, 1, &error, &packageName, FALSE))
902 goto out;
903
904 if (!WinPrAsn1DecReadContextualOctetString(&dec2, 2, &error, &payload, FALSE))
905 goto out;
906
907 wStream payloadStream = WINPR_C_ARRAY_INIT;
908 Stream_StaticInit(&payloadStream, payload.data, payload.len);
909
910 ret = rdpear_decode_payload(rdpear, &packageName, pChannelCallback, &payloadStream);
911out:
912 sspi_SecBufferFree(&decrypted);
913 return ret;
914}
915
921static UINT rdpear_on_open(IWTSVirtualChannelCallback* pChannelCallback)
922{
923 WINPR_UNUSED(pChannelCallback);
924 return CHANNEL_RC_OK;
925}
926
932static UINT rdpear_on_close(IWTSVirtualChannelCallback* pChannelCallback)
933{
934 WINPR_UNUSED(pChannelCallback);
935 return CHANNEL_RC_OK;
936}
937
938static void terminate_plugin_cb(GENERIC_DYNVC_PLUGIN* base)
939{
940 WINPR_ASSERT(base);
941
942 RDPEAR_PLUGIN* rdpear = (RDPEAR_PLUGIN*)base;
943 krb5_free_context(rdpear->krbContext);
944}
945
946static UINT init_plugin_cb(GENERIC_DYNVC_PLUGIN* base, rdpContext* rcontext, rdpSettings* settings)
947{
948 WINPR_ASSERT(base);
949 WINPR_UNUSED(settings);
950
951 RDPEAR_PLUGIN* rdpear = (RDPEAR_PLUGIN*)base;
952 rdpear->rdp_context = rcontext;
953 if (krb5_init_context(&rdpear->krbContext))
954 return CHANNEL_RC_INITIALIZATION_ERROR;
955 return CHANNEL_RC_OK;
956}
957
958static const IWTSVirtualChannelCallback rdpear_callbacks = { rdpear_on_data_received,
959 rdpear_on_open, rdpear_on_close,
960 nullptr };
961
967FREERDP_ENTRY_POINT(UINT rdpear_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints))
968{
969 return freerdp_generic_DVCPluginEntry(pEntryPoints, TAG, RDPEAR_DVC_CHANNEL_NAME,
970 sizeof(RDPEAR_PLUGIN), sizeof(GENERIC_CHANNEL_CALLBACK),
971 &rdpear_callbacks, init_plugin_cb, terminate_plugin_cb);
972}
NDR encoder and decoder ([C706] chapter 14, [MS-RPCE] 2.2.5 and 2.2.6).
static INLINE void winpr_ndr_decoder_destroy(WinPrNdrDecoder **pcontext)
frees a decoder and resets the pointer
Definition ndr.h:657
static INLINE void winpr_ndr_encoder_destroy(WinPrNdrEncoder **pcontext)
frees an encoder and resets the pointer
Definition ndr.h:405
WINPR_API WinPrNdrEncoder * winpr_ndr_encoder_from_decoder(const WinPrNdrDecoder *src)
creates an encoder with the same endianness and version as a decoder, to answer the message it decode...
Definition ndr.c:206
WINPR_API void * winpr_ndr_pointer_new(WinPrNdrMessageType descr, const void *hints, size_t size)
allocates a referent
Definition ndr.c:1454
WINPR_API WinPrNdrDecoder * winpr_ndr_decoder_new_fromStream(wStream *s)
reads the common type header ([MS-RPCE] 2.2.6.1) and creates a decoder for its version and endianness
Definition ndr.c:1124
UINT32 count
Definition ndr.h:554
hints for a conformant array
Definition ndr.h:553
2.2.2.1.8 BuildEncryptedAuthData
2.2.2.1.7 ComputeTgsChecksum
2.2.2.1.4 CreateApReqAuthenticator
2.2.2.1.4 CreateApReqAuthenticator
2.2.1.2.1 KERB_ASN1_DATA
2.2.1.2.8 KERB_RPC_ENCRYPTION_KEY
KerbCredIsoRemoteInputUnion Input
KerbCredIsoRemoteOutputUnion Output
NtlmCredIsoRemoteInputUnion Input
NtlmCredIsoRemoteOutputUnion Output
2.3.10 RPC_UNICODE_STRING (MS-DTYP)
2.2.2.1.6 UnpackKdcReplyBody
2.2.2.1.6 UnpackKdcReplyBody
2.2.1.2.9 KerbCredIsoRemoteInput
CreateApReqAuthenticatorReq CreateApReqAuthenticator
2.2.1.2.10 KerbCredIsoRemoteOutput
CreateApReqAuthenticatorResp CreateApReqAuthenticator
UnpackKdcReplyBodyResp UnpackKdcReplyBody
KERB_ASN1_DATA BuildEncryptedAuthData