epan/dissectors/pidl/rcg/rcg.idl

   1 #include "idl_types.h"
   2
   3 [
   4   uuid("00000000-0000-0000-0000-000000000000"),
   5   pointer_default(ref)
   6 ]
   7
   8 interface rcg {
   9         #define BOOL uint32
  10         #define PLONG int32 *
  11         #define UCHAR uint8
  12         #define PBYTE uint8 *
  13         #define KERBERR int32
  14         #define KEY_AGREEMENT_HANDLE int64
  15
  16         typedef struct {
  17                 uint32 Pdu;
  18                 uint32 Length;
  19                 [size_is(Length)] uint8 *Asn1Buffer;
  20         } KERB_ASN1_DATA;
  21
  22         typedef struct {
  23                 uint32 Pdu;
  24                 uint32 Length;
  25                 [size_is(Length)] uint8 *checksum;
  26         } KERB_ASN1_DATA_CHECKSUM;
  27
  28         typedef struct {
  29                 uint32 length;
  30                 [size_is(length)] uint8 *value;
  31         } KERB_RPC_OCTET_STRING;
  32
  33         typedef struct {
  34                 int32 preauth_data_type;
  35                 KERB_RPC_OCTET_STRING preauth_data;
  36         } KERB_RPC_PA_DATA;
  37
  38         typedef struct {
  39                 uint32 reserved1;
  40                 uint32 reserved2;
  41                 KERB_RPC_OCTET_STRING reserved3;
  42         } KERB_RPC_ENCRYPTION_KEY;
  43
  44         typedef struct {
  45                 uint16 Length;
  46                 uint16 MaximumLength;
  47                 [size_is(MaximumLength/2), length_is(Length/2)]
  48                 [string,charset(UTF16)] uint16* Buffer;
  49         } RPC_UNICODE_STRING;
  50
  51         typedef struct {
  52                 int16 NameType;
  53                 uint16 NameCount;
  54                 [size_is(NameCount)] RPC_UNICODE_STRING* Names;
  55         } KERB_RPC_INTERNAL_NAME;
  56
  57
  58         //[v1_enum]
  59         typedef [enum16bit] enum
  60         {
  61                 //RemoteCallMinimum = 0,
  62                 // start generic calls - not tied to a specific SSP
  63                 //RemoteCallGenericMinimum = 0,
  64                 //RemoteCallGenericReserved = 0,
  65                 //RemoteCallGenericMaximum = 0xff,
  66                 // Start Kerberos remote calls
  67                 //RemoteCallKerbMinimum = 0x100,
  68                 RemoteCallKerbNegotiateVersion = 0x100,
  69                 RemoteCallKerbBuildAsReqAuthenticator = 0x101,
  70                 RemoteCallKerbVerifyServiceTicket = 0x102,
  71                 RemoteCallKerbCreateApReqAuthenticator = 0x103,
  72                 RemoteCallKerbDecryptApReply = 0x104,
  73                 RemoteCallKerbUnpackKdcReplyBody = 0x105,
  74                 RemoteCallKerbComputeTgsChecksum = 0x106,
  75                 RemoteCallKerbBuildEncryptedAuthData = 0x107,
  76                 RemoteCallKerbPackApReply = 0x108,
  77                 RemoteCallKerbHashS4UPreauth = 0x109,
  78                 RemoteCallKerbSignS4UPreauthData = 0x10a,
  79                 RemoteCallKerbVerifyChecksum = 0x10b,
  80                 #if 0
  81                 Reserved1, // 0x10c,
  82                 Reserved2, // 0x10d,
  83                 Reserved3, // 0x10e,
  84                 Reserved4, // 0x10f,
  85                 Reserved5, // 0x110,
  86                 Reserved6, // 0x111,
  87                 Reserved7, // 0x112,
  88                 #endif
  89                 RemoteCallKerbDecryptPacCredentials = 0x113,
  90                 RemoteCallKerbCreateECDHKeyAgreement = 0x114,
  91                 RemoteCallKerbCreateDHKeyAgreement = 0x115,
  92                 RemoteCallKerbDestroyKeyAgreement  = 0x116,
  93                 RemoteCallKerbKeyAgreementGenerateNonce = 0x117,
  94                 RemoteCallKerbFinalizeKeyAgreement = 0x118,
  95                 //RemoteCallKerbMaximum = 0x1ff,
  96                 // End Kerberos remote calls
  97
  98                 // Start NTLM remote calls
  99                 //RemoteCallNtlmMinimum = 0x200,
 100                 RemoteCallNtlmNegotiateVersion = 0x200,
 101                 RemoteCallNtlmLm20GetNtlm3ChallengeResponse = 0x201,
 102                 RemoteCallNtlmCalculateNtResponse = 0x202,
 103                 RemoteCallNtlmCalculateUserSessionKeyNt = 0x203,
 104                 RemoteCallNtlmCompareCredentials = 0x204 //,
 105                 //RemoteCallNtlmMaximum = 0x2ff,
 106                 // End NTLM remote calls
 107                 //RemoteCallMaximum = 0x2ff,
 108                 //RemoteCallInvalid = 0xffff // This enumeration MUST fit in 16 bits
 109         } RemoteGuardCallId;
 110
 111
 112         typedef struct _SECPKG_SUPPLEMENTAL_CRED {
 113                 RPC_UNICODE_STRING PackageName;
 114                 uint32 CredentialSize;
 115                 [size_is(CredentialSize)] uint8 *Credentials;
 116         } SECPKG_SUPPLEMENTAL_CRED;
 117
 118         typedef struct {
 119                 uint32 CredentialCount;
 120                 [size_is(CredentialCount)] SECPKG_SUPPLEMENTAL_CRED Credentials[*];
 121         } SECPKG_SUPPLEMENTAL_CRED_ARRAY;
 122         typedef struct SECPKG_SUPPLEMENTAL_CRED_ARRAY *PSECPKG_SUPPLEMENTAL_CRED_ARRAY;
 123
 124
 125         typedef struct {
 126                 uint32 cbData;
 127                 [size_is(cbData)] PBYTE pbData;
 128         } KERB_RPC_CRYPTO_API_BLOB;
 129
 130
 131         // Used to negotiate the protocol version that will be used.
 132         // Server sends the maximum version it supports; client replies
 133         // with the version that will actually be used.
 134         typedef struct {
 135                 uint32 MaxSupportedVersion;
 136         } NegotiateVersion;
 137
 138         typedef struct {
 139                 int64 QuadPart;
 140         } LARGE_INTEGER;
 141         typedef struct LARGE_INTEGER *PLARGE_INTEGER;
 142
 143         typedef struct {
 144                 KERB_RPC_ENCRYPTION_KEY* EncryptionKey;
 145                 [ptr] KERB_RPC_ENCRYPTION_KEY* ArmorKey; // optional
 146                 LARGE_INTEGER *TimeSkew;
 147         } BuildAsReqAuthenticatorReq;
 148
 149         typedef struct {
 150                 int32 PreauthDataType;
 151                 KERB_RPC_OCTET_STRING PreauthData;
 152         } BuildAsReqAuthenticatorResp;
 153
 154         typedef struct {
 155                 KERB_ASN1_DATA* PackedTicket;
 156                 KERB_RPC_ENCRYPTION_KEY* ServiceKey;
 157                 [ptr] LARGE_INTEGER *TimeSkew; // optional
 158         } VerifyServiceTicketReq;
 159
 160         typedef struct {
 161                 KERB_ASN1_DATA DecryptedTicket;
 162                 int32 KerbProtocolError;
 163         } VerifyServiceTicketResp;
 164
 165         typedef struct RPC_UNICODE_STRING *PRPC_UNICODE_STRING;
 166         typedef struct {
 167                 KERB_RPC_ENCRYPTION_KEY* EncryptionKey;
 168                 uint32 SequenceNumber;
 169                 KERB_RPC_INTERNAL_NAME* ClientName;
 170                 RPC_UNICODE_STRING* ClientRealm;
 171                 LARGE_INTEGER *SkewTime;
 172                 [ptr] KERB_RPC_ENCRYPTION_KEY* SubKey; // optional
 173                 [ptr] KERB_ASN1_DATA* AuthData; // optional
 174                 [ptr] KERB_ASN1_DATA_CHECKSUM* GssChecksum; // optional
 175                 uint32 KeyUsage;
 176         } CreateApReqAuthenticatorReq;
 177
 178         typedef struct {
 179                 LARGE_INTEGER AuthenticatorTime;
 180                 KERB_ASN1_DATA Authenticator;
 181                 int32 KerbProtocolError;
 182         } CreateApReqAuthenticatorResp;
 183
 184         typedef struct {
 185                 KERB_ASN1_DATA* EncryptedReply;
 186                 KERB_RPC_ENCRYPTION_KEY* Key;
 187         } DecryptApReplyReq;
 188
 189         typedef struct {
 190                 KERB_ASN1_DATA ApReply;
 191         } DecryptApReplyResp;
 192
 193         typedef struct {
 194                 KERB_ASN1_DATA* EncryptedData;
 195                 KERB_RPC_ENCRYPTION_KEY* Key;
 196                 [ptr] KERB_RPC_ENCRYPTION_KEY* StrengthenKey; // seems optional
 197                 uint32 Pdu;
 198                 uint32 KeyUsage;
 199         } UnpackKdcReplyBodyReq;
 200
 201         typedef struct {
 202                 int32 KerbProtocolError;
 203                 KERB_ASN1_DATA ReplyBody;
 204         } UnpackKdcReplyBodyResp;
 205
 206         typedef struct {
 207                 KERB_ASN1_DATA* RequestBody;
 208                 KERB_RPC_ENCRYPTION_KEY* Key;
 209                 uint32 ChecksumType;
 210         } ComputeTgsChecksumReq;
 211
 212         typedef struct {
 213                 KERB_ASN1_DATA_CHECKSUM Checksum;
 214         } ComputeTgsChecksumResp;
 215
 216         typedef struct {
 217                 uint32 KeyUsage;
 218                 KERB_RPC_ENCRYPTION_KEY* Key;
 219                 KERB_ASN1_DATA* PlainAuthData;
 220         } BuildEncryptedAuthDataReq;
 221
 222         typedef struct {
 223                 KERB_ASN1_DATA EncryptedAuthData;
 224         } BuildEncryptedAuthDataResp;
 225
 226         typedef struct {
 227                 KERB_ASN1_DATA* Reply;
 228                 KERB_ASN1_DATA* ReplyBody;
 229                 KERB_RPC_ENCRYPTION_KEY* SessionKey;
 230         } PackApReplyReq;
 231
 232         typedef struct {
 233                 uint32 PackedReplySize;
 234                 [size_is(PackedReplySize)] uint8 *PackedReply;
 235         } PackApReplyResp;
 236
 237         typedef struct {
 238                 KERB_ASN1_DATA* S4UPreauth;
 239                 KERB_RPC_ENCRYPTION_KEY* Key;
 240                 int32 ChecksumType;
 241         } HashS4UPreauthReq;
 242
 243         typedef struct {
 244                 uint32 *ChecksumSize;
 245                 [size_is(, *ChecksumSize)] uint8 ** ChecksumValue;
 246         } HashS4UPreauthResp;
 247
 248         typedef struct {
 249                 KERB_RPC_ENCRYPTION_KEY* Key;
 250                 BOOL IsRequest;
 251                 KERB_ASN1_DATA* UserId;
 252                 PLONG ChecksumType;
 253         } SignS4UPreauthDataReq;
 254
 255         typedef struct {
 256                 int32 *ChecksumType;
 257                 uint32 *ChecksumSize;
 258                 [size_is(, *ChecksumSize)] uint8 ** ChecksumValue;
 259         } SignS4UPreauthDataResp;
 260
 261         typedef struct {
 262                 KERB_RPC_ENCRYPTION_KEY* Key;
 263                 uint32 ChecksumType;
 264                 uint32 ExpectedChecksumSize;
 265                 [size_is(ExpectedChecksumSize)] UCHAR* ExpectedChecksum;
 266                 uint32 DataToCheckSize;
 267                 [size_is(DataToCheckSize)] UCHAR* DataToCheck;
 268         } VerifyChecksumReq;
 269
 270         typedef struct {
 271                 BOOL IsValid;
 272         } VerifyChecksumResp;
 273
 274         typedef struct {
 275                 KERB_RPC_ENCRYPTION_KEY* Key;
 276                 uint32 Version;
 277                 uint32 EncryptionType;
 278                 uint32 DataSize;
 279                 [size_is(DataSize)] UCHAR* Data;
 280         } DecryptPacCredentialsReq;
 281
 282         typedef struct {
 283                 PSECPKG_SUPPLEMENTAL_CRED_ARRAY Credentials;
 284         } DecryptPacCredentialsResp;
 285
 286         typedef struct {
 287                 uint32 KeyBitLen;
 288         } CreateECDHKeyAgreementReq;
 289
 290         typedef struct {
 291                 KEY_AGREEMENT_HANDLE* KeyAgreementHandle;
 292                 KERBERR* KerbErr;
 293                 uint32 *EncodedPubKeyLen;
 294                 [size_is(, *EncodedPubKeyLen)] uint8 ** EncodedPubKey;
 295         } CreateECDHKeyAgreementResp;
 296
 297         typedef struct {
 298                 // This [case(RemoteCallKerb)] struct has no input parameters, but for
 299                 // simplicity and consistency with the other parameters, let's define
 300                 // this as a [case(RemoteCallKerb)] struct with a single ignored value.
 301                 UCHAR Ignored;
 302         } CreateDHKeyAgreementReq;
 303
 304         typedef struct {
 305                 KERB_RPC_CRYPTO_API_BLOB* ModulusP;
 306                 KERB_RPC_CRYPTO_API_BLOB* GeneratorG;
 307                 KERB_RPC_CRYPTO_API_BLOB* FactorQ;
 308                 KEY_AGREEMENT_HANDLE* KeyAgreementHandle;
 309                 KERBERR* KerbErr;
 310                 uint32 *LittleEndianPublicKeyLen;
 311                 [size_is(, *LittleEndianPublicKeyLen)] uint8 ** LittleEndianPublicKey;
 312         } CreateDHKeyAgreementResp;
 313
 314         typedef struct {
 315                 KEY_AGREEMENT_HANDLE KeyAgreementHandle;
 316         } DestroyKeyAgreementReq;
 317
 318         typedef struct {
 319                 // This [case(RemoteCallKerb)] struct has no output, but for
 320                 // simplicity and consistency define as a
 321                 // [case(RemoteCallKerb)] struct with a single ignored value.
 322                 UCHAR Ignored;
 323         } DestroyKeyAgreementResp;
 324
 325         typedef struct {
 326                 KEY_AGREEMENT_HANDLE KeyAgreementHandle;
 327         } KeyAgreementGenerateNonceReq;
 328
 329         typedef struct {
 330                 uint32 *NonceLen;
 331                 [size_is(, *NonceLen)] uint8 ** Nonce;
 332         } KeyAgreementGenerateNonceResp;
 333
 334         typedef struct {
 335                 KEY_AGREEMENT_HANDLE* KeyAgreementHandle;
 336                 uint32 *KerbEType;
 337                 uint32 RemoteNonceLen;
 338                 [size_is(RemoteNonceLen)] uint8 *RemoteNonce;
 339                 uint32 X509PublicKeyLen;
 340                 [size_is(X509PublicKeyLen)] uint8 *X509PublicKey;
 341         } FinalizeKeyAgreementReq;
 342
 343         typedef struct {
 344                 KERB_RPC_ENCRYPTION_KEY* SharedKey;
 345         } FinalizeKeyAgreementResp;
 346
 347         typedef [flag(LIBNDR_FLAG_ALIGN4),switch_type(uint16)] union {
 348                 [case(RemoteCallKerbNegotiateVersion)] NegotiateVersion negociateVersion;
 349                 [case(RemoteCallKerbBuildAsReqAuthenticator)] BuildAsReqAuthenticatorReq buildAsReqAuthenticator;
 350                 [case(RemoteCallKerbVerifyServiceTicket)] VerifyServiceTicketReq verifyServiceTicket;
 351                 [case(RemoteCallKerbCreateApReqAuthenticator)] CreateApReqAuthenticatorReq createApReqAuthenticator;
 352                 [case(RemoteCallKerbDecryptApReply)] DecryptApReplyReq decryptApReply;
 353                 [case(RemoteCallKerbUnpackKdcReplyBody)] UnpackKdcReplyBodyReq unpackKdcReplyBody;
 354                 [case(RemoteCallKerbComputeTgsChecksum)] ComputeTgsChecksumReq computeTgsChecksum;
 355                 [case(RemoteCallKerbBuildEncryptedAuthData)] BuildEncryptedAuthDataReq buildEncryptedAuthData;
 356                 [case(RemoteCallKerbPackApReply)] PackApReplyReq packApReply;
 357                 [case(RemoteCallKerbHashS4UPreauth)] HashS4UPreauthReq hashS4UPreauth;
 358                 [case(RemoteCallKerbSignS4UPreauthData)] SignS4UPreauthDataReq signS4UPreauthData;
 359                 [case(RemoteCallKerbVerifyChecksum)] VerifyChecksumReq verifyChecksum;
 360                 [case(RemoteCallKerbDecryptPacCredentials)] DecryptPacCredentialsReq decryptPacCredentials;
 361                 [case(RemoteCallKerbCreateECDHKeyAgreement)] CreateECDHKeyAgreementReq createECDHKeyAgreement;
 362                 [case(RemoteCallKerbCreateDHKeyAgreement)] CreateDHKeyAgreementReq createDHKeyAgreement;
 363                 [case(RemoteCallKerbDestroyKeyAgreement)] DestroyKeyAgreementReq destroyKeyAgreement;
 364                 [case(RemoteCallKerbKeyAgreementGenerateNonce)] KeyAgreementGenerateNonceReq keyAgreementGenerateNonce;
 365                 [case(RemoteCallKerbFinalizeKeyAgreement)] FinalizeKeyAgreementReq finalizeKeyAgreement;
 366         } KerbInputUnion;
 367
 368
 369         [public]
 370         typedef struct {
 371                 // CallId determines the call being sent over the wire.
 372                 RemoteGuardCallId CallId;
 373                 // Input paramters are held in a union so that each call can be sent
 374                 // over the wire in the same type of KerbCredIsoRemoteInput structure.
 375                 [switch_type(uint16), switch_is(CallId)] KerbInputUnion callUnion;
 376         } KerbCredIsoRemoteInput;
 377
 378         typedef [flag(LIBNDR_FLAG_ALIGN4), switch_type(uint16)]union {
 379                 [case(RemoteCallKerbNegotiateVersion)] NegotiateVersion negociateVersion;
 380                 [case(RemoteCallKerbBuildAsReqAuthenticator)] BuildAsReqAuthenticatorResp buildAsReqAuthenticator;
 381                 [case(RemoteCallKerbVerifyServiceTicket)] VerifyServiceTicketResp verifyServiceTicket;
 382                 [case(RemoteCallKerbCreateApReqAuthenticator)] CreateApReqAuthenticatorResp createApReqAuthenticator;
 383                 [case(RemoteCallKerbDecryptApReply)] DecryptApReplyResp decryptApReply;
 384                 [case(RemoteCallKerbUnpackKdcReplyBody)] UnpackKdcReplyBodyResp unpackKdcReplyBody;
 385                 [case(RemoteCallKerbComputeTgsChecksum)] ComputeTgsChecksumResp computeTgsChecksum;
 386                 [case(RemoteCallKerbBuildEncryptedAuthData)] BuildEncryptedAuthDataResp buildEncryptedAuthData;
 387                 [case(RemoteCallKerbPackApReply)] PackApReplyResp packApReply;
 388                 [case(RemoteCallKerbHashS4UPreauth)] HashS4UPreauthResp hashS4UPreauth;
 389                 [case(RemoteCallKerbSignS4UPreauthData)] SignS4UPreauthDataResp signS4UPreauthData;
 390                 [case(RemoteCallKerbVerifyChecksum)] VerifyChecksumResp verifyChecksum;
 391                 [case(RemoteCallKerbDecryptPacCredentials)] DecryptPacCredentialsResp decryptPacCredentials;
 392                 [case(RemoteCallKerbCreateECDHKeyAgreement)] CreateECDHKeyAgreementResp createECDHKeyAgreement;
 393                 [case(RemoteCallKerbCreateDHKeyAgreement)] CreateDHKeyAgreementResp createDHKeyAgreement;
 394                 [case(RemoteCallKerbDestroyKeyAgreement)] DestroyKeyAgreementResp destroyKeyAgreement;
 395                 [case(RemoteCallKerbKeyAgreementGenerateNonce)] KeyAgreementGenerateNonceResp keyAgreementGenerateNonce;
 396                 [case(RemoteCallKerbFinalizeKeyAgreement)] FinalizeKeyAgreementResp finalizeKeyAgreement;
 397         } KerbOutputUnion;
 398
 399         [public]
 400         typedef struct {
 401                 // CallId determines the call being sent over the wire.
 402                 RemoteGuardCallId CallId;
 403                 NTSTATUS Status;
 404
 405                 // Input paramters are held in a union so that each call can be sent
 406                 // over the wire in the same type of KerbCredIsoRemoteInput structure.
 407                 [switch_type(RemoteGuardCallId), switch_is(CallId)] KerbOutputUnion callUnion;
 408         } KerbCredIsoRemoteOutput;
 409
 410 // ==================================== NTLM =============================================
 411         typedef struct {
 412              // UCHAR Data[MSV1_0_RESPONSE_LENGTH];
 413          } NT_RESPONSE;
 414
 415         typedef struct _NT_CHALLENGE{
 416                 //UCHAR Data[MSV1_0_CHALLENGE_LENGTH];
 417         } NT_CHALLENGE;
 418         typedef struct NT_CHALLENGE *PNT_CHALLENGE;
 419
 420         typedef NT_CHALLENGE LM_SESSION_KEY;
 421
 422         typedef struct {
 423                 //UCHAR Response[MSV1_0_NTLM3_RESPONSE_LENGTH];
 424                 //UCHAR ChallengeFromClient[MSV1_0_CHALLENGE_LENGTH];
 425         } MSV1_0_LM3_RESPONSE;
 426         typedef struct MSV1_0_LM3_RESPONSE *PMSV1_0_LM3_RESPONSE;
 427
 428         typedef struct {
 429                 //UCHAR Data[MSV1_0_USER_SESSION_KEY_LENGTH];
 430         } USER_SESSION_KEY;
 431         typedef struct PUSER_SESSION_KEY *PUSER_SESSION_KEY;
 432
 433         typedef struct {
 434                 //UCHAR Data[MSV1_0_CREDENTIAL_KEY_LENGTH];
 435         } MSV1_0_CREDENTIAL_KEY;
 436         typedef struct MSV1_0_CREDENTIAL_KEY* PMSV1_0_CREDENTIAL_KEY;
 437
 438         typedef struct _MSV1_0_REMOTE_ENCRYPTED_SECRETS {
 439                 BOOL reserved1;
 440                 BOOL reserved2;
 441                 BOOL reserved3;
 442                 MSV1_0_CREDENTIAL_KEY reserved4;
 443                 MSV1_0_CREDENTIAL_KEY reserved5;
 444                 uint32 reservedSize;
 445                 [size_is(reservedSize)] UCHAR* reserved6;
 446         } MSV1_0_REMOTE_ENCRYPTED_SECRETS;
 447         typedef struct MSV1_0_REMOTE_ENCRYPTED_SECRETS *PMSV1_0_REMOTE_ENCRYPTED_SECRETS;
 448
 449         // Use the provided credential and challenge to generate the
 450         // NT and LM response for the NTLM v2 authentication protocol.
 451         typedef struct {
 452                 PMSV1_0_REMOTE_ENCRYPTED_SECRETS Credential;
 453                 PRPC_UNICODE_STRING UserName;
 454                 PRPC_UNICODE_STRING LogonDomainName;
 455                 PRPC_UNICODE_STRING ServerName;
 456                 //UCHAR ChallengeToClient[MSV1_0_CHALLENGE_LENGTH];
 457         } Lm20GetNtlm3ChallengeResponseReq;
 458
 459         typedef struct {
 460                 uint16 Ntlm3ResponseLength;
 461                 [size_is(Ntlm3ResponseLength)] uint8 *Ntlm3Response;
 462                 MSV1_0_LM3_RESPONSE Lm3Response;
 463                 USER_SESSION_KEY UserSessionKey;
 464                 LM_SESSION_KEY LmSessionKey;
 465         } Lm20GetNtlm3ChallengeResponseResp;
 466
 467         typedef struct {
 468                 PNT_CHALLENGE NtChallenge;
 469                 PMSV1_0_REMOTE_ENCRYPTED_SECRETS Credential;
 470         } CalculateNtResponseReq;
 471
 472         typedef struct {
 473                 NT_RESPONSE NtResponse;
 474         } CalculateNtResponseResp;
 475
 476         // Use the provided credential and response to calculate
 477         // a session key according to the NTLM v1 protocol.
 478         typedef struct {
 479                 NT_RESPONSE *NtResponse;
 480                 PMSV1_0_REMOTE_ENCRYPTED_SECRETS Credential;
 481         } CalculateUserSessionKeyNtReq;
 482
 483         typedef struct {
 484                 USER_SESSION_KEY UserSessionKey;
 485         } CalculateUserSessionKeyNtResp;
 486
 487         // Compare the provided credentials to determine whether
 488         // they're identical.
 489         typedef struct  {
 490                 PMSV1_0_REMOTE_ENCRYPTED_SECRETS LhsCredential;
 491                 PMSV1_0_REMOTE_ENCRYPTED_SECRETS RhsCredential;
 492         } CompareCredentialsReq;
 493
 494         typedef struct {
 495                 BOOL AreNtOwfsEqual;
 496                 BOOL AreLmOwfsEqual;
 497                 BOOL AreShaOwfsEqual;
 498         } CompareCredentialsResp;
 499
 500         typedef [flag(LIBNDR_FLAG_ALIGN4), switch_type(uint16)] union {
 501                 [case(RemoteCallNtlmNegotiateVersion)] NegotiateVersion negotiateVersion;
 502                 [case(RemoteCallNtlmLm20GetNtlm3ChallengeResponse)] Lm20GetNtlm3ChallengeResponseReq lm20GetNtlm3ChallengeResponse;
 503                 [case(RemoteCallNtlmCalculateNtResponse)] CalculateNtResponseReq calculateNtResponse;
 504                 [case(RemoteCallNtlmCalculateUserSessionKeyNt)] CalculateUserSessionKeyNtReq calculateUserSessionKeyNt;
 505                 [case(RemoteCallNtlmCompareCredentials)] CompareCredentialsReq compareCredentials;
 506         } NtlmCredInput;
 507
 508         [public]
 509         typedef struct {
 510                 RemoteGuardCallId CallId;
 511                 [switch_type(RemoteGuardCallId), switch_is(CallId)] NtlmCredInput callUnion;
 512         } NtlmCredIsoRemoteInput;
 513
 514
 515         typedef [flag(LIBNDR_FLAG_ALIGN4), switch_type(uint16)] union {
 516                 [case(RemoteCallNtlmNegotiateVersion)] NegotiateVersion negotiateVersion;
 517                 [case(RemoteCallNtlmLm20GetNtlm3ChallengeResponse)] Lm20GetNtlm3ChallengeResponseResp lm20GetNtlm3ChallengeResponse;
 518                 [case(RemoteCallNtlmCalculateNtResponse)] CalculateNtResponseResp calculateNtResponse;
 519                 [case(RemoteCallNtlmCalculateUserSessionKeyNt)] CalculateUserSessionKeyNtResp calculateUserSessionKeyNt;
 520                 [case(RemoteCallNtlmCompareCredentials)] CompareCredentialsResp compareCredentials;
 521         } NtlmCredOutput;
 522
 523         [public]
 524         typedef struct {
 525                 RemoteGuardCallId CallId;
 526                 NTSTATUS Status;
 527                 [switch_type(RemoteGuardCallId), switch_is(CallId)] NtlmCredOutput callUnion;
 528         } NtlmCredIsoRemoteOutput;
 529
 530
 531 }