Milestone 5: deliver embedded RDP sessions and lifecycle hardening
This commit is contained in:
Keith Smith
572
third_party/FreeRDP/channels/rdpear/common/rdpear_common.c
vendored
Normal file
572
third_party/FreeRDP/channels/rdpear/common/rdpear_common.c
vendored
Normal file
@@ -0,0 +1,572 @@
|
||||
/**
|
||||
* FreeRDP: A Remote Desktop Protocol Implementation
|
||||
*
|
||||
* Copyright 2023 David Fort <contact@hardening-consulting.com>
|
||||
*
|
||||
* 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 <rdpear-common/rdpear_common.h>
|
||||
#include <rdpear-common/rdpear_asn1.h>
|
||||
#include <rdpear-common/ndr.h>
|
||||
|
||||
#include <stddef.h>
|
||||
#include <winpr/print.h>
|
||||
#include <freerdp/channels/log.h>
|
||||
|
||||
#define TAG CHANNELS_TAG("rdpear")
|
||||
|
||||
static char kerberosPackageName[] = {
|
||||
'K', 0, 'e', 0, 'r', 0, 'b', 0, 'e', 0, 'r', 0, 'o', 0, 's', 0
|
||||
};
|
||||
static char ntlmPackageName[] = { 'N', 0, 'T', 0, 'L', 0, 'M', 0 };
|
||||
|
||||
RdpEarPackageType rdpear_packageType_from_name(const WinPrAsn1_OctetString* package)
|
||||
{
|
||||
if (package->len == sizeof(kerberosPackageName) &&
|
||||
memcmp(package->data, kerberosPackageName, package->len) == 0)
|
||||
return RDPEAR_PACKAGE_KERBEROS;
|
||||
|
||||
if (package->len == sizeof(ntlmPackageName) &&
|
||||
memcmp(package->data, ntlmPackageName, package->len) == 0)
|
||||
return RDPEAR_PACKAGE_NTLM;
|
||||
|
||||
return RDPEAR_PACKAGE_UNKNOWN;
|
||||
}
|
||||
|
||||
wStream* rdpear_encodePayload(BOOL isKerb, wStream* payload)
|
||||
{
|
||||
wStream* ret = nullptr;
|
||||
WinPrAsn1Encoder* enc = WinPrAsn1Encoder_New(WINPR_ASN1_DER);
|
||||
if (!enc)
|
||||
return nullptr;
|
||||
|
||||
/* TSRemoteGuardInnerPacket ::= SEQUENCE { */
|
||||
if (!WinPrAsn1EncSeqContainer(enc))
|
||||
goto out;
|
||||
|
||||
/* packageName [1] OCTET STRING */
|
||||
WinPrAsn1_OctetString packageOctetString;
|
||||
if (isKerb)
|
||||
{
|
||||
packageOctetString.data = (BYTE*)kerberosPackageName;
|
||||
packageOctetString.len = sizeof(kerberosPackageName);
|
||||
}
|
||||
else
|
||||
{
|
||||
packageOctetString.data = (BYTE*)ntlmPackageName;
|
||||
packageOctetString.len = sizeof(ntlmPackageName);
|
||||
}
|
||||
|
||||
if (!WinPrAsn1EncContextualOctetString(enc, 1, &packageOctetString))
|
||||
goto out;
|
||||
|
||||
/* buffer [2] OCTET STRING*/
|
||||
WinPrAsn1_OctetString payloadOctetString = { Stream_GetPosition(payload),
|
||||
Stream_Buffer(payload) };
|
||||
if (!WinPrAsn1EncContextualOctetString(enc, 2, &payloadOctetString))
|
||||
goto out;
|
||||
|
||||
/* } */
|
||||
if (!WinPrAsn1EncEndContainer(enc))
|
||||
goto out;
|
||||
|
||||
ret = Stream_New(nullptr, 100);
|
||||
if (!ret)
|
||||
goto out;
|
||||
|
||||
if (!WinPrAsn1EncToStream(enc, ret))
|
||||
{
|
||||
Stream_Free(ret, TRUE);
|
||||
ret = nullptr;
|
||||
goto out;
|
||||
}
|
||||
out:
|
||||
WinPrAsn1Encoder_Free(&enc);
|
||||
return ret;
|
||||
}
|
||||
|
||||
#define RDPEAR_SIMPLE_MESSAGE_TYPE(V) \
|
||||
BOOL ndr_read_##V(NdrContext* context, wStream* s, const void* hints, V* obj) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
return ndr_struct_read_fromDescr(context, s, &V##_struct, obj); \
|
||||
} \
|
||||
BOOL ndr_write_##V(NdrContext* context, wStream* s, const void* hints, const V* obj) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
return ndr_struct_write_fromDescr(context, s, &V##_struct, obj); \
|
||||
} \
|
||||
void ndr_destroy_##V(NdrContext* context, const void* hints, V* obj) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
ndr_struct_destroy(context, &V##_struct, obj); \
|
||||
} \
|
||||
void ndr_dump_##V(wLog* logger, UINT32 lvl, size_t indentLevel, const V* obj) \
|
||||
{ \
|
||||
ndr_struct_dump_fromDescr(logger, lvl, indentLevel, &V##_struct, obj); \
|
||||
} \
|
||||
\
|
||||
static BOOL ndr_descr_read_##V(NdrContext* context, wStream* s, const void* hints, void* obj) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
return ndr_struct_read_fromDescr(context, s, &V##_struct, obj); \
|
||||
} \
|
||||
static BOOL ndr_descr_write_##V(NdrContext* context, wStream* s, const void* hints, \
|
||||
const void* obj) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
return ndr_struct_write_fromDescr(context, s, &V##_struct, obj); \
|
||||
} \
|
||||
static void ndr_descr_destroy_##V(NdrContext* context, const void* hints, void* obj) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
ndr_struct_destroy(context, &V##_struct, obj); \
|
||||
} \
|
||||
static void ndr_descr_dump_##V(wLog* logger, UINT32 lvl, size_t indentLevel, const void* obj) \
|
||||
{ \
|
||||
ndr_struct_dump_fromDescr(logger, lvl, indentLevel, &V##_struct, obj); \
|
||||
} \
|
||||
\
|
||||
static NdrMessageDescr ndr_##V##_descr_s = { \
|
||||
NDR_ARITY_SIMPLE, sizeof(V), ndr_descr_read_##V, ndr_descr_write_##V, \
|
||||
ndr_descr_destroy_##V, ndr_descr_dump_##V, \
|
||||
}; \
|
||||
\
|
||||
NdrMessageType ndr_##V##_descr(void) \
|
||||
{ \
|
||||
return &ndr_##V##_descr_s; \
|
||||
}
|
||||
|
||||
static const NdrFieldStruct KERB_RPC_OCTET_STRING_fields[] = {
|
||||
{ "Length", offsetof(KERB_RPC_OCTET_STRING, length), NDR_NOT_POINTER, -1, &ndr_uint32_descr_s },
|
||||
{ "value", offsetof(KERB_RPC_OCTET_STRING, value), NDR_POINTER_NON_NULL, 0,
|
||||
&ndr_uint8Array_descr_s }
|
||||
};
|
||||
static const NdrStructDescr KERB_RPC_OCTET_STRING_struct = { "KERB_RPC_OCTET_STRING", 2,
|
||||
KERB_RPC_OCTET_STRING_fields };
|
||||
|
||||
RDPEAR_SIMPLE_MESSAGE_TYPE(KERB_RPC_OCTET_STRING)
|
||||
|
||||
/* ============================= KERB_ASN1_DATA ============================== */
|
||||
|
||||
static const NdrFieldStruct KERB_ASN1_DATA_fields[] = {
|
||||
{ "Pdu", offsetof(KERB_ASN1_DATA, Pdu), NDR_NOT_POINTER, -1, &ndr_uint32_descr_s },
|
||||
{ "Count", offsetof(KERB_ASN1_DATA, Asn1BufferHints.count), NDR_NOT_POINTER, -1,
|
||||
&ndr_uint32_descr_s },
|
||||
{ "Asn1Buffer", offsetof(KERB_ASN1_DATA, Asn1Buffer), NDR_POINTER_NON_NULL, 1,
|
||||
&ndr_uint8Array_descr_s }
|
||||
};
|
||||
static const NdrStructDescr KERB_ASN1_DATA_struct = { "KERB_ASN1_DATA",
|
||||
ARRAYSIZE(KERB_ASN1_DATA_fields),
|
||||
KERB_ASN1_DATA_fields };
|
||||
|
||||
RDPEAR_SIMPLE_MESSAGE_TYPE(KERB_ASN1_DATA)
|
||||
|
||||
/* ============================ RPC_UNICODE_STRING ========================== */
|
||||
|
||||
BOOL ndr_read_RPC_UNICODE_STRING(NdrContext* context, wStream* s, const void* hints,
|
||||
RPC_UNICODE_STRING* res)
|
||||
{
|
||||
NdrDeferredEntry bufferDesc = { NDR_PTR_NULL, "RPC_UNICODE_STRING.Buffer", &res->lenHints,
|
||||
(void*)&res->Buffer, ndr_uint16VaryingArray_descr() };
|
||||
UINT16 Length = 0;
|
||||
UINT16 MaximumLength = 0;
|
||||
|
||||
WINPR_UNUSED(hints);
|
||||
if (!ndr_read_uint16(context, s, &Length) || !ndr_read_uint16(context, s, &MaximumLength) ||
|
||||
!ndr_read_refpointer(context, s, &bufferDesc.ptrId) || Length > MaximumLength)
|
||||
return FALSE;
|
||||
|
||||
res->lenHints.length = Length;
|
||||
res->lenHints.maxLength = MaximumLength;
|
||||
res->strLength = Length / 2;
|
||||
|
||||
return ndr_push_deferreds(context, &bufferDesc, 1);
|
||||
}
|
||||
|
||||
static BOOL ndr_descr_read_RPC_UNICODE_STRING(NdrContext* context, wStream* s, const void* hints,
|
||||
void* res)
|
||||
{
|
||||
return ndr_read_RPC_UNICODE_STRING(context, s, hints, res);
|
||||
}
|
||||
|
||||
BOOL ndr_write_RPC_UNICODE_STRING(NdrContext* context, wStream* s,
|
||||
WINPR_ATTR_UNUSED const void* hints,
|
||||
const RPC_UNICODE_STRING* res)
|
||||
{
|
||||
WINPR_ASSERT(res);
|
||||
if (!ndr_write_uint32(context, s, res->lenHints.length))
|
||||
return FALSE;
|
||||
|
||||
if (!ndr_write_uint32(context, s, res->lenHints.maxLength))
|
||||
return FALSE;
|
||||
|
||||
return ndr_write_data(context, s, res->Buffer, res->strLength);
|
||||
}
|
||||
|
||||
static BOOL ndr_write_RPC_UNICODE_STRING_(NdrContext* context, wStream* s, const void* hints,
|
||||
const void* pvres)
|
||||
{
|
||||
const RPC_UNICODE_STRING* res = pvres;
|
||||
return ndr_write_RPC_UNICODE_STRING(context, s, hints, res);
|
||||
}
|
||||
|
||||
void ndr_dump_RPC_UNICODE_STRING(wLog* logger, UINT32 lvl, size_t indentLevel,
|
||||
const RPC_UNICODE_STRING* obj)
|
||||
{
|
||||
WINPR_UNUSED(indentLevel);
|
||||
WLog_Print(logger, lvl, "\tLength=%u MaximumLength=%u", obj->lenHints.length,
|
||||
obj->lenHints.maxLength);
|
||||
winpr_HexLogDump(logger, lvl, obj->Buffer, obj->lenHints.length);
|
||||
}
|
||||
|
||||
static void ndr_descr_dump_RPC_UNICODE_STRING(wLog* logger, UINT32 lvl, size_t indentLevel,
|
||||
const void* obj)
|
||||
{
|
||||
ndr_dump_RPC_UNICODE_STRING(logger, lvl, indentLevel, obj);
|
||||
}
|
||||
|
||||
void ndr_destroy_RPC_UNICODE_STRING(NdrContext* context, const void* hints, RPC_UNICODE_STRING* obj)
|
||||
{
|
||||
WINPR_UNUSED(context);
|
||||
WINPR_UNUSED(hints);
|
||||
if (!obj)
|
||||
return;
|
||||
free(obj->Buffer);
|
||||
obj->Buffer = nullptr;
|
||||
}
|
||||
|
||||
static void ndr_descr_destroy_RPC_UNICODE_STRING(NdrContext* context, const void* hints, void* obj)
|
||||
{
|
||||
ndr_destroy_RPC_UNICODE_STRING(context, hints, obj);
|
||||
}
|
||||
|
||||
static const NdrMessageDescr RPC_UNICODE_STRING_descr_s = { NDR_ARITY_SIMPLE,
|
||||
sizeof(RPC_UNICODE_STRING),
|
||||
ndr_descr_read_RPC_UNICODE_STRING,
|
||||
ndr_write_RPC_UNICODE_STRING_,
|
||||
ndr_descr_destroy_RPC_UNICODE_STRING,
|
||||
ndr_descr_dump_RPC_UNICODE_STRING };
|
||||
|
||||
NdrMessageType ndr_RPC_UNICODE_STRING_descr(void)
|
||||
{
|
||||
return &RPC_UNICODE_STRING_descr_s;
|
||||
}
|
||||
|
||||
/* ========================= RPC_UNICODE_STRING_Array ======================== */
|
||||
|
||||
static BOOL ndr_read_RPC_UNICODE_STRING_Array(NdrContext* context, wStream* s, const void* hints,
|
||||
void* v)
|
||||
{
|
||||
WINPR_ASSERT(context);
|
||||
WINPR_ASSERT(s);
|
||||
WINPR_ASSERT(hints);
|
||||
return ndr_read_uconformant_array(context, s, hints, ndr_RPC_UNICODE_STRING_descr(), v);
|
||||
}
|
||||
|
||||
static BOOL ndr_write_RPC_UNICODE_STRING_Array(NdrContext* context, wStream* s, const void* ghints,
|
||||
const void* v)
|
||||
{
|
||||
WINPR_ASSERT(context);
|
||||
WINPR_ASSERT(s);
|
||||
WINPR_ASSERT(ghints);
|
||||
|
||||
const NdrArrayHints* hints = (const NdrArrayHints*)ghints;
|
||||
|
||||
return ndr_write_uconformant_array(context, s, hints->count, ndr_RPC_UNICODE_STRING_descr(), v);
|
||||
}
|
||||
|
||||
static const NdrMessageDescr RPC_UNICODE_STRING_Array_descr_s = {
|
||||
NDR_ARITY_ARRAYOF,
|
||||
sizeof(RPC_UNICODE_STRING),
|
||||
ndr_read_RPC_UNICODE_STRING_Array,
|
||||
ndr_write_RPC_UNICODE_STRING_Array,
|
||||
nullptr,
|
||||
nullptr
|
||||
};
|
||||
|
||||
static NdrMessageType ndr_RPC_UNICODE_STRING_Array_descr(void)
|
||||
{
|
||||
return &RPC_UNICODE_STRING_Array_descr_s;
|
||||
}
|
||||
|
||||
/* ========================== KERB_RPC_INTERNAL_NAME ======================== */
|
||||
|
||||
BOOL ndr_read_KERB_RPC_INTERNAL_NAME(NdrContext* context, wStream* s, const void* hints,
|
||||
KERB_RPC_INTERNAL_NAME* res)
|
||||
{
|
||||
WINPR_ASSERT(res);
|
||||
|
||||
union
|
||||
{
|
||||
RPC_UNICODE_STRING** ppstr;
|
||||
void* pv;
|
||||
} cnv;
|
||||
cnv.ppstr = &res->Names;
|
||||
NdrDeferredEntry names = { NDR_PTR_NULL, "KERB_RPC_INTERNAL_NAME.Names", &res->nameHints,
|
||||
cnv.pv, ndr_RPC_UNICODE_STRING_Array_descr() };
|
||||
|
||||
UINT16 nameCount = 0;
|
||||
WINPR_UNUSED(hints);
|
||||
|
||||
if (!ndr_read_uint16(context, s, &res->NameType) || !ndr_read_uint16(context, s, &nameCount))
|
||||
return FALSE;
|
||||
|
||||
res->nameHints.count = nameCount;
|
||||
|
||||
return ndr_read_refpointer(context, s, &names.ptrId) && ndr_push_deferreds(context, &names, 1);
|
||||
}
|
||||
|
||||
static BOOL ndr_descr_read_KERB_RPC_INTERNAL_NAME(NdrContext* context, wStream* s,
|
||||
const void* hints, void* res)
|
||||
{
|
||||
return ndr_read_KERB_RPC_INTERNAL_NAME(context, s, hints, res);
|
||||
}
|
||||
|
||||
BOOL ndr_write_KERB_RPC_INTERNAL_NAME(NdrContext* context, wStream* s, const void* hints,
|
||||
const KERB_RPC_INTERNAL_NAME* res)
|
||||
{
|
||||
WINPR_UNUSED(context);
|
||||
WINPR_UNUSED(s);
|
||||
WINPR_UNUSED(hints);
|
||||
WINPR_UNUSED(res);
|
||||
WLog_ERR(TAG, "TODO: implement this");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
void ndr_dump_KERB_RPC_INTERNAL_NAME(wLog* logger, UINT32 lvl, size_t indentLevel,
|
||||
const KERB_RPC_INTERNAL_NAME* obj)
|
||||
{
|
||||
WINPR_UNUSED(indentLevel);
|
||||
WINPR_UNUSED(obj);
|
||||
WLog_Print(logger, lvl, "TODO: implement this");
|
||||
}
|
||||
|
||||
static void ndr_descr_dump_KERB_RPC_INTERNAL_NAME(wLog* logger, UINT32 lvl, size_t indentLevel,
|
||||
const void* obj)
|
||||
{
|
||||
ndr_dump_KERB_RPC_INTERNAL_NAME(logger, lvl, indentLevel, obj);
|
||||
}
|
||||
|
||||
void ndr_destroy_KERB_RPC_INTERNAL_NAME(NdrContext* context, const void* hints,
|
||||
KERB_RPC_INTERNAL_NAME* obj)
|
||||
{
|
||||
WINPR_UNUSED(hints);
|
||||
if (!obj)
|
||||
return;
|
||||
|
||||
for (UINT32 i = 0; i < obj->nameHints.count; i++)
|
||||
ndr_destroy_RPC_UNICODE_STRING(context, nullptr, &obj->Names[i]);
|
||||
|
||||
free(obj->Names);
|
||||
obj->Names = nullptr;
|
||||
}
|
||||
|
||||
static void ndr_descr_destroy_KERB_RPC_INTERNAL_NAME(NdrContext* context, const void* hints,
|
||||
void* obj)
|
||||
{
|
||||
ndr_destroy_KERB_RPC_INTERNAL_NAME(context, hints, obj);
|
||||
}
|
||||
|
||||
static NdrMessageDescr KERB_RPC_INTERNAL_NAME_descr_s = { NDR_ARITY_SIMPLE,
|
||||
sizeof(KERB_RPC_INTERNAL_NAME),
|
||||
ndr_descr_read_KERB_RPC_INTERNAL_NAME,
|
||||
nullptr,
|
||||
ndr_descr_destroy_KERB_RPC_INTERNAL_NAME,
|
||||
ndr_descr_dump_KERB_RPC_INTERNAL_NAME };
|
||||
|
||||
NdrMessageType ndr_KERB_RPC_INTERNAL_NAME_descr(void)
|
||||
{
|
||||
return &KERB_RPC_INTERNAL_NAME_descr_s;
|
||||
}
|
||||
|
||||
/* ========================== KERB_RPC_ENCRYPTION_KEY ======================== */
|
||||
|
||||
static const NdrFieldStruct KERB_RPC_ENCRYPTION_KEY_fields[] = {
|
||||
{ "reserved1", offsetof(KERB_RPC_ENCRYPTION_KEY, reserved1), NDR_NOT_POINTER, -1,
|
||||
&ndr_uint32_descr_s },
|
||||
{ "reserved2", offsetof(KERB_RPC_ENCRYPTION_KEY, reserved2), NDR_NOT_POINTER, -1,
|
||||
&ndr_uint32_descr_s },
|
||||
{ "reserved3", offsetof(KERB_RPC_ENCRYPTION_KEY, reserved3), NDR_NOT_POINTER, -1,
|
||||
&ndr_KERB_RPC_OCTET_STRING_descr_s }
|
||||
};
|
||||
static const NdrStructDescr KERB_RPC_ENCRYPTION_KEY_struct = {
|
||||
"KERB_RPC_ENCRYPTION_KEY", ARRAYSIZE(KERB_RPC_ENCRYPTION_KEY_fields),
|
||||
KERB_RPC_ENCRYPTION_KEY_fields
|
||||
};
|
||||
|
||||
RDPEAR_SIMPLE_MESSAGE_TYPE(KERB_RPC_ENCRYPTION_KEY)
|
||||
|
||||
/* ========================== BuildEncryptedAuthDataReq ======================== */
|
||||
|
||||
static const NdrFieldStruct BuildEncryptedAuthDataReq_fields[] = {
|
||||
{ "KeyUsage", offsetof(BuildEncryptedAuthDataReq, KeyUsage), NDR_NOT_POINTER, -1,
|
||||
&ndr_uint32_descr_s },
|
||||
{ "key", offsetof(BuildEncryptedAuthDataReq, Key), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_KERB_RPC_ENCRYPTION_KEY_descr_s },
|
||||
{ "plainAuthData", offsetof(BuildEncryptedAuthDataReq, PlainAuthData), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_KERB_ASN1_DATA_descr_s }
|
||||
};
|
||||
static const NdrStructDescr BuildEncryptedAuthDataReq_struct = {
|
||||
"BuildEncryptedAuthDataReq", ARRAYSIZE(BuildEncryptedAuthDataReq_fields),
|
||||
BuildEncryptedAuthDataReq_fields
|
||||
};
|
||||
|
||||
RDPEAR_SIMPLE_MESSAGE_TYPE(BuildEncryptedAuthDataReq)
|
||||
|
||||
/* ========================== ComputeTgsChecksumReq ======================== */
|
||||
|
||||
static const NdrFieldStruct ComputeTgsChecksumReq_fields[] = {
|
||||
{ "requestBody", offsetof(ComputeTgsChecksumReq, requestBody), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_KERB_ASN1_DATA_descr_s },
|
||||
{ "key", offsetof(ComputeTgsChecksumReq, Key), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_KERB_RPC_ENCRYPTION_KEY_descr_s },
|
||||
{ "ChecksumType", offsetof(ComputeTgsChecksumReq, ChecksumType), NDR_NOT_POINTER, -1,
|
||||
&ndr_uint32_descr_s }
|
||||
};
|
||||
static const NdrStructDescr ComputeTgsChecksumReq_struct = {
|
||||
"ComputeTgsChecksumReq", ARRAYSIZE(ComputeTgsChecksumReq_fields), ComputeTgsChecksumReq_fields
|
||||
};
|
||||
|
||||
RDPEAR_SIMPLE_MESSAGE_TYPE(ComputeTgsChecksumReq)
|
||||
|
||||
/* ========================== CreateApReqAuthenticatorReq ======================== */
|
||||
|
||||
static const NdrFieldStruct CreateApReqAuthenticatorReq_fields[] = {
|
||||
{ "EncryptionKey", offsetof(CreateApReqAuthenticatorReq, EncryptionKey), NDR_POINTER_NON_NULL,
|
||||
-1, &ndr_KERB_RPC_ENCRYPTION_KEY_descr_s },
|
||||
{ "SequenceNumber", offsetof(CreateApReqAuthenticatorReq, SequenceNumber), NDR_NOT_POINTER, -1,
|
||||
&ndr_uint32_descr_s },
|
||||
{ "ClientName", offsetof(CreateApReqAuthenticatorReq, ClientName), NDR_POINTER_NON_NULL, -1,
|
||||
&KERB_RPC_INTERNAL_NAME_descr_s },
|
||||
{ "ClientRealm", offsetof(CreateApReqAuthenticatorReq, ClientRealm), NDR_POINTER_NON_NULL, -1,
|
||||
&RPC_UNICODE_STRING_descr_s },
|
||||
{ "SkewTime", offsetof(CreateApReqAuthenticatorReq, SkewTime), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_uint64_descr_s },
|
||||
{ "SubKey", offsetof(CreateApReqAuthenticatorReq, SubKey), NDR_POINTER, -1,
|
||||
&ndr_KERB_RPC_ENCRYPTION_KEY_descr_s },
|
||||
{ "AuthData", offsetof(CreateApReqAuthenticatorReq, AuthData), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_KERB_ASN1_DATA_descr_s },
|
||||
{ "GssChecksum", offsetof(CreateApReqAuthenticatorReq, GssChecksum), NDR_POINTER, -1,
|
||||
&ndr_KERB_ASN1_DATA_descr_s },
|
||||
{ "KeyUsage", offsetof(CreateApReqAuthenticatorReq, KeyUsage), NDR_NOT_POINTER, -1,
|
||||
&ndr_uint32_descr_s },
|
||||
};
|
||||
static const NdrStructDescr CreateApReqAuthenticatorReq_struct = {
|
||||
"CreateApReqAuthenticatorReq", ARRAYSIZE(CreateApReqAuthenticatorReq_fields),
|
||||
CreateApReqAuthenticatorReq_fields
|
||||
};
|
||||
|
||||
RDPEAR_SIMPLE_MESSAGE_TYPE(CreateApReqAuthenticatorReq)
|
||||
|
||||
/* ========================== CreateApReqAuthenticatorResp ======================== */
|
||||
|
||||
static const NdrFieldStruct CreateApReqAuthenticatorResp_fields[] = {
|
||||
{ "AuthenticatorTime", offsetof(CreateApReqAuthenticatorResp, AuthenticatorTime),
|
||||
NDR_NOT_POINTER, -1, &ndr_uint64_descr_s },
|
||||
{ "Authenticator", offsetof(CreateApReqAuthenticatorResp, Authenticator), NDR_NOT_POINTER, -1,
|
||||
&ndr_KERB_ASN1_DATA_descr_s },
|
||||
{ "KerbProtocolError", offsetof(CreateApReqAuthenticatorResp, KerbProtocolError),
|
||||
NDR_NOT_POINTER, -1, &ndr_uint32_descr_s },
|
||||
};
|
||||
|
||||
static const NdrStructDescr CreateApReqAuthenticatorResp_struct = {
|
||||
"CreateApReqAuthenticatorResp", ARRAYSIZE(CreateApReqAuthenticatorResp_fields),
|
||||
CreateApReqAuthenticatorResp_fields
|
||||
};
|
||||
|
||||
RDPEAR_SIMPLE_MESSAGE_TYPE(CreateApReqAuthenticatorResp)
|
||||
|
||||
/* ========================== UnpackKdcReplyBodyReq ======================== */
|
||||
|
||||
static const NdrFieldStruct UnpackKdcReplyBodyReq_fields[] = {
|
||||
{ "EncryptedData", offsetof(UnpackKdcReplyBodyReq, EncryptedData), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_KERB_ASN1_DATA_descr_s },
|
||||
{ "Key", offsetof(UnpackKdcReplyBodyReq, Key), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_KERB_RPC_ENCRYPTION_KEY_descr_s },
|
||||
{ "StrenghtenKey", offsetof(UnpackKdcReplyBodyReq, StrengthenKey), NDR_POINTER, -1,
|
||||
&ndr_KERB_RPC_ENCRYPTION_KEY_descr_s },
|
||||
{ "Pdu", offsetof(UnpackKdcReplyBodyReq, Pdu), NDR_NOT_POINTER, -1, &ndr_uint32_descr_s },
|
||||
{ "KeyUsage", offsetof(UnpackKdcReplyBodyReq, KeyUsage), NDR_NOT_POINTER, -1,
|
||||
&ndr_uint32_descr_s },
|
||||
};
|
||||
|
||||
static const NdrStructDescr UnpackKdcReplyBodyReq_struct = {
|
||||
"UnpackKdcReplyBodyReq", ARRAYSIZE(UnpackKdcReplyBodyReq_fields), UnpackKdcReplyBodyReq_fields
|
||||
};
|
||||
|
||||
RDPEAR_SIMPLE_MESSAGE_TYPE(UnpackKdcReplyBodyReq)
|
||||
|
||||
/* ========================== UnpackKdcReplyBodyResp ======================== */
|
||||
|
||||
static const NdrFieldStruct UnpackKdcReplyBodyResp_fields[] = {
|
||||
{ "KerbProtocolError", offsetof(UnpackKdcReplyBodyResp, KerbProtocolError), NDR_NOT_POINTER, -1,
|
||||
&ndr_uint32_descr_s },
|
||||
{ "ReplyBody", offsetof(UnpackKdcReplyBodyResp, ReplyBody), NDR_NOT_POINTER, -1,
|
||||
&ndr_KERB_ASN1_DATA_descr_s }
|
||||
};
|
||||
|
||||
static const NdrStructDescr UnpackKdcReplyBodyResp_struct = {
|
||||
"UnpackKdcReplyBodyResp", ARRAYSIZE(UnpackKdcReplyBodyResp_fields),
|
||||
UnpackKdcReplyBodyResp_fields
|
||||
};
|
||||
|
||||
RDPEAR_SIMPLE_MESSAGE_TYPE(UnpackKdcReplyBodyResp)
|
||||
|
||||
/* ========================== DecryptApReplyReq ======================== */
|
||||
|
||||
static const NdrFieldStruct DecryptApReplyReq_fields[] = {
|
||||
{ "EncryptedReply", offsetof(DecryptApReplyReq, EncryptedReply), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_KERB_ASN1_DATA_descr_s },
|
||||
{ "Key", offsetof(DecryptApReplyReq, Key), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_KERB_RPC_ENCRYPTION_KEY_descr_s }
|
||||
};
|
||||
|
||||
static const NdrStructDescr DecryptApReplyReq_struct = { "DecryptApReplyReq",
|
||||
ARRAYSIZE(DecryptApReplyReq_fields),
|
||||
DecryptApReplyReq_fields };
|
||||
|
||||
RDPEAR_SIMPLE_MESSAGE_TYPE(DecryptApReplyReq)
|
||||
|
||||
/* ========================== PackApReplyReq ======================== */
|
||||
|
||||
static const NdrFieldStruct PackApReplyReq_fields[] = {
|
||||
{ "Reply", offsetof(PackApReplyReq, Reply), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_KERB_ASN1_DATA_descr_s },
|
||||
{ "ReplyBody", offsetof(PackApReplyReq, ReplyBody), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_KERB_ASN1_DATA_descr_s },
|
||||
{ "SessionKey", offsetof(PackApReplyReq, SessionKey), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_KERB_RPC_ENCRYPTION_KEY_descr_s }
|
||||
};
|
||||
|
||||
static const NdrStructDescr PackApReplyReq_struct = { "PackApReplyReq",
|
||||
ARRAYSIZE(PackApReplyReq_fields),
|
||||
PackApReplyReq_fields };
|
||||
|
||||
RDPEAR_SIMPLE_MESSAGE_TYPE(PackApReplyReq)
|
||||
|
||||
/* ========================== PackApReplyResp ======================== */
|
||||
|
||||
static const NdrFieldStruct PackApReplyResp_fields[] = {
|
||||
{ "PackedReplySize", offsetof(PackApReplyResp, PackedReplyHints), NDR_NOT_POINTER, -1,
|
||||
&ndr_uint32_descr_s },
|
||||
{ "PackedReply", offsetof(PackApReplyResp, PackedReply), NDR_POINTER_NON_NULL, 0,
|
||||
&ndr_uint8Array_descr_s },
|
||||
};
|
||||
|
||||
static const NdrStructDescr PackApReplyResp_struct = { "PackApReplyResp",
|
||||
ARRAYSIZE(PackApReplyResp_fields),
|
||||
PackApReplyResp_fields };
|
||||
|
||||
RDPEAR_SIMPLE_MESSAGE_TYPE(PackApReplyResp)
|
||||
Reference in New Issue
Block a user