source4/scripting/python/samba/samr.py

   1 import dcerpc
   2
   3 def sid_to_string(sid):
   4     """Convert a Python dictionary SID to a string SID."""
   5
   6     result = 'S-%d' % sid.sid_rev_num
   7
   8     result = result + '-%u' % \
   9              (dcerpc.uint8_array_getitem(sid.id_auth, 5) +
  10               (dcerpc.uint8_array_getitem(sid.id_auth, 4) << 8) +
  11               (dcerpc.uint8_array_getitem(sid.id_auth, 3) << 16) +
  12               (dcerpc.uint8_array_getitem(sid.id_auth, 2) << 24))
  13
  14     for i in range(0, sid.num_auths):
  15         result = result + '-%u' % \
  16                  dcerpc.uint32_array_getitem(sid.sub_auths, i)
  17
  18     return result
  19
  20 def string_to_sid(string):
  21     """Convert a string SID to a Python dictionary SID.  Throws a
  22     ValueError if the SID string was badly formed."""
  23
  24     if string[0] != 'S':
  25         raise ValueError('Bad SID format')
  26
  27     string = string[1:]
  28
  29     import re
  30
  31     match = re.match('-\d+', string)
  32
  33     if not match:
  34         raise ValueError('Bad SID format')
  35
  36     try:
  37         sid_rev_num = int(string[match.start()+1:match.end()])
  38     except ValueError:
  39         raise ValueError('Bad SID format')
  40
  41     string = string[match.end():]
  42
  43     match = re.match('-\d+', string)
  44
  45     if not match:
  46         raise ValueError('Bad SID format')
  47
  48     try:
  49         ia = int(string[match.start()+1:match.end()])
  50     except ValueError:
  51         raise ValueError('Bad SID format')
  52
  53     string = string[match.end():]
  54
  55     id_auth = [0, 0, (ia >> 24) & 0xff, (ia >> 16) & 0xff,
  56                (ia >> 8) & 0xff, ia & 0xff]
  57
  58     num_auths = 0
  59     sub_auths = []
  60
  61     while len(string):
  62
  63         match = re.match('-\d+', string)
  64
  65         if not match:
  66             raise ValueError('Bad SID format')
  67
  68         try:
  69             sa = int(string[match.start() + 1 : match.end()])
  70         except ValueError:
  71             raise ValueError('Bad SID format')
  72
  73         num_auths = num_auths + 1
  74         sub_auths.append(int(sa))
  75
  76         string = string[match.end():]
  77
  78     sid = dcerpc.dom_sid()
  79     sid.sid_rev_num = sid_rev_num
  80     sid.id_auth = dcerpc.new_uint8_array(6)
  81     for i in range(6):
  82         dcerpc.uint8_array_setitem(sid.id_auth, i, id_auth[i])
  83     sid.num_auths = num_auths
  84     sid.sub_auths = dcerpc.new_uint32_array(num_auths)
  85     for i in range(num_auths):
  86         dcerpc.uint32_array_setitem(sid.sub_auths, i, sub_auths[i])
  87
  88     return sid
  89
  90 def call_fn(fn, pipe, args):
  91     """Wrap up a RPC call and throw an exception is an error was returned."""
  92
  93     result = fn(pipe, args);
  94
  95     if result & 0xc0000000L:
  96         raise dcerpc.NTSTATUS(result, dcerpc.nt_errstr(result));
  97
  98     return result;
  99
 100
 101 class SamrHandle(object):
 102
 103     def __init__(self, pipe, handle):
 104
 105         self.pipe = pipe
 106         self.handle = handle
 107
 108     def __del__(self):
 109
 110         if self.handle is not None:
 111             self.Close()
 112
 113     def Close(self):
 114
 115         r = dcerpc.samr_Close()
 116         r.data_in.handle = self.handle
 117
 118         call_fn(dcerpc.dcerpc_samr_Close, self.pipe, r)
 119
 120         self.handle = None
 121
 122     def QuerySecurity(self, sec_info = 7):
 123
 124         r = dcerpc.samr_QuerySecurity()
 125         r.data_in.handle = self.handle
 126         r.data_in.sec_info = sec_info
 127
 128         call_fn(dcerpc.dcerpc_samr_QuerySecurity, self.pipe, r)
 129
 130         return r.data_out.sdbuf
 131
 132     def SetSecurity(self, sdbuf, sec_info = 7):
 133
 134         r = dcerpc.samr_SetSecurity()
 135         r.data_in.handle = self.handle
 136         r.data_in.sec_info = sec_info
 137         r.data_in.sdbuf = sdbuf
 138
 139         call_fn(dcerpc.dcerpc_samr_SetSecurity, self.pipe, r)
 140
 141
 142 class ConnectHandle(SamrHandle):
 143
 144     def EnumDomains(self):
 145
 146         r = dcerpc.samr_EnumDomains()
 147         r.data_in.connect_handle = self.handle
 148         r.data_in.resume_handle = 0
 149         r.data_in.buf_size = -1
 150
 151         domains = []
 152
 153         while 1:
 154
 155             call_fn(dcerpc.dcerpc_samr_EnumDomains, self.pipe, r)
 156
 157             for i in range(r.data_out.sam.count):
 158                 domains.append(dcerpc.samr_SamEntry_array_getitem(
 159                     r.data_out.sam.entries, i).name.string)
 160
 161             # TODO: Handle more entries here
 162
 163             break
 164
 165         return domains
 166
 167     def LookupDomain(self, domain_name):
 168
 169         r = dcerpc.samr_LookupDomain()
 170         r.data_in.connect_handle = self.handle
 171         r.data_in.domain_name = dcerpc.samr_String()
 172         r.data_in.domain_name.string = domain_name
 173
 174         call_fn(dcerpc.dcerpc_samr_LookupDomain, self.pipe, r)
 175
 176         return sid_to_string(r.data_out.sid);
 177
 178     def OpenDomain(self, domain_sid, access_mask = 0x02000000):
 179
 180         r = dcerpc.samr_OpenDomain()
 181         r.data_in.connect_handle = self.handle
 182         r.data_in.access_mask = access_mask
 183         r.data_in.sid = string_to_sid(domain_sid)
 184
 185         call_fn(dcerpc.dcerpc_samr_OpenDomain, self.pipe, r)
 186
 187         return DomainHandle(self.pipe, r.data_out.domain_handle)
 188
 189     def Shutdown(self):
 190
 191         r = dcerpc.samr_Shutdown()
 192         r.data_in.connect_handle = self.handle
 193
 194         call_fn(dcerpc.dcerpc_samr_Shutdown, self.pipe, r)
 195
 196     def GetDomPwInfo(self, domain_name):
 197
 198         r = dcerpc.samr_GetDomPwInfo()
 199         r.data_in.domain_name = dcerpc.samr_String()
 200         r.data_in.domain_name.string = domain_name
 201
 202         call_fn(dcerpc.dcerpc_samr_GetDomPwInfo, self.pipe, r)
 203
 204         return r.data_out.info
 205
 206
 207     def SetBootKeyInformation(self, unknown1, unknown2, unknown3):
 208
 209         r = dcerpc.samr_GetBootKeyInformation()
 210         r.data_in.connect_handle = self.handle
 211         r.data_in.unknown1 = unknown1
 212         r.data_in.unknown2 = unknown2
 213         r.data_in.unknown3 = unknown3
 214
 215         call_fn(dcerpc.dcerpc_samr_SetBootKeyInformation, self.pipe, r)
 216
 217
 218 class DomainHandle(SamrHandle):
 219
 220     def QueryDomainInfo(self, level = 2):
 221
 222         r = dcerpc.samr_QueryDomainInfo()
 223         r.data_in.domain_handle = self.handle
 224         r.data_in.level = level
 225
 226         call_fn(dcerpc.dcerpc_samr_QueryDomainInfo, self.pipe, r)
 227
 228         return getattr(r.data_out.info, 'info%d' % level)
 229
 230     def QueryDomainInfo2(self, level = 2):
 231
 232         r = dcerpc.samr_QueryDomainInfo2()
 233         r.data_in.domain_handle = self.handle
 234         r.data_in.level = level
 235
 236         call_fn(dcerpc.dcerpc_samr_QueryDomainInfo2, self.pipe, r)
 237
 238         return getattr(r.data_out.info, 'info%d' % level)
 239
 240     def SetDomainInfo(self, level, info):
 241
 242         r = dcerpc.samr_SetDomainInfo()
 243         r.data_in.domain_handle = self.handle
 244         r.data_in.level = level
 245         r.data_in.info = dcerpc.samr_DomainInfo()
 246         setattr(r.data_in.info, 'info%d' % level, info)
 247
 248         call_fn(dcerpc.dcerpc_samr_SetDomainInfo, self.pipe, r)
 249
 250     def EnumDomainGroups(self):
 251
 252         r = dcerpc.samr_EnumDomainGroups()
 253         r.data_in.domain_handle = self.handle
 254         r.data_in.resume_handle = 0
 255         r.data_in.max_size = 1000
 256
 257         call_fn(dcerpc.dcerpc_samr_EnumDomainGroups, self.pipe, r)
 258
 259         groups = []
 260
 261         if r.data_out.sam.entries:
 262             for i in range(r.data_out.sam.count):
 263                 groups.append(dcerpc.samr_SamEntry_array_getitem(
 264                     r.data_out.sam.entries, i).name.string)
 265
 266         return groups
 267
 268     def EnumDomainAliases(self):
 269
 270         r = dcerpc.samr_EnumDomainAliases()
 271         r.data_in.domain_handle = self.handle
 272         r.data_in.resume_handle = 0
 273         # acct_flags in SamrEnumerateAliasesInDomain has probably
 274         # no meaning so use 0xffffffff like W2K
 275         r.data_in.acct_flags = 0xffffffffL
 276
 277         call_fn(dcerpc.dcerpc_samr_EnumDomainAliases, self.pipe, r)
 278
 279         aliases = []
 280
 281         if r.data_out.sam.entries:
 282             for i in range(r.data_out.sam.count):
 283                 aliases.append(dcerpc.samr_SamEntry_array_getitem(
 284                     r.data_out.sam.entries, i).name.string)
 285
 286         return aliases
 287
 288     def EnumDomainUsers(self, user_account_flags = 16):
 289
 290         r = dcerpc.samr_EnumDomainUsers()
 291         r.data_in.domain_handle = self.handle
 292         r.data_in.resume_handle = 0
 293         r.data_in.acct_flags = user_account_flags
 294         r.data_in.max_size = 1000
 295
 296         call_fn(dcerpc.dcerpc_samr_EnumDomainUsers, self.pipe, r)
 297
 298         users = []
 299
 300         if r.data_out.sam.entries:
 301             for i in range(r.data_out.sam.count):
 302                 users.append(dcerpc.samr_SamEntry_array_getitem(
 303                     r.data_out.sam.entries, i).name.string)
 304
 305         return users
 306
 307     def CreateUser(self, account_name, access_mask = 0x02000000):
 308
 309         r = dcerpc.samr_CreateUser()
 310         r.data_in.domain_handle = self.handle
 311         r.data_in.account_name = dcerpc.samr_String()
 312         r.data_in.account_name.string = account_name
 313         r.data_in.access_mask = access_mask
 314
 315         call_fn(dcerpc.dcerpc_samr_CreateUser, self.pipe, r)
 316
 317         return (r.data_out.user_handle,
 318                 dcerpc.uint32_array_getitem(r.data_out.rid, 0))
 319
 320     def CreateUser2(self, account_name, acct_flags = 0x00000010,
 321                     access_mask = 0x02000000):
 322
 323         r = dcerpc.samr_CreateUser2()
 324         r.data_in.domain_handle = self.handle
 325         r.data_in.account_name = dcerpc.samr_String()
 326         r.data_in.account_name.string = account_name
 327         r.data_in.acct_flags = acct_flags
 328         r.data_in.access_mask = access_mask
 329
 330         call_fn(dcerpc.dcerpc_samr_CreateUser2, self.pipe, r)
 331
 332         return (r.data_out.user_handle,
 333                 dcerpc.uint32_array_getitem(r.data_out.access_granted, 0),
 334                 dcerpc.uint32_array_getitem(r.data_out.rid, 0))
 335
 336     def OpenUser(self, rid, access_mask = 0x02000000):
 337
 338         r = dcerpc.samr_OpenUser()
 339         r.data_in.domain_handle = self.handle
 340         r.data_in.access_mask = access_mask
 341         r.data_in.rid = rid
 342
 343         call_fn(dcerpc.dcerpc_samr_OpenUser, self.pipe, r)
 344
 345         return UserHandle(self.pipe, r.data_out.user_handle)
 346
 347     def OpenGroup(self, rid, access_mask = 0x02000000):
 348
 349         r = dcerpc.samr_OpenGroup()
 350         r.data_in.domain_handle = self.handle
 351         r.data_in.access_mask = access_mask
 352         r.data_in.rid = rid
 353
 354         call_fn(dcerpc.dcerpc_samr_OpenGroup, self.pipe, r)
 355
 356         return GroupHandle(self.pipe, r.data_out.group_handle)
 357
 358     def OpenAlias(self, rid, access_mask = 0x02000000):
 359
 360         r = dcerpc.samr_OpenAlias()
 361         r.data_in.domain_handle = self.handle
 362         r.data_in.access_mask = access_mask
 363         r.data_in.rid = rid
 364
 365         call_fn(dcerpc.dcerpc_samr_OpenAlias, self.pipe, r)
 366
 367         return AliasHandle(self.pipe, r.data_out.alias_handle)
 368
 369     def CreateDomAlias(self, alias_name, access_mask = 0x02000000):
 370
 371         r = dcerpc.samr_CreateDomAlias()
 372         r.data_in.domain_handle = self.handle
 373         r.data_in.alias_name = dcerpc.samr_String()
 374         r.data_in.alias_name.string = alias_name
 375         r.data_in.access_mask = access_mask
 376
 377         call_fn(dcerpc.dcerpc_samr_CreateDomAlias, self.pipe, r)
 378
 379         return (AliasHandle(self.pipe, r.data_out.alias_handle),
 380                 r.data_out.rid)
 381
 382     def RidToSid(self, rid):
 383
 384         r = dcerpc.samr_RidToSid()
 385         r.data_in.domain_handle = self.handle
 386         r.data_in.rid = rid
 387
 388         call_fn(dcerpc.dcerpc_samr_RidToSid, self.pipe, r)
 389
 390         return sid_to_string(r.data_out.sid)
 391
 392     def RemoveMemberFromForeignDomain(self, sid):
 393
 394         r = dcerpc.samr_RemoveMemberFromForeignDomain()
 395         r.data_in.domain_handle = self.handle
 396         r.data_in.sid = sid
 397
 398         call_fn(dcerpc.dcerpc_samr_RemoveMemberFromForeignDomain, self.pipe, r)
 399
 400     def LookupNames(self, names):
 401
 402         r = dcerpc.samr_LookupNames()
 403         r.data_in.domain_handle = self.handle
 404         r.data_in.num_names = len(names)
 405         r.data_in.names = dcerpc.new_samr_String_array(len(names))
 406
 407         for i in range(len(names)):
 408             s = dcerpc.samr_String()
 409             s.string = names[i]
 410             dcerpc.samr_String_array_setitem(r.data_in.names, i, s)
 411
 412         call_fn(dcerpc.dcerpc_samr_LookupNames, self.pipe, r)
 413
 414         return ([dcerpc.uint32_array_getitem(r.data_out.rids.ids, i)
 415                  for i in range(r.data_out.rids.count)],
 416                 [dcerpc.uint32_array_getitem(r.data_out.types.ids, i)
 417                  for i in range(r.data_out.types.count)])
 418
 419     def CreateDomainGroup(self, domain_name, access_mask = 0x02000000):
 420
 421         r = dcerpc.samr_CreateDomainGroup()
 422         r.data_in.domain_handle = self.handle
 423         r.data_in.name = dcerpc.samr_String()
 424         r.data_in.name.string = domain_name
 425         r.data_in.access_mask = access_mask
 426
 427         call_fn(dcerpc.dcerpc_samr_CreateDomainGroup, self.pipe, r)
 428
 429     def GetAliasMembership(self, sids):
 430
 431         r = dcerpc.samr_GetAliasMembership()
 432         r.data_in.domain_handle = self.handle
 433         r.data_in.sids = dcerpc.lsa_SidArray()
 434         r.data_in.sids.num_sids = len(sids)
 435         r.data_in.sids.sids = dcerpc.new_lsa_SidPtr_array(len(sids))
 436
 437         for i in range(len(sids)):
 438             s = dcerpc.lsa_SidPtr()
 439             s.sid = string_to_sid(sids[i])
 440             dcerpc.lsa_SidPtr_array_setitem(r.data_in.sids.sids, i, s)
 441
 442         call_fn(dcerpc.dcerpc_samr_GetAliasMembership, self.pipe, r)
 443
 444         return [r.ids[x] for x in range(r.count)]
 445
 446     def QueryDisplayInfo(self, level):
 447
 448         # TODO: Handle more data returns
 449
 450         r = dcerpc.samr_QueryDisplayInfo()
 451         r.data_in.domain_handle = self.handle
 452         r.data_in.level = level
 453         r.data_in.start_idx = 0
 454         r.data_in.max_entries = 1000
 455         r.data_in.buf_size = -1
 456
 457         call_fn(dcerpc.dcerpc_samr_QueryDisplayInfo, self.pipe, r)
 458
 459         # TODO: Return a mapping of the various samr_DispInfo
 460         # structures here.
 461
 462         return getattr(r.data_out.info, 'info%d' % level)
 463
 464     def QueryDisplayInfo2(self, level):
 465
 466         # TODO: Handle more data returns
 467
 468         r = dcerpc.samr_QueryDisplayInfo2()
 469         r.data_in.domain_handle = self.handle
 470         r.data_in.level = level
 471         r.data_in.start_idx = 0
 472         r.data_in.max_entries = 1000
 473         r.data_in.buf_size = -1
 474
 475         call_fn(dcerpc.dcerpc_samr_QueryDisplayInfo2, self.pipe, r)
 476
 477         # TODO: Return a mapping of the various samr_DispInfo
 478         # structures here.
 479
 480         return getattr(r.data_out.info, 'info%d' % level)
 481
 482     def QueryDisplayInfo3(self, level):
 483
 484         # TODO: Handle more data returns
 485
 486         r = dcerpc.samr_QueryDisplayInfo3()
 487         r.data_in.domain_handle = self.handle
 488         r.data_in.level = level
 489         r.data_in.start_idx = 0
 490         r.data_in.max_entries = 1000
 491         r.data_in.buf_size = -1
 492
 493         call_fn(dcerpc.dcerpc_samr_QueryDisplayInfo3, self.pipe, r)
 494
 495         # TODO: Return a mapping of the various samr_DispInfo
 496         # structures here.
 497
 498         return getattr(r.data_out.info, 'info%d' % level)
 499
 500     def GetBootKeyInformation(self):
 501
 502         r = dcerpc.samr_GetBootKeyInformation()
 503         r.data_in.domain_handle = self.handle
 504
 505         call_fn(dcerpc.dcerpc_samr_GetBootKeyInformation, self.pipe, r)
 506
 507         return r.data_out.unknown
 508
 509     def SetBootKeyInformation(self):
 510
 511         r = dcerpc.samr_GetBootKeyInformation()
 512         r.data_in.domain_handle = self.handle
 513
 514         call_fn(dcerpc.dcerpc_samr_GetBootKeyInformation, self.pipe, r)
 515
 516     def TestPrivateFunctionsDomain(self):
 517
 518         r = dcerpc.samr_TestPrivateFunctionsDomain()
 519         r.data_in.domain_handle = self.handle
 520
 521         call_fn(dcerpc.dcerpc_samr_TestPrivateFunctionsDomain, self.pipe, r)
 522
 523
 524 class UserHandle(SamrHandle):
 525
 526     def DeleteUser(self):
 527
 528         r = dcerpc.samr_DeleteUser()
 529         r.data_in.user_handle = self.handle
 530
 531         call_fn(dcerpc.dcerpc_samr_DeleteUser, self.pipe, r)
 532
 533         self.handle = None
 534
 535     def GetUserPwInfo(self):
 536
 537         r = dcerpc.samr_GetUserPwInfo()
 538         r.data_in.user_handle = self.handle
 539
 540         call_fn(dcerpc.dcerpc_samr_GetUserPwInfo, self.pipe, r)
 541
 542         return r.data_out.info
 543
 544     def QueryUserInfo(self, level):
 545
 546         r = dcerpc.samr_QueryUserInfo()
 547         r.data_in.user_handle = self.handle
 548         r.data_in.level = level
 549
 550         call_fn(dcerpc.dcerpc_samr_QueryUserInfo, self.pipe, r)
 551
 552         return r.data_out.info
 553
 554     def QueryUserInfo2(self, level):
 555
 556         r = dcerpc.samr_QueryUserInfo2()
 557         r.data_in.user_handle = self.handle
 558         r.data_in.level = level
 559
 560         call_fn(dcerpc.dcerpc_samr_QueryUserInfo2, self.pipe, r)
 561
 562         return r.data_out.info
 563
 564     def GetGroupsForUser(self):
 565
 566         r = dcerpc.samr_GetGroupsForUser()
 567         r.data_in.user_handle = self.handle
 568
 569         call_fn(dcerpc.dcerpc_samr_GetGroupsForUser, self.pipe, r)
 570
 571         rid_types = [dcerpc.samr_RidType_array_getitem(r.data_out.rids.rid, x)
 572                      for x in range(r.data_out.rids.count)]
 573
 574         return [(x.rid, x.type) for x in rid_types]
 575
 576     def TestPrivateFunctionsUser(self):
 577
 578         r = dcerpc.samr_TestPrivateFunctionsUser()
 579         r.data_in.user_handle = self.handle
 580
 581         call_fn(dcerpc.dcerpc_samr_TestPrivateFunctionsUser, self.pipe, r)
 582
 583
 584 class GroupHandle(SamrHandle):
 585
 586     def QueryGroupInfo(self, level):
 587
 588         r = dcerpc.samr_QueryGroupInfo()
 589         r.data_in.group_handle = self.handle
 590         r.data_in.level = level
 591
 592         call_fn(dcerpc.dcerpc_samr_QueryGroupInfo, self.pipe, r)
 593
 594         return r.data_out.info
 595
 596     def SetGroupInfo(self, level, info):
 597
 598         r = dcerpc.samr_SetGroupInfo()
 599         r.data_in.group_handle = self.handle
 600         r.data_in.level = level
 601         r.data_in.info = info
 602
 603         call_fn(dcerpc.dcerpc_samr_SetGroupInfo, self.pipe, r)
 604
 605     def QueryGroupMember(self):
 606
 607         r = dcerpc.samr_QueryGroupMember()
 608         r.data_in.group_handle = self.handle
 609
 610         call_fn(dcerpc.dcerpc_samr_QueryGroupMember, self.pipe, r)
 611
 612         return [(dcerpc.uint32_array_getitem(r.data_out.rids.rids, x),
 613                  dcerpc.uint32_array_getitem(r.data_out.rids.unknown, x))
 614                 for x in range(r.data_out.rids.count)]
 615
 616
 617 class AliasHandle(SamrHandle):
 618
 619     def DeleteDomAlias(self):
 620
 621         r = dcerpc.samr_DeleteDomAlias()
 622         r.data_in.alias_handle = self.handle
 623
 624         call_fn(dcerpc.dcerpc_samr_DeleteDomAlias, self.pipe, r)
 625
 626         self.handle = None
 627
 628     def QueryAliasInfo(self, level = 1):
 629
 630         r = dcerpc.samr_QueryAliasInfo()
 631         r.data_in.alias_handle = self.handle
 632         r.data_in.level = level
 633
 634         call_fn(dcerpc.dcerpc_samr_QueryAliasInfo, self.pipe, r)
 635
 636         return r.data_out.info
 637
 638     def SetAliasInfo(self, level, info):
 639
 640         r = dcerpc.samr_SetAliasInfo()
 641         r.data_in.alias_handle = self.handle
 642         r.data_in.level = level
 643         r.data_in.info = info
 644
 645         call_fn(dcerpc.dcerpc_samr_SetAliasInfo, self.pipe, r)
 646
 647     def AddAliasMember(self, sid):
 648
 649         r = dcerpc.samr_AddAliasMember()
 650         r.data_in.alias_handle = self.handle
 651         r.data_in.sid = string_to_sid(sid)
 652
 653         call_fn(dcerpc.dcerpc_samr_AddAliasMember, self.pipe, r)
 654
 655     def AddMultipleMembersToAlias(self, sids):
 656
 657         r = dcerpc.samr_AddMultipleMembersToAlias()
 658         r.data_in.alias_handle = self.handle
 659         r.data_in.sids = dcerpc.lsa_SidArray()
 660         r.data_in.sids.num_sids = len(sids)
 661         r.data_in.sids.sids = dcerpc.new_lsa_SidPtr_array(len(sids))
 662
 663         for i in range(len(sids)):
 664             s = dcerpc.lsa_SidPtr()
 665             s.sid = string_to_sid(sids[i])
 666             dcerpc.lsa_SidPtr_array_setitem(r.data_in.sids.sids, i, s)
 667
 668         call_fn(dcerpc.dcerpc_samr_AddMultipleMembersToAlias, self.pipe, r)
 669
 670     def GetMembersInAlias(self):
 671
 672         r = dcerpc.samr_GetMembersInAlias()
 673         r.data_in.alias_handle = self.handle
 674
 675         call_fn(dcerpc.dcerpc_samr_GetMembersInAlias, self.pipe, r)
 676
 677         return [
 678             sid_to_string(
 679                 dcerpc.lsa_SidPtr_array_getitem(r.data_out.sids.sids, x).sid)
 680             for x in range(r.data_out.sids.num_sids)]
 681
 682 def Connect(pipe, access_mask = 0x02000000):
 683
 684     r = dcerpc.samr_Connect()
 685     r.data_in.system_name = dcerpc.new_uint16_array(1)
 686     dcerpc.uint16_array_setitem(r.data_in.system_name, 0, ord('\\'))
 687     r.data_in.access_mask = access_mask
 688
 689     call_fn(dcerpc.dcerpc_samr_Connect, pipe, r)
 690
 691     return ConnectHandle(pipe, r.data_out.connect_handle)
 692
 693 def Connect2(pipe, system_name = '', access_mask = 0x02000000):
 694     """Connect to the SAMR pipe."""
 695
 696     r = dcerpc.samr_Connect2()
 697     r.data_in.system_name = system_name
 698     r.data_in.access_mask = access_mask
 699
 700     call_fn(dcerpc.dcerpc_samr_Connect2, pipe, r)
 701
 702     return ConnectHandle(pipe, r.data_out.connect_handle)
 703
 704 def Connect3(pipe, system_name = '', access_mask = 0x02000000):
 705
 706     r = dcerpc.samr_Connect3()
 707     r.data_in.system_name = system_name
 708     r.data_in.unknown = 0
 709     r.data_in.access_mask = access_mask
 710
 711     call_fn(dcerpc.dcerpc_samr_Connect3, pipe, r)
 712
 713     return ConnectHandle(pipe, r.data_out.connect_handle)
 714
 715
 716 def Connect4(pipe, system_name = '', access_mask = 0x02000000):
 717
 718     r = dcerpc.samr_Connect4()
 719     r.data_in.system_name = system_name
 720     r.data_in.unknown = 0
 721     r.data_in.access_mask = access_mask
 722
 723     call_fn(dcerpc.dcerpc_samr_Connect4, pipe, r)
 724
 725     return ConnectHandle(pipe, r.data_out.connect_handle)
 726
 727 def Connect5(pipe, system_name = '', access_mask = 0x02000000):
 728
 729     r = dcerpc.samr_Connect5()
 730     r.data_in.system_name = system_name
 731     r.data_in.access_mask = access_mask
 732     r.data_in.level = 1
 733     r.data_in.info = dcerpc.new_samr_ConnectInfo_array(1)
 734     r.data_in.info.unknown1 = 0
 735     r.data_in.info.unknown2 = 0
 736
 737     call_fn(dcerpc.dcerpc_samr_Connect5, pipe, r)
 738
 739     return ConnectHandle(pipe, r.data_out.connect_handle)
 740
 741 # AddGroupMember
 742 # DeleteDomainGroup
 743 # DeleteGroupMember
 744 # SetMemberAttributesofGroup
 745 # AddAliasMember
 746 # DeleteAliasMember
 747 # GetMembersinAlias
 748 # SetUserInfo
 749 # ChangePasswordUser
 750 # GetDisplayEnumerationIndex
 751 # RemoveMemberFromForeignDomain
 752 # GetDisplayEnumerationIndex2
 753 # RemoveMultipleMembersFromAlias
 754 # OemChangePasswordUser2
 755 # ChangePasswordUser2
 756 # SetUserInfo2
 757 # ChangePasswordUser3
 758 # SetDsrmPassword
 759 # ValidatePassword