librpc/idl/drsblobs.idl

   1 #include "idl_types.h"
   2
   3 import "drsuapi.idl", "misc.idl", "samr.idl", "lsa.idl";
   4
   5 [
   6   uuid("12345778-1234-abcd-0001-00000001"),
   7   version(0.0),
   8   pointer_default(unique),
   9   helper("../librpc/ndr/ndr_drsblobs.h"),
  10   helpstring("Active Directory Replication LDAP Blobs")
  11 ]
  12 interface drsblobs {
  13         typedef bitmap drsuapi_DsReplicaSyncOptions drsuapi_DsReplicaSyncOptions;
  14         typedef bitmap drsuapi_DsReplicaNeighbourFlags drsuapi_DsReplicaNeighbourFlags;
  15         typedef [v1_enum] enum drsuapi_DsAttributeId drsuapi_DsAttributeId;
  16         typedef [v1_enum] enum lsa_TrustAuthType lsa_TrustAuthType;
  17         /*
  18          * replPropertyMetaData
  19          * w2k  uses version 1
  20          * w2k3 uses version 1
  21          */
  22         typedef struct {
  23                 drsuapi_DsAttributeId attid;
  24                 uint32 version;
  25                 NTTIME_1sec originating_change_time;
  26                 GUID originating_invocation_id;
  27                 hyper originating_usn;
  28                 hyper local_usn;
  29         } replPropertyMetaData1;
  30
  31         typedef struct {
  32                 uint32 count;
  33                 uint32 reserved;
  34                 replPropertyMetaData1 array[count];
  35         } replPropertyMetaDataCtr1;
  36
  37         typedef [nodiscriminant] union {
  38                 [case(1)] replPropertyMetaDataCtr1 ctr1;
  39         } replPropertyMetaDataCtr;
  40
  41         typedef [public] struct {
  42                 uint32 version;
  43                 uint32 reserved;
  44                 [switch_is(version)] replPropertyMetaDataCtr ctr;
  45         } replPropertyMetaDataBlob;
  46
  47         void decode_replPropertyMetaData(
  48                 [in] replPropertyMetaDataBlob blob
  49                 );
  50
  51         /*
  52          * replUpToDateVector
  53          * w2k  uses version 1
  54          * w2k3 uses version 2
  55          */
  56         typedef struct {
  57                 uint32 count;
  58                 uint32 reserved;
  59                 drsuapi_DsReplicaCursor cursors[count];
  60         } replUpToDateVectorCtr1;
  61
  62         typedef struct {
  63                 uint32 count;
  64                 uint32 reserved;
  65                 drsuapi_DsReplicaCursor2 cursors[count];
  66         } replUpToDateVectorCtr2;
  67
  68         typedef [nodiscriminant] union {
  69                 [case(1)] replUpToDateVectorCtr1 ctr1;
  70                 [case(2)] replUpToDateVectorCtr2 ctr2;
  71         } replUpToDateVectorCtr;
  72
  73         typedef [public] struct {
  74                 uint32 version;
  75                 uint32 reserved;
  76                 [switch_is(version)] replUpToDateVectorCtr ctr;
  77         } replUpToDateVectorBlob;
  78
  79         void decode_replUpToDateVector(
  80                 [in] replUpToDateVectorBlob blob
  81                 );
  82
  83         /*
  84          * repsFrom/repsTo
  85          * w2k  uses version 1
  86          * w2k3 uses version 1
  87          */
  88         typedef [public,gensize] struct {
  89                 [value(strlen(dns_name)+1)] uint32 __dns_name_size;
  90                 [charset(DOS)] uint8 dns_name[__dns_name_size];
  91         } repsFromTo1OtherInfo;
  92
  93         typedef [public,gensize,flag(NDR_PAHEX)] struct {
  94                 /* this includes the 8 bytes of the repsFromToBlob header */
  95                 [value(ndr_size_repsFromTo1(this, ndr->iconv_convenience, ndr->flags)+8)] uint32 blobsize;
  96                 uint32 consecutive_sync_failures;
  97                 NTTIME_1sec last_success;
  98                 NTTIME_1sec last_attempt;
  99                 WERROR result_last_attempt;
 100                 [relative] repsFromTo1OtherInfo *other_info;
 101                 [value(ndr_size_repsFromTo1OtherInfo(other_info, ndr->iconv_convenience, ndr->flags))] uint32 other_info_length;
 102                 drsuapi_DsReplicaNeighbourFlags replica_flags;
 103                 uint8 schedule[84];
 104                 uint32 reserved;
 105                 drsuapi_DsReplicaHighWaterMark highwatermark;
 106                 GUID source_dsa_obj_guid; /* the 'objectGuid' field of the CN=NTDS Settings object */
 107                 GUID source_dsa_invocation_id; /* the 'invocationId' field of the CN=NTDS Settings object */
 108                 GUID transport_guid;
 109         } repsFromTo1;
 110
 111         typedef [nodiscriminant] union {
 112                 [case(1)] repsFromTo1 ctr1;
 113         } repsFromTo;
 114
 115         typedef [public] struct {
 116                 uint32 version;
 117                 uint32 reserved;
 118                 [switch_is(version)] repsFromTo ctr;
 119         } repsFromToBlob;
 120
 121         void decode_repsFromTo(
 122                 [in] repsFromToBlob blob
 123                 );
 124
 125         /*
 126          * partialAttributeSet
 127          * w2k  uses version 1
 128          * w2k3 uses version 1
 129          */
 130         typedef struct {
 131                 uint32 count;
 132                 drsuapi_DsAttributeId array[count];
 133         } partialAttributeSetCtr1;
 134
 135         typedef [nodiscriminant] union {
 136                 [case(1)] partialAttributeSetCtr1 ctr1;
 137         } partialAttributeSetCtr;
 138
 139         typedef [public] struct {
 140                 uint32 version;
 141                 uint32 reserved;
 142                 [switch_is(version)] partialAttributeSetCtr ctr;
 143         } partialAttributeSetBlob;
 144
 145         void decode_partialAttributeSet(
 146                 [in] partialAttributeSetBlob blob
 147                 );
 148
 149         /*
 150          * prefixMap
 151          * w2k  unknown
 152          * w2k3 unknown
 153          * samba4 uses 0x44534442 'DSDB'
 154          *
 155          * as we windows don't return the prefixMap attribute when you ask for
 156          * we don't know the format, but the attribute is not replicated
 157          * so that we can choose our own format...
 158          */
 159         typedef [v1_enum] enum {
 160                 PREFIX_MAP_VERSION_DSDB = 0x44534442
 161         } prefixMapVersion;
 162
 163         typedef [nodiscriminant] union {
 164                 [case(PREFIX_MAP_VERSION_DSDB)] drsuapi_DsReplicaOIDMapping_Ctr dsdb;
 165         } prefixMapCtr;
 166
 167         typedef [public] struct {
 168                 prefixMapVersion version;
 169                 uint32 reserved;
 170                 [switch_is(version)] prefixMapCtr ctr;
 171         } prefixMapBlob;
 172
 173         void decode_prefixMap(
 174                 [in] prefixMapBlob blob
 175                 );
 176
 177
 178         /*
 179          * the cookie for the LDAP dirsync control
 180          */
 181         typedef [nodiscriminant,gensize] union {
 182                 [case(0)];
 183                 [default] replUpToDateVectorBlob uptodateness_vector;
 184         } ldapControlDirSyncExtra;
 185
 186         typedef struct {
 187                 [value(3)] uint32 u1;
 188                 NTTIME time;
 189                 uint32 u2;
 190                 uint32 u3;
 191                 [value(ndr_size_ldapControlDirSyncExtra(&extra, extra.uptodateness_vector.version, ndr->iconv_convenience, 0))]
 192                         uint32 extra_length;
 193                 drsuapi_DsReplicaHighWaterMark highwatermark;
 194                 GUID guid1;
 195                 [switch_is(extra_length)] ldapControlDirSyncExtra extra;
 196         } ldapControlDirSyncBlob;
 197
 198         typedef [public,relative_base] struct {
 199                 [charset(DOS),value("MSDS")] uint8 msds[4];
 200                 [subcontext(0)] ldapControlDirSyncBlob blob;
 201         } ldapControlDirSyncCookie;
 202
 203         void decode_ldapControlDirSync(
 204                 [in] ldapControlDirSyncCookie cookie
 205                 );
 206
 207         typedef struct {
 208                 [value(2*strlen_m(name))] uint16 name_len;
 209                 [value(strlen(data))] uint16 data_len;
 210                 uint16 reserved; /* 2 for 'Packages', 1 for 'Primary:*', but should be ignored */
 211                 [charset(UTF16)] uint8 name[name_len];
 212                 /*
 213                  * the data field contains data as HEX strings
 214                  *
 215                  * 'Packages':
 216                  *   data contains the list of packages
 217                  *   as non termiated UTF16 strings with
 218                  *   a UTF16 NULL byte as separator
 219                  *
 220                  * 'Primary:Kerberos-Newer-Keys':
 221                  *    ...
 222                  *
 223                  * 'Primary:Kerberos':
 224                  *    ...
 225                  *
 226                  * 'Primary:WDigest':
 227                  *    ...
 228                  *
 229                  * 'Primary:CLEARTEXT':
 230                  *    data contains the cleartext password
 231                  *    as UTF16 string encoded as HEX string
 232                  */
 233                 [charset(DOS)] uint8 data[data_len];
 234         } supplementalCredentialsPackage;
 235
 236         /* this are 0x30 (48) whitespaces (0x20) */
 237         const string SUPPLEMENTAL_CREDENTIALS_PREFIX = "                                                ";
 238
 239         typedef [flag(NDR_PAHEX)] enum {
 240                 SUPPLEMENTAL_CREDENTIALS_SIGNATURE = 0x0050
 241         } supplementalCredentialsSignature;
 242
 243         typedef [gensize] struct {
 244                 [value(SUPPLEMENTAL_CREDENTIALS_PREFIX),charset(UTF16)] uint16 prefix[0x30];
 245                 [value(SUPPLEMENTAL_CREDENTIALS_SIGNATURE)] supplementalCredentialsSignature signature;
 246                 uint16 num_packages;
 247                 supplementalCredentialsPackage packages[num_packages];
 248         } supplementalCredentialsSubBlob;
 249
 250         typedef [public] struct {
 251                 [value(0)] uint32 unknown1;
 252                 [value(ndr_size_supplementalCredentialsSubBlob(&sub, ndr->iconv_convenience, ndr->flags))] uint32 __ndr_size;
 253                 [value(0)] uint32 unknown2;
 254                 [subcontext(0),subcontext_size(__ndr_size)] supplementalCredentialsSubBlob sub;
 255                 [value(0)] uint8 unknown3;
 256         } supplementalCredentialsBlob;
 257
 258         void decode_supplementalCredentials(
 259                 [in] supplementalCredentialsBlob blob
 260                 );
 261
 262         typedef [public] struct {
 263                 [flag(STR_NOTERM|NDR_REMAINING)] string_array names;
 264         } package_PackagesBlob;
 265
 266         void decode_Packages(
 267                 [in] package_PackagesBlob blob
 268                 );
 269
 270         typedef struct {
 271                 [value(2*strlen_m(string))] uint16 length;
 272                 [value(2*strlen_m(string))] uint16 size;
 273                 [relative,subcontext(0),subcontext_size(size),flag(STR_NOTERM|NDR_REMAINING)] string *string;
 274         } package_PrimaryKerberosString;
 275
 276         typedef struct {
 277                 [value(0)] uint16 reserved1;
 278                 [value(0)] uint16 reserved2;
 279                 [value(0)] uint32 reserved3;
 280                 uint32 keytype;
 281                 [value((value?value->length:0))] uint32 value_len;
 282                 [relative,subcontext(0),subcontext_size(value_len),flag(NDR_REMAINING)] DATA_BLOB *value;
 283         } package_PrimaryKerberosKey3;
 284
 285         typedef struct {
 286                 uint16 num_keys;
 287                 uint16 num_old_keys;
 288                 package_PrimaryKerberosString salt;
 289                 package_PrimaryKerberosKey3 keys[num_keys];
 290                 package_PrimaryKerberosKey3 old_keys[num_old_keys];
 291                 [value(0)] uint32 padding1;
 292                 [value(0)] uint32 padding2;
 293                 [value(0)] uint32 padding3;
 294                 [value(0)] uint32 padding4;
 295                 [value(0)] uint32 padding5;
 296         } package_PrimaryKerberosCtr3;
 297
 298         typedef struct {
 299                 [value(0)] uint16 reserved1;
 300                 [value(0)] uint16 reserved2;
 301                 [value(0)] uint32 reserved3;
 302                 uint32 iteration_count;
 303                 uint32 keytype;
 304                 [value((value?value->length:0))] uint32 value_len;
 305                 [relative,subcontext(0),subcontext_size(value_len),flag(NDR_REMAINING)] DATA_BLOB *value;
 306         } package_PrimaryKerberosKey4;
 307
 308         typedef struct {
 309                 uint16 num_keys;
 310                 [value(0)] uint16 num_service_keys;
 311                 uint16 num_old_keys;
 312                 uint16 num_older_keys;
 313                 package_PrimaryKerberosString salt;
 314                 uint32 default_iteration_count;
 315                 package_PrimaryKerberosKey4 keys[num_keys];
 316                 package_PrimaryKerberosKey4 service_keys[num_service_keys];
 317                 package_PrimaryKerberosKey4 old_keys[num_old_keys];
 318                 package_PrimaryKerberosKey4 older_keys[num_older_keys];
 319         } package_PrimaryKerberosCtr4;
 320
 321         typedef [nodiscriminant] union {
 322                 [case(3)] package_PrimaryKerberosCtr3 ctr3;
 323                 [case(4)] package_PrimaryKerberosCtr4 ctr4;
 324         } package_PrimaryKerberosCtr;
 325
 326         typedef [public] struct {
 327                 uint16 version;
 328                 [value(0)] uint16 flags;
 329                 [switch_is(version)] package_PrimaryKerberosCtr ctr;
 330         } package_PrimaryKerberosBlob;
 331
 332         void decode_PrimaryKerberos(
 333                 [in] package_PrimaryKerberosBlob blob
 334                 );
 335
 336         typedef [public] struct {
 337                 [flag(NDR_REMAINING)] DATA_BLOB cleartext;
 338         } package_PrimaryCLEARTEXTBlob;
 339
 340         void decode_PrimaryCLEARTEXT(
 341                 [in] package_PrimaryCLEARTEXTBlob blob
 342                 );
 343
 344         typedef [flag(NDR_PAHEX)] struct {
 345                 uint8 hash[16];
 346         } package_PrimaryWDigestHash;
 347
 348         typedef [public] struct {
 349                 [value(0x31)] uint16 unknown1;
 350                 [value(0x01)] uint8  unknown2;
 351                 uint8  num_hashes;
 352                 [value(0)] uint32 unknown3;
 353                 [value(0)] udlong uuknown4;
 354                 package_PrimaryWDigestHash hashes[num_hashes];
 355         } package_PrimaryWDigestBlob;
 356
 357         void decode_PrimaryWDigest(
 358                 [in] package_PrimaryWDigestBlob blob
 359                 );
 360
 361         typedef struct {
 362                 [value(0)] uint32 size;
 363         } AuthInfoNone;
 364
 365         typedef struct {
 366                 [value(16)] uint32 size;
 367                 samr_Password password;
 368         } AuthInfoNT4Owf;
 369
 370         /*
 371          * the secret value is encoded as UTF16 if it's a string
 372          * but depending the AuthType, it might also be krb5 trusts have random bytes here, so converting to UTF16
 373          * mayfail...
 374          *
 375          * TODO: We should try handle the case of a random buffer in all places
 376          *       we deal with cleartext passwords from windows
 377          *
 378          * so we don't use this:
 379          *
 380          * uint32 value_len;
 381          * [charset(UTF16)] uint8 value[value_len];
 382          */
 383
 384         typedef struct {
 385                 uint32 size;
 386                 uint8 password[size];
 387         } AuthInfoClear;
 388
 389         typedef struct {
 390                 [value(4)] uint32 size;
 391                  uint32 version;
 392         } AuthInfoVersion;
 393
 394         typedef [nodiscriminant] union {
 395                 [case(TRUST_AUTH_TYPE_NONE)] AuthInfoNone none;
 396                 [case(TRUST_AUTH_TYPE_NT4OWF)] AuthInfoNT4Owf nt4owf;
 397                 [case(TRUST_AUTH_TYPE_CLEAR)] AuthInfoClear clear;
 398                 [case(TRUST_AUTH_TYPE_VERSION)] AuthInfoVersion version;
 399         } AuthInfo;
 400
 401         typedef [public] struct {
 402                 NTTIME LastUpdateTime;
 403                 lsa_TrustAuthType AuthType;
 404
 405                 [switch_is(AuthType)] AuthInfo AuthInfo;
 406                 [flag(NDR_ALIGN4)] DATA_BLOB _pad;
 407         } AuthenticationInformation;
 408
 409         typedef [nopull,nopush,noprint] struct {
 410                 /* sizeis here is bogus, but this is here just for the structure */
 411                 [size_is(1)] AuthenticationInformation array[];
 412         } AuthenticationInformationArray;
 413
 414         /* This is nopull,nopush because we pass count down to the
 415          * manual parser of AuthenticationInformationArray */
 416         typedef [public,nopull,nopush,noprint,gensize] struct {
 417                 uint32 count;
 418                 [relative] AuthenticationInformationArray *current;
 419                 [relative] AuthenticationInformationArray *previous;
 420         } trustAuthInOutBlob;
 421
 422         void decode_trustAuthInOut(
 423                 [in] trustAuthInOutBlob blob
 424                 );
 425
 426         typedef [public,gensize] struct {
 427                 uint32 count;
 428                 [relative] AuthenticationInformation *current[count];
 429         } trustCurrentPasswords;
 430
 431         typedef [public,nopull] struct {
 432                 uint8 confounder[512];
 433                 [subcontext(0),subcontext_size(outgoing_size)] trustCurrentPasswords outgoing;
 434                 [subcontext(0),subcontext_size(incoming_size)] trustCurrentPasswords incoming;
 435                 [value(ndr_size_trustCurrentPasswords(&outgoing, ndr->iconv_convenience, ndr->flags))] uint32 outgoing_size;
 436                 [value(ndr_size_trustCurrentPasswords(&incoming, ndr->iconv_convenience, ndr->flags))] uint32 incoming_size;
 437         } trustDomainPasswords;
 438
 439         void decode_trustDomainPasswords(
 440                 [in] trustDomainPasswords blob
 441                 );
 442
 443         typedef [public] struct {
 444                 uint32 marker;
 445                 DATA_BLOB data;
 446         } DsCompressedChunk;
 447
 448         typedef struct {
 449                 uint16 __size;
 450                 [size_is(__size),charset(DOS)] uint8 *string;
 451         } ExtendedErrorAString;
 452
 453         typedef struct {
 454                 uint16 __size;
 455                 [size_is(__size),charset(UTF16)] uint16 *string;
 456         } ExtendedErrorUString;
 457
 458         typedef struct {
 459                 uint16 length;
 460                 [size_is(length)] uint8 *data;
 461         } ExtendedErrorBlob;
 462
 463         typedef enum {
 464                 EXTENDED_ERROR_COMPUTER_NAME_PRESENT    = 1,
 465                 EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT= 2
 466         } ExtendedErrorComputerNamePresent;
 467
 468         typedef [switch_type(ExtendedErrorComputerNamePresent)] union {
 469         [case(EXTENDED_ERROR_COMPUTER_NAME_PRESENT)] ExtendedErrorUString name;
 470         [case(EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT)];
 471         } ExtendedErrorComputerNameU;
 472
 473         typedef struct {
 474                 ExtendedErrorComputerNamePresent present;
 475                 [switch_is(present)] ExtendedErrorComputerNameU n;
 476         } ExtendedErrorComputerName;
 477
 478         typedef enum {
 479                 EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING          = 1,
 480                 EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING        = 2,
 481                 EXTENDED_ERROR_PARAM_TYPE_UINT32                = 3,
 482                 EXTENDED_ERROR_PARAM_TYPE_UINT16                = 4,
 483                 EXTENDED_ERROR_PARAM_TYPE_UINT64                = 5,
 484                 EXTENDED_ERROR_PARAM_TYPE_NONE                  = 6,
 485                 EXTENDED_ERROR_PARAM_TYPE_BLOB                  = 7
 486         } ExtendedErrorParamType;
 487
 488         typedef [switch_type(ExtendedErrorParamType)] union {
 489         [case(EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING)] ExtendedErrorAString a_string;
 490         [case(EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING)] ExtendedErrorUString u_string;
 491         [case(EXTENDED_ERROR_PARAM_TYPE_UINT32)] uint32 uint32;
 492         [case(EXTENDED_ERROR_PARAM_TYPE_UINT16)] uint16 uint16;
 493         [case(EXTENDED_ERROR_PARAM_TYPE_UINT64)] hyper uint64;
 494         [case(EXTENDED_ERROR_PARAM_TYPE_NONE)];
 495         [case(EXTENDED_ERROR_PARAM_TYPE_BLOB)] ExtendedErrorBlob blob;
 496         } ExtendedErrorParamU;
 497
 498         typedef struct {
 499                 ExtendedErrorParamType type;
 500                 [switch_is(type)] ExtendedErrorParamU p;
 501         } ExtendedErrorParam;
 502
 503         typedef [public] struct {
 504                 ExtendedErrorInfo *next;
 505                 ExtendedErrorComputerName computer_name;
 506                 hyper pid;
 507                 NTTIME time;
 508                 uint32 generating_component;
 509                 WERROR status;
 510                 uint16 detection_location;
 511                 uint16 flags;
 512                 uint16 num_params;
 513                 [size_is(num_params)] ExtendedErrorParam params[];
 514         } ExtendedErrorInfo;
 515
 516         typedef struct {
 517                 [unique] ExtendedErrorInfo *info;
 518         } ExtendedErrorInfoPtr;
 519
 520         void decode_ExtendedErrorInfo (
 521                 [in,subcontext(0xFFFFFC01)] ExtendedErrorInfoPtr ptr
 522                 );
 523 }