Changeset 989 for vendor/current/python


Ignore:
Timestamp:
Nov 25, 2016, 8:04:54 PM (9 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to version 4.4.7

Location:
vendor/current/python/samba
Files:
2 added
8 edited

Legend:

Unmodified
Added
Removed

  • vendor/current/python/samba/dbchecker.py

    r988 r989  
    3232from samba.descriptor import get_wellknown_sds, get_diff_sds
    3333from samba.auth import system_session, admin_session
     34from samba.netcmd import CommandError
    3435
    3536
    … …  
    196197            self.samdb.delete(dn, controls=controls)
    197198        except Exception, err:
     199            if self.in_transaction:
     200                raise CommandError("%s : %s" % (msg, err))
    198201            self.report("%s : %s" % (msg, err))
    199202            return False
    … …  
    208211            self.samdb.modify(m, controls=controls, validate=validate)
    209212        except Exception, err:
     213            if self.in_transaction:
     214                raise CommandError("%s : %s" % (msg, err))
    210215            self.report("%s : %s" % (msg, err))
    211216            return False
    … …  
    225230            self.samdb.rename(from_dn, to_dn, controls=controls)
    226231        except Exception, err:
     232            if self.in_transaction:
     233                raise CommandError("%s : %s" % (msg, err))
    227234            self.report("%s : %s" % (msg, err))
    228235            return False

  • vendor/current/python/samba/drs_utils.py

    r988 r989  
    4545
    4646    binding_options = "seal"
    47     if int(lp.get("log level")) >= 5:
     47    if lp.log_level() >= 5:
    4848        binding_options += ",print"
    4949    binding_string = "ncacn_ip_tcp:%s[%s]" % (server, binding_options)

  • vendor/current/python/samba/join.py

    r988 r989  
    374374        '''make a DRSUAPI connection to the naming master'''
    375375        binding_options = "seal"
    376         if int(ctx.lp.get("log level")) >= 4:
     376        if ctx.lp.log_level() >= 4:
    377377            binding_options += ",print"
    378378        binding_string = "ncacn_ip_tcp:%s[%s]" % (ctx.server, binding_options)
    … …  
    811811
    812812            binding_options = "seal"
    813             if int(ctx.lp.get("log level")) >= 5:
     813            if ctx.lp.log_level() >= 5:
    814814                binding_options += ",print"
    815815            repl = drs_utils.drs_Replicate(

  • vendor/current/python/samba/netcmd/fsmo.py

    r988 r989  
    3232from samba.samdb import SamDB
    3333
    34 def get_fsmo_roleowner(samdb, roledn):
     34def get_fsmo_roleowner(samdb, roledn, role):
    3535    """Gets the owner of an FSMO role
    3636
    3737    :param roledn: The DN of the FSMO role
     38    :param role: The FSMO role
    3839    """
    39     res = samdb.search(roledn,
    40                        scope=ldb.SCOPE_BASE, attrs=["fSMORoleOwner"])
    41     if len(res) == 0:
    42         raise CommandError('"%s" does not have a FSMO roleowner' % roledn)
    43     master_owner = res[0]["fSMORoleOwner"][0]
    44     return master_owner
     40    try:
     41        res = samdb.search(roledn,
     42                           scope=ldb.SCOPE_BASE, attrs=["fSMORoleOwner"])
     43    except LdbError, (num, msg):
     44        if num == ldb.ERR_NO_SUCH_OBJECT:
     45            return "* The '%s' role is not present in this domain" % role
     46        raise
     47
     48    if 'fSMORoleOwner' in res[0]:
     49        master_owner = res[0]["fSMORoleOwner"][0]
     50        return master_owner
     51    else:
     52        master_owner = "* The '%s' role does not have an FSMO roleowner" % role
     53        return master_owner
    4554
    4655
    … …  
    5564        role_object = "CN=Infrastructure,DC=ForestDnsZones," + forest_dn
    5665
    57     try:
    58         res = samdb.search(role_object,
    59                            attrs=["fSMORoleOwner"],
    60                            scope=ldb.SCOPE_BASE,
    61                            controls=["extended_dn:1:1"])
    62 
    63         if 'fSMORoleOwner' in res[0]:
    64             try:
    65                 master_guid = str(misc.GUID(ldb.Dn(samdb,
    66                                   res[0]['fSMORoleOwner'][0])
    67                                   .get_extended_component('GUID')))
    68                 master_owner = str(ldb.Dn(samdb, res[0]['fSMORoleOwner'][0]))
    69             except LdbError, (num, msg):
    70                 raise CommandError("GUID not found in partition naming master DN %s : %s \n" %
    71                                    (res[0]['fSMORoleOwner'][0], msg))
    72     except LdbError, (num, msg):
    73         raise CommandError("DNS partion %s not found : %s" % (role, msg))
     66    res = samdb.search(role_object,
     67                       attrs=["fSMORoleOwner"],
     68                       scope=ldb.SCOPE_BASE,
     69                       controls=["extended_dn:1:1"])
     70
     71    if 'fSMORoleOwner' in res[0]:
     72        try:
     73            master_guid = str(misc.GUID(ldb.Dn(samdb,
     74                              res[0]['fSMORoleOwner'][0])
     75                              .get_extended_component('GUID')))
     76            master_owner = str(ldb.Dn(samdb, res[0]['fSMORoleOwner'][0]))
     77        except LdbError, (num, msg):
     78            raise CommandError("No GUID found in naming master DN %s : %s \n" %
     79                               (res[0]['fSMORoleOwner'][0], msg))
     80    else:
     81        outf.write("* The '%s' role does not have an FSMO roleowner\n" % role)
     82        return False
    7483
    7584    if role == "domaindns":
    … …  
    151160    m.dn = ldb.Dn(samdb, "")
    152161    if role == "rid":
    153         master_owner = get_fsmo_roleowner(samdb, rid_dn)
     162        master_owner = get_fsmo_roleowner(samdb, rid_dn, role)
    154163        m["becomeRidMaster"]= ldb.MessageElement(
    155164            "1", ldb.FLAG_MOD_REPLACE,
    156165            "becomeRidMaster")
    157166    elif role == "pdc":
    158         master_owner = get_fsmo_roleowner(samdb, domain_dn)
     167        master_owner = get_fsmo_roleowner(samdb, domain_dn, role)
    159168
    160169        res = samdb.search(domain_dn,
    … …  
    166175            "becomePdc")
    167176    elif role == "naming":
    168         master_owner = get_fsmo_roleowner(samdb, naming_dn)
     177        master_owner = get_fsmo_roleowner(samdb, naming_dn, role)
    169178        m["becomeDomainMaster"]= ldb.MessageElement(
    170179            "1", ldb.FLAG_MOD_REPLACE,
    171180            "becomeDomainMaster")
    172181    elif role == "infrastructure":
    173         master_owner = get_fsmo_roleowner(samdb, infrastructure_dn)
     182        master_owner = get_fsmo_roleowner(samdb, infrastructure_dn, role)
    174183        m["becomeInfrastructureMaster"]= ldb.MessageElement(
    175184            "1", ldb.FLAG_MOD_REPLACE,
    176185            "becomeInfrastructureMaster")
    177186    elif role == "schema":
    178         master_owner = get_fsmo_roleowner(samdb, schema_dn)
     187        master_owner = get_fsmo_roleowner(samdb, schema_dn, role)
    179188        m["becomeSchemaMaster"]= ldb.MessageElement(
    180189            "1", ldb.FLAG_MOD_REPLACE,
    … …  
    183192        raise CommandError("Invalid FSMO role.")
    184193
    185     if master_owner != new_owner:
    186         try:
    187             samdb.modify(m)
    188         except LdbError, (num, msg):
    189             raise CommandError("Transfer of '%s' role failed: %s" %
    190                                (role, msg))
    191 
    192         outf.write("FSMO transfer of '%s' role successful\n" % role)
    193         return True
     194    if not '*' in master_owner:
     195        if master_owner != new_owner:
     196            try:
     197                samdb.modify(m)
     198            except LdbError, (num, msg):
     199                raise CommandError("Transfer of '%s' role failed: %s" %
     200                                   (role, msg))
     201
     202            outf.write("FSMO transfer of '%s' role successful\n" % role)
     203            return True
     204        else:
     205            outf.write("This DC already has the '%s' FSMO role\n" % role)
     206            return False
    194207    else:
    195         outf.write("This DC already has the '%s' FSMO role\n" % role)
     208        outf.write("%s\n" % master_owner)
    196209        return False
    197210
    … …  
    211224               type=str, metavar="URL", dest="H"),
    212225        Option("--force",
    213                help="Force seizing of the role without attempting to transfer first.",
     226               help="Force seizing of role without attempting to transfer.",
    214227               action="store_true"),
    215228        Option("--role", type="choice", choices=["rid", "pdc", "infrastructure",
    … …  
    254267        #first try to transfer to avoid problem if the owner is still active
    255268        seize = False
    256         master_owner = get_fsmo_roleowner(samdb, m.dn)
    257         if master_owner != serviceName:
    258             if force is None:
    259                 self.message("Attempting transfer...")
    260                 if not transfer_role(self.outf, role, samdb):
    261                     #transfer failed, use the big axe...
    262                     seize = True
    263                     self.message("Transfer unsuccessful, seizing...")
    264                 else:
    265                     self.message("Not seizing role as transfer was successful")
    266 
    267             if force is not None or seize == True:
    268                 self.message("Seizing %s FSMO role..." % role)
    269                 m["fSMORoleOwner"]= ldb.MessageElement(
    270                     serviceName, ldb.FLAG_MOD_REPLACE,
    271                     "fSMORoleOwner")
    272                 try:
    273                     samdb.modify(m)
    274                 except LdbError, (num, msg):
    275                     raise CommandError("Failed to seize '%s' role: %s" %
    276                                        (role, msg))
    277                 self.outf.write("FSMO seize of '%s' role successful\n" % role)
    278                 return True
    279         else:
    280             self.outf.write("This DC already has the '%s' FSMO role\n" % role)
    281             return False
     269        master_owner = get_fsmo_roleowner(samdb, m.dn, role)
     270        if not '*' in master_owner:
     271            # if there is a different owner
     272            if master_owner != serviceName:
     273                # if --force isn't given, attempt transfer
     274                if force is None:
     275                    self.message("Attempting transfer...")
     276                    try:
     277                        transfer_role(self.outf, role, samdb)
     278                    except:
     279                        #transfer failed, use the big axe...
     280                        seize = True
     281                        self.message("Transfer unsuccessful, seizing...")
     282                    else:
     283                        self.message("Transfer successful, not seizing role")
     284                        return True
     285            else:
     286                self.outf.write("This DC already has the '%s' FSMO role\n" %
     287                                role)
     288                return False
     289        else:
     290            seize = True
     291
     292        if force is not None or seize == True:
     293            self.message("Seizing %s FSMO role..." % role)
     294            m["fSMORoleOwner"]= ldb.MessageElement(
     295                serviceName, ldb.FLAG_MOD_REPLACE,
     296                "fSMORoleOwner")
     297            try:
     298                samdb.modify(m)
     299            except LdbError, (num, msg):
     300                raise CommandError("Failed to seize '%s' role: %s" %
     301                                   (role, msg))
     302            self.outf.write("FSMO seize of '%s' role successful\n" % role)
     303            return True
    282304
    283305    def seize_dns_role(self, role, samdb, credopts, sambaopts,
    … …  
    300322        #first try to transfer to avoid problem if the owner is still active
    301323        seize = False
    302         master_owner = get_fsmo_roleowner(samdb, m.dn)
    303         if master_owner != serviceName:
    304             if force is None:
    305                 self.message("Attempting transfer...")
    306                 if not transfer_dns_role(self.outf, sambaopts, credopts, role,
    307                                       samdb):
    308                     #transfer failed, use the big axe...
    309                     seize = True
    310                     self.message("Transfer unsuccessful, seizing...")
    311                 else:
    312                     self.message("Not seizing role as transfer was successful\n")
    313 
    314             if force is not None or seize == True:
    315                 self.message("Seizing %s FSMO role..." % role)
    316                 m["fSMORoleOwner"]= ldb.MessageElement(
    317                     serviceName, ldb.FLAG_MOD_REPLACE,
    318                     "fSMORoleOwner")
    319                 try:
    320                     samdb.modify(m)
    321                 except LdbError, (num, msg):
    322                     raise CommandError("Failed to seize '%s' role: %s" %
    323                                        (role, msg))
    324                 self.outf.write("FSMO seize of '%s' role successful\n" % role)
    325                 return True
    326         else:
    327             self.outf.write("This DC already has the '%s' FSMO role\n" % role)
    328             return False
     324        master_owner = get_fsmo_roleowner(samdb, m.dn, role)
     325        if not '*' in master_owner:
     326            # if there is a different owner
     327            if master_owner != serviceName:
     328                # if --force isn't given, attempt transfer
     329                if force is None:
     330                    self.message("Attempting transfer...")
     331                    try:
     332                        transfer_dns_role(self.outf, sambaopts, credopts, role,
     333                                          samdb)
     334                    except:
     335                        #transfer failed, use the big axe...
     336                        seize = True
     337                        self.message("Transfer unsuccessful, seizing...")
     338                    else:
     339                        self.message("Transfer successful, not seizing role\n")
     340                        return True
     341            else:
     342                self.outf.write("This DC already has the '%s' FSMO role\n" %
     343                                role)
     344                return False
     345        else:
     346            seize = True
     347
     348        if force is not None or seize == True:
     349            self.message("Seizing %s FSMO role..." % role)
     350            m["fSMORoleOwner"]= ldb.MessageElement(
     351                serviceName, ldb.FLAG_MOD_REPLACE,
     352                "fSMORoleOwner")
     353            try:
     354                samdb.modify(m)
     355            except LdbError, (num, msg):
     356                raise CommandError("Failed to seize '%s' role: %s" %
     357                                   (role, msg))
     358            self.outf.write("FSMO seize of '%s' role successful\n" % role)
     359            return True
     360
    329361
    330362    def run(self, force=None, H=None, role=None,
    … …  
    389421        forestdns_dn = "CN=Infrastructure,DC=ForestDnsZones," + forest_dn
    390422
    391         infrastructureMaster = get_fsmo_roleowner(samdb, infrastructure_dn)
    392         pdcEmulator = get_fsmo_roleowner(samdb, domain_dn)
    393         namingMaster = get_fsmo_roleowner(samdb, naming_dn)
    394         schemaMaster = get_fsmo_roleowner(samdb, schema_dn)
    395         ridMaster = get_fsmo_roleowner(samdb, rid_dn)
    396         domaindnszonesMaster = get_fsmo_roleowner(samdb, domaindns_dn)
    397         forestdnszonesMaster = get_fsmo_roleowner(samdb, forestdns_dn)
     423        infrastructureMaster = get_fsmo_roleowner(samdb, infrastructure_dn,
     424                                                  "infrastructure")
     425        pdcEmulator = get_fsmo_roleowner(samdb, domain_dn, "pdc")
     426        namingMaster = get_fsmo_roleowner(samdb, naming_dn, "naming")
     427        schemaMaster = get_fsmo_roleowner(samdb, schema_dn, "schema")
     428        ridMaster = get_fsmo_roleowner(samdb, rid_dn, "rid")
     429        domaindnszonesMaster = get_fsmo_roleowner(samdb, domaindns_dn,
     430                                                  "domaindns")
     431        forestdnszonesMaster = get_fsmo_roleowner(samdb, forestdns_dn,
     432                                                  "forestdns")
    398433
    399434        self.message("SchemaMasterRole owner: " + schemaMaster)
    … …  
    450485            transfer_role(self.outf, "infrastructure", samdb)
    451486            transfer_role(self.outf, "schema", samdb)
    452             transfer_dns_role(self.outf, sambaopts, credopts, "domaindns", samdb)
    453             transfer_dns_role(self.outf, sambaopts, credopts, "forestdns", samdb)
     487            transfer_dns_role(self.outf, sambaopts, credopts,
     488                              "domaindns", samdb)
     489            transfer_dns_role(self.outf, sambaopts, credopts, "forestdns",
     490                              samdb)
    454491        else:
    455492            if role == "domaindns" or role == "forestdns":

  • vendor/current/python/samba/netcmd/ldapcmp.py

    r988 r989  
    439439                "uSNCreated",
    440440                "uSNLastObjRem",
    441                 # "whenChanged", # This is implicitly replicated
     441                "whenChanged", # This is implicitly replicated, but may diverge on updates of non-replicated attributes
    442442        ]
    443443        self.ignore_attributes = self.non_replicated_attributes

  • vendor/current/python/samba/remove_dc.py

    r988 r989  
    177177        for record in records:
    178178            try:
    179                 values = record["dnsRecord"]
     179                orig_values = record["dnsRecord"]
    180180            except KeyError:
    181                 next
    182             orig_num_values = len(values)
     181                continue
    183182
    184183            # Remove references to dnsHostName in A, AAAA, NS, CNAME and SRV
    185184            values = [ ndr_unpack(dnsp.DnssrvRpcRecord, v)
    186                        for v in values if not to_remove(v) ]
    187 
    188             if len(values) != orig_num_values:
     185                       for v in orig_values if not to_remove(v) ]
     186
     187            if len(values) != len(orig_values):
    189188                logger.info("updating %s keeping %d values, removing %s values" \
    190189                            % (record.dn, len(values),
    191                                orig_num_values - len(values)))
     190                               len(orig_values) - len(values)))
    192191
    193192                # This requires the values to be unpacked, so this

  • vendor/current/python/samba/tests/dcerpc/raw_protocol.py

    r988 r989  
    26172617        self.assertNotConnected()
    26182618
     2619    def test_spnego_auth_pad_ok(self):
     2620        ndr32 = base.transfer_syntax_ndr()
     2621
     2622        tsf1_list = [ndr32]
     2623        ctx1 = dcerpc.ctx_list()
     2624        ctx1.context_id = 1
     2625        ctx1.num_transfer_syntaxes = len(tsf1_list)
     2626        ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
     2627        ctx1.transfer_syntaxes = tsf1_list
     2628        ctx_list = [ctx1]
     2629
     2630        c = Credentials()
     2631        c.set_anonymous()
     2632        g = gensec.Security.start_client(self.settings)
     2633        g.set_credentials(c)
     2634        g.want_feature(gensec.FEATURE_DCE_STYLE)
     2635        auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
     2636        auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
     2637        auth_context_id = 2
     2638        g.start_mech_by_authtype(auth_type, auth_level)
     2639        from_server = ""
     2640        (finished, to_server) = g.update(from_server)
     2641        self.assertFalse(finished)
     2642
     2643        auth_info = self.generate_auth(auth_type=auth_type,
     2644                                       auth_level=auth_level,
     2645                                       auth_context_id=auth_context_id,
     2646                                       auth_blob=to_server)
     2647
     2648        req = self.generate_bind(call_id=0,
     2649                                 ctx_list=ctx_list,
     2650                                 auth_info=auth_info)
     2651        req_pdu = samba.ndr.ndr_pack(req)
     2652
     2653        auth_pad_ok = len(req_pdu)
     2654        auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
     2655        auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
     2656        auth_pad_ok -= len(to_server)
     2657
     2658        auth_info = self.generate_auth(auth_type=auth_type,
     2659                                       auth_level=auth_level,
     2660                                       auth_context_id=auth_context_id,
     2661                                       auth_pad_length=auth_pad_ok,
     2662                                       auth_blob=to_server)
     2663
     2664        req = self.generate_bind(call_id=0,
     2665                                 ctx_list=ctx_list,
     2666                                 auth_info=auth_info)
     2667        self.send_pdu(req)
     2668        rep = self.recv_pdu()
     2669        self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
     2670        self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
     2671        self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
     2672        self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
     2673        self.assertEquals(rep.u.secondary_address_size, 4)
     2674        self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
     2675        self.assertEquals(len(rep.u._pad1), 2)
     2676        #self.assertEquals(rep.u._pad1, '\0' * 2)
     2677        self.assertEquals(rep.u.num_results, 1)
     2678        self.assertEquals(rep.u.ctx_list[0].result,
     2679                dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
     2680        self.assertEquals(rep.u.ctx_list[0].reason,
     2681                dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
     2682        self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
     2683        self.assertNotEquals(len(rep.u.auth_info), 0)
     2684        a = self.parse_auth(rep.u.auth_info)
     2685
     2686        from_server = a.credentials
     2687        (finished, to_server) = g.update(from_server)
     2688        self.assertFalse(finished)
     2689
     2690        auth_info = self.generate_auth(auth_type=auth_type,
     2691                                       auth_level=auth_level,
     2692                                       auth_context_id=auth_context_id,
     2693                                       auth_blob=to_server)
     2694        req = self.generate_alter(call_id=0,
     2695                                  ctx_list=ctx_list,
     2696                                  assoc_group_id=rep.u.assoc_group_id,
     2697                                  auth_info=auth_info)
     2698        req_pdu = samba.ndr.ndr_pack(req)
     2699
     2700        auth_pad_ok = len(req_pdu)
     2701        auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
     2702        auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
     2703        auth_pad_ok -= len(to_server)
     2704        auth_info = self.generate_auth(auth_type=auth_type,
     2705                                       auth_level=auth_level,
     2706                                       auth_context_id=auth_context_id,
     2707                                       auth_pad_length=auth_pad_ok,
     2708                                       auth_blob=to_server)
     2709        req = self.generate_alter(call_id=0,
     2710                                  ctx_list=ctx_list,
     2711                                  assoc_group_id=rep.u.assoc_group_id,
     2712                                  auth_info=auth_info)
     2713        self.send_pdu(req)
     2714        rep = self.recv_pdu()
     2715        self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id)
     2716        self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
     2717        self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
     2718        self.assertEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
     2719        self.assertEquals(rep.u.secondary_address_size, 0)
     2720        self.assertEquals(len(rep.u._pad1), 2)
     2721        # Windows sends garbage
     2722        #self.assertEquals(rep.u._pad1, '\0' * 2)
     2723        self.assertEquals(rep.u.num_results, 1)
     2724        self.assertEquals(rep.u.ctx_list[0].result,
     2725                dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
     2726        self.assertEquals(rep.u.ctx_list[0].reason,
     2727                dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
     2728        self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
     2729        self.assertNotEquals(len(rep.u.auth_info), 0)
     2730        a = self.parse_auth(rep.u.auth_info)
     2731
     2732        from_server = a.credentials
     2733        (finished, to_server) = g.update(from_server)
     2734        self.assertTrue(finished)
     2735
     2736        # And now try a request without auth_info
     2737        req = self.generate_request(call_id = 2,
     2738                                    context_id=ctx1.context_id,
     2739                                    opnum=0,
     2740                                    stub="")
     2741        self.send_pdu(req)
     2742        rep = self.recv_pdu()
     2743        self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
     2744                        auth_length=0)
     2745        self.assertNotEquals(rep.u.alloc_hint, 0)
     2746        self.assertEquals(rep.u.context_id, req.u.context_id)
     2747        self.assertEquals(rep.u.cancel_count, 0)
     2748        self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
     2749
     2750        # Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
     2751        auth_info = self.generate_auth(auth_type=auth_type,
     2752                                       auth_level=auth_level,
     2753                                       auth_context_id=auth_context_id,
     2754                                       auth_blob="\x01"+"\x00"*15)
     2755        req = self.generate_request(call_id = 3,
     2756                                    context_id=ctx1.context_id,
     2757                                    opnum=0,
     2758                                    stub="",
     2759                                    auth_info=auth_info)
     2760        self.send_pdu(req)
     2761        rep = self.recv_pdu()
     2762        # We don't get an auth_info back
     2763        self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
     2764                        auth_length=0)
     2765        self.assertNotEquals(rep.u.alloc_hint, 0)
     2766        self.assertEquals(rep.u.context_id, req.u.context_id)
     2767        self.assertEquals(rep.u.cancel_count, 0)
     2768        self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
     2769
     2770        self._disconnect("disconnect")
     2771        self.assertNotConnected()
     2772
     2773    def test_spnego_auth_pad_fail_bind(self):
     2774        ndr32 = base.transfer_syntax_ndr()
     2775
     2776        tsf1_list = [ndr32]
     2777        ctx1 = dcerpc.ctx_list()
     2778        ctx1.context_id = 1
     2779        ctx1.num_transfer_syntaxes = len(tsf1_list)
     2780        ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
     2781        ctx1.transfer_syntaxes = tsf1_list
     2782        ctx_list = [ctx1]
     2783
     2784        c = Credentials()
     2785        c.set_anonymous()
     2786        g = gensec.Security.start_client(self.settings)
     2787        g.set_credentials(c)
     2788        g.want_feature(gensec.FEATURE_DCE_STYLE)
     2789        auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
     2790        auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
     2791        auth_context_id = 2
     2792        g.start_mech_by_authtype(auth_type, auth_level)
     2793        from_server = ""
     2794        (finished, to_server) = g.update(from_server)
     2795        self.assertFalse(finished)
     2796
     2797        auth_info = self.generate_auth(auth_type=auth_type,
     2798                                       auth_level=auth_level,
     2799                                       auth_context_id=auth_context_id,
     2800                                       auth_blob=to_server)
     2801
     2802        req = self.generate_bind(call_id=0,
     2803                                 ctx_list=ctx_list,
     2804                                 auth_info=auth_info)
     2805        req_pdu = samba.ndr.ndr_pack(req)
     2806
     2807        auth_pad_ok = len(req_pdu)
     2808        auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
     2809        auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
     2810        auth_pad_ok -= len(to_server)
     2811        auth_pad_bad = auth_pad_ok + 1
     2812        auth_info = self.generate_auth(auth_type=auth_type,
     2813                                       auth_level=auth_level,
     2814                                       auth_context_id=auth_context_id,
     2815                                       auth_pad_length=auth_pad_bad,
     2816                                       auth_blob=to_server)
     2817
     2818        req = self.generate_bind(call_id=0,
     2819                                 ctx_list=ctx_list,
     2820                                 auth_info=auth_info)
     2821        self.send_pdu(req)
     2822        rep = self.recv_pdu()
     2823        self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
     2824                        auth_length=0)
     2825        self.assertEquals(rep.u.reject_reason,
     2826                dcerpc.DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED)
     2827        self.assertEquals(rep.u.num_versions, 1)
     2828        self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
     2829        self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
     2830        self.assertEquals(len(rep.u._pad), 3)
     2831        self.assertEquals(rep.u._pad, '\0' * 3)
     2832
     2833        # wait for a disconnect
     2834        rep = self.recv_pdu()
     2835        self.assertIsNone(rep)
     2836        self.assertNotConnected()
     2837
     2838    def test_spnego_auth_pad_fail_alter(self):
     2839        ndr32 = base.transfer_syntax_ndr()
     2840
     2841        tsf1_list = [ndr32]
     2842        ctx1 = dcerpc.ctx_list()
     2843        ctx1.context_id = 1
     2844        ctx1.num_transfer_syntaxes = len(tsf1_list)
     2845        ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
     2846        ctx1.transfer_syntaxes = tsf1_list
     2847        ctx_list = [ctx1]
     2848
     2849        c = Credentials()
     2850        c.set_anonymous()
     2851        g = gensec.Security.start_client(self.settings)
     2852        g.set_credentials(c)
     2853        g.want_feature(gensec.FEATURE_DCE_STYLE)
     2854        auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
     2855        auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
     2856        auth_context_id = 2
     2857        g.start_mech_by_authtype(auth_type, auth_level)
     2858        from_server = ""
     2859        (finished, to_server) = g.update(from_server)
     2860        self.assertFalse(finished)
     2861
     2862        auth_info = self.generate_auth(auth_type=auth_type,
     2863                                       auth_level=auth_level,
     2864                                       auth_context_id=auth_context_id,
     2865                                       auth_blob=to_server)
     2866
     2867        req = self.generate_bind(call_id=0,
     2868                                 ctx_list=ctx_list,
     2869                                 auth_info=auth_info)
     2870        req_pdu = samba.ndr.ndr_pack(req)
     2871
     2872        auth_pad_ok = len(req_pdu)
     2873        auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
     2874        auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
     2875        auth_pad_ok -= len(to_server)
     2876
     2877        auth_info = self.generate_auth(auth_type=auth_type,
     2878                                       auth_level=auth_level,
     2879                                       auth_context_id=auth_context_id,
     2880                                       auth_pad_length=auth_pad_ok,
     2881                                       auth_blob=to_server)
     2882
     2883        req = self.generate_bind(call_id=0,
     2884                                 ctx_list=ctx_list,
     2885                                 auth_info=auth_info)
     2886        self.send_pdu(req)
     2887        rep = self.recv_pdu()
     2888        self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
     2889        self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
     2890        self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
     2891        self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
     2892        self.assertEquals(rep.u.secondary_address_size, 4)
     2893        self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
     2894        self.assertEquals(len(rep.u._pad1), 2)
     2895        #self.assertEquals(rep.u._pad1, '\0' * 2)
     2896        self.assertEquals(rep.u.num_results, 1)
     2897        self.assertEquals(rep.u.ctx_list[0].result,
     2898                dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
     2899        self.assertEquals(rep.u.ctx_list[0].reason,
     2900                dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
     2901        self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
     2902        self.assertNotEquals(len(rep.u.auth_info), 0)
     2903        a = self.parse_auth(rep.u.auth_info)
     2904
     2905        from_server = a.credentials
     2906        (finished, to_server) = g.update(from_server)
     2907        self.assertFalse(finished)
     2908
     2909        auth_info = self.generate_auth(auth_type=auth_type,
     2910                                       auth_level=auth_level,
     2911                                       auth_context_id=auth_context_id,
     2912                                       auth_blob=to_server)
     2913        req = self.generate_alter(call_id=0,
     2914                                  ctx_list=ctx_list,
     2915                                  assoc_group_id=rep.u.assoc_group_id,
     2916                                  auth_info=auth_info)
     2917        req_pdu = samba.ndr.ndr_pack(req)
     2918
     2919        auth_pad_ok = len(req_pdu)
     2920        auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
     2921        auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
     2922        auth_pad_ok -= len(to_server)
     2923        auth_pad_bad = auth_pad_ok + 1
     2924        auth_info = self.generate_auth(auth_type=auth_type,
     2925                                       auth_level=auth_level,
     2926                                       auth_context_id=auth_context_id,
     2927                                       auth_pad_length=auth_pad_bad,
     2928                                       auth_blob=to_server)
     2929        req = self.generate_alter(call_id=0,
     2930                                  ctx_list=ctx_list,
     2931                                  assoc_group_id=rep.u.assoc_group_id,
     2932                                  auth_info=auth_info)
     2933        self.send_pdu(req)
     2934        rep = self.recv_pdu()
     2935        self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
     2936                        pfc_flags=req.pfc_flags |
     2937                        dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
     2938                        auth_length=0)
     2939        self.assertNotEquals(rep.u.alloc_hint, 0)
     2940        self.assertEquals(rep.u.context_id, 0)
     2941        self.assertEquals(rep.u.cancel_count, 0)
     2942        self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
     2943        self.assertEquals(len(rep.u._pad), 4)
     2944        self.assertEquals(rep.u._pad, '\0' * 4)
     2945
     2946        # wait for a disconnect
     2947        rep = self.recv_pdu()
     2948        self.assertIsNone(rep)
     2949        self.assertNotConnected()
     2950
     2951    def test_ntlmssp_auth_pad_ok(self):
     2952        ndr32 = base.transfer_syntax_ndr()
     2953
     2954        tsf1_list = [ndr32]
     2955        ctx1 = dcerpc.ctx_list()
     2956        ctx1.context_id = 1
     2957        ctx1.num_transfer_syntaxes = len(tsf1_list)
     2958        ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
     2959        ctx1.transfer_syntaxes = tsf1_list
     2960        ctx_list = [ctx1]
     2961
     2962        c = Credentials()
     2963        c.set_anonymous()
     2964        g = gensec.Security.start_client(self.settings)
     2965        g.set_credentials(c)
     2966        g.want_feature(gensec.FEATURE_DCE_STYLE)
     2967        auth_type = dcerpc.DCERPC_AUTH_TYPE_NTLMSSP
     2968        auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
     2969        auth_context_id = 2
     2970        g.start_mech_by_authtype(auth_type, auth_level)
     2971        from_server = ""
     2972        (finished, to_server) = g.update(from_server)
     2973        self.assertFalse(finished)
     2974
     2975        auth_info = self.generate_auth(auth_type=auth_type,
     2976                                       auth_level=auth_level,
     2977                                       auth_context_id=auth_context_id,
     2978                                       auth_blob=to_server)
     2979
     2980        req = self.generate_bind(call_id=0,
     2981                                 ctx_list=ctx_list,
     2982                                 auth_info=auth_info)
     2983        req_pdu = samba.ndr.ndr_pack(req)
     2984
     2985        auth_pad_ok = len(req_pdu)
     2986        auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
     2987        auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
     2988        auth_pad_ok -= len(to_server)
     2989
     2990        auth_info = self.generate_auth(auth_type=auth_type,
     2991                                       auth_level=auth_level,
     2992                                       auth_context_id=auth_context_id,
     2993                                       auth_pad_length=auth_pad_ok,
     2994                                       auth_blob=to_server)
     2995
     2996        req = self.generate_bind(call_id=0,
     2997                                 ctx_list=ctx_list,
     2998                                 auth_info=auth_info)
     2999        self.send_pdu(req)
     3000        rep = self.recv_pdu()
     3001        self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
     3002        self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
     3003        self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
     3004        self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
     3005        self.assertEquals(rep.u.secondary_address_size, 4)
     3006        self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
     3007        self.assertEquals(len(rep.u._pad1), 2)
     3008        #self.assertEquals(rep.u._pad1, '\0' * 2)
     3009        self.assertEquals(rep.u.num_results, 1)
     3010        self.assertEquals(rep.u.ctx_list[0].result,
     3011                dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
     3012        self.assertEquals(rep.u.ctx_list[0].reason,
     3013                dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
     3014        self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
     3015        self.assertNotEquals(len(rep.u.auth_info), 0)
     3016        a = self.parse_auth(rep.u.auth_info)
     3017
     3018        from_server = a.credentials
     3019        (finished, to_server) = g.update(from_server)
     3020        self.assertTrue(finished)
     3021
     3022        auth_pad_ok = 0
     3023        auth_info = self.generate_auth(auth_type=auth_type,
     3024                                       auth_level=auth_level,
     3025                                       auth_context_id=auth_context_id,
     3026                                       auth_pad_length=auth_pad_ok,
     3027                                       auth_blob=to_server)
     3028        req = self.generate_auth3(call_id=0,
     3029                                  auth_info=auth_info)
     3030        self.send_pdu(req)
     3031        self.assertIsConnected()
     3032
     3033        # And now try a request without auth_info
     3034        req = self.generate_request(call_id = 2,
     3035                                    context_id=ctx1.context_id,
     3036                                    opnum=0,
     3037                                    stub="")
     3038        self.send_pdu(req)
     3039        rep = self.recv_pdu()
     3040        self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
     3041                        auth_length=0)
     3042        self.assertNotEquals(rep.u.alloc_hint, 0)
     3043        self.assertEquals(rep.u.context_id, req.u.context_id)
     3044        self.assertEquals(rep.u.cancel_count, 0)
     3045        self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
     3046
     3047        # Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
     3048        auth_info = self.generate_auth(auth_type=auth_type,
     3049                                       auth_level=auth_level,
     3050                                       auth_context_id=auth_context_id,
     3051                                       auth_blob="\x01"+"\x00"*15)
     3052        req = self.generate_request(call_id = 3,
     3053                                    context_id=ctx1.context_id,
     3054                                    opnum=0,
     3055                                    stub="",
     3056                                    auth_info=auth_info)
     3057        self.send_pdu(req)
     3058        rep = self.recv_pdu()
     3059        # We don't get an auth_info back
     3060        self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
     3061                        auth_length=0)
     3062        self.assertNotEquals(rep.u.alloc_hint, 0)
     3063        self.assertEquals(rep.u.context_id, req.u.context_id)
     3064        self.assertEquals(rep.u.cancel_count, 0)
     3065        self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
     3066
     3067        self._disconnect("disconnect")
     3068        self.assertNotConnected()
     3069
     3070    def test_ntlmssp_auth_pad_fail_auth3(self):
     3071        ndr32 = base.transfer_syntax_ndr()
     3072
     3073        tsf1_list = [ndr32]
     3074        ctx1 = dcerpc.ctx_list()
     3075        ctx1.context_id = 1
     3076        ctx1.num_transfer_syntaxes = len(tsf1_list)
     3077        ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
     3078        ctx1.transfer_syntaxes = tsf1_list
     3079        ctx_list = [ctx1]
     3080
     3081        c = Credentials()
     3082        c.set_anonymous()
     3083        g = gensec.Security.start_client(self.settings)
     3084        g.set_credentials(c)
     3085        g.want_feature(gensec.FEATURE_DCE_STYLE)
     3086        auth_type = dcerpc.DCERPC_AUTH_TYPE_NTLMSSP
     3087        auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
     3088        auth_context_id = 2
     3089        g.start_mech_by_authtype(auth_type, auth_level)
     3090        from_server = ""
     3091        (finished, to_server) = g.update(from_server)
     3092        self.assertFalse(finished)
     3093
     3094        auth_info = self.generate_auth(auth_type=auth_type,
     3095                                       auth_level=auth_level,
     3096                                       auth_context_id=auth_context_id,
     3097                                       auth_blob=to_server)
     3098
     3099        req = self.generate_bind(call_id=0,
     3100                                 ctx_list=ctx_list,
     3101                                 auth_info=auth_info)
     3102        req_pdu = samba.ndr.ndr_pack(req)
     3103
     3104        auth_pad_ok = len(req_pdu)
     3105        auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
     3106        auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
     3107        auth_pad_ok -= len(to_server)
     3108
     3109        auth_info = self.generate_auth(auth_type=auth_type,
     3110                                       auth_level=auth_level,
     3111                                       auth_context_id=auth_context_id,
     3112                                       auth_pad_length=auth_pad_ok,
     3113                                       auth_blob=to_server)
     3114
     3115        req = self.generate_bind(call_id=0,
     3116                                 ctx_list=ctx_list,
     3117                                 auth_info=auth_info)
     3118        self.send_pdu(req)
     3119        rep = self.recv_pdu()
     3120        self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
     3121        self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
     3122        self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
     3123        self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
     3124        self.assertEquals(rep.u.secondary_address_size, 4)
     3125        self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
     3126        self.assertEquals(len(rep.u._pad1), 2)
     3127        #self.assertEquals(rep.u._pad1, '\0' * 2)
     3128        self.assertEquals(rep.u.num_results, 1)
     3129        self.assertEquals(rep.u.ctx_list[0].result,
     3130                dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
     3131        self.assertEquals(rep.u.ctx_list[0].reason,
     3132                dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
     3133        self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
     3134        self.assertNotEquals(len(rep.u.auth_info), 0)
     3135        a = self.parse_auth(rep.u.auth_info)
     3136
     3137        from_server = a.credentials
     3138        (finished, to_server) = g.update(from_server)
     3139        self.assertTrue(finished)
     3140
     3141        auth_pad_bad = 1
     3142        auth_info = self.generate_auth(auth_type=auth_type,
     3143                                       auth_level=auth_level,
     3144                                       auth_context_id=auth_context_id,
     3145                                       auth_pad_length=auth_pad_bad,
     3146                                       auth_blob=to_server)
     3147        req = self.generate_auth3(call_id=0,
     3148                                  auth_info=auth_info)
     3149        self.send_pdu(req)
     3150        rep = self.recv_pdu()
     3151        self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
     3152                        pfc_flags=req.pfc_flags |
     3153                        dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
     3154                        auth_length=0)
     3155        self.assertNotEquals(rep.u.alloc_hint, 0)
     3156        self.assertEquals(rep.u.context_id, 0)
     3157        self.assertEquals(rep.u.cancel_count, 0)
     3158        self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY)
     3159        self.assertEquals(len(rep.u._pad), 4)
     3160        self.assertEquals(rep.u._pad, '\0' * 4)
     3161
     3162        # wait for a disconnect
     3163        rep = self.recv_pdu()
     3164        self.assertIsNone(rep)
     3165        self.assertNotConnected()
     3166
    26193167if __name__ == "__main__":
    26203168    global_ndr_print = True

  • vendor/current/python/samba/tests/param.py

    r988 r989  
    5656        samba_lp.load_default()
    5757        self.assertRaises(KeyError, samba_lp.__getitem__, "nonexistent")
     58
     59    def test_log_level(self):
     60        samba_lp = param.LoadParm()
     61        samba_lp.set("log level", "5 auth:4")
     62        self.assertEquals(5, samba_lp.log_level())
     63
Note: See TracChangeset for help on using the changeset viewer.