import sys
import os
+import time
sys.path.insert(0, "bin/python")
os.environ["PYTHONUNBUFFERED"] = "1"
import samba.dcerpc.netlogon
import struct
from samba import gensec
-from samba.tests import RawDCERPCTest
+from samba.tests.dcerpc.raw_testcase import RawDCERPCTest
global_ndr_print = False
global_hexdump = False
+
class TestDCERPC_BIND(RawDCERPCTest):
def setUp(self):
# self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
# And now try a request
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx1.context_id,
opnum=0,
stub="")
# self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
# self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
# And now try a request
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx1.context_id,
opnum=0,
stub="")
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
self.assertEquals(rep.u.reject_reason,
- dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
self.assertEquals(rep.u.num_versions, 1)
self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
self.assertEquals(rep.u.reject_reason,
- dcerpc.DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED)
self.assertEquals(rep.u.num_versions, 1)
self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
self.assertEquals(rep.u.reject_reason,
- dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
self.assertEquals(rep.u.num_versions, 1)
self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
self.assertEquals(rep.u.reject_reason,
- dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
self.assertEquals(rep.u.num_versions, 1)
self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx1.context_id,
opnum=0xffff,
stub="")
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
+ dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
+ dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=12345,
opnum=0,
stub="")
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
+ dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
self.assertEquals(rep.u.reject_reason,
- dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
self.assertEquals(rep.u.num_versions, 1)
self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
# With a known but wrong syntax we get a protocol error
# see test_no_auth_presentation_ctx_valid2
- tsf1b_list = [zero_syntax,samba.dcerpc.epmapper.abstract_syntax(),ndr64]
+ tsf1b_list = [zero_syntax, samba.dcerpc.epmapper.abstract_syntax(), ndr64]
ctx1b = dcerpc.ctx_list()
ctx1b.context_id = 1
ctx1b.num_transfer_syntaxes = len(tsf1b_list)
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
# With a unknown but wrong syntaxes we get NO protocol error
# see test_no_auth_presentation_ctx_invalid4
- tsf1b_list = [zero_syntax,samba.dcerpc.epmapper.abstract_syntax()]
+ tsf1b_list = [zero_syntax, samba.dcerpc.epmapper.abstract_syntax()]
ctx1b = dcerpc.ctx_list()
ctx1b.context_id = 1
ctx1b.num_transfer_syntaxes = len(tsf1b_list)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
+ dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx1a.context_id,
opnum=0xffff,
stub="")
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
+ dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx0.context_id,
opnum=0,
stub="")
self.assertEquals(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- tsf1_list = [zero_syntax,ndr32]
+ tsf1_list = [zero_syntax, ndr32]
ctx1 = dcerpc.ctx_list()
ctx1.context_id = 1
ctx1.num_transfer_syntaxes = len(tsf1_list)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx1.context_id,
opnum=0,
stub="")
self.assertEquals(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- tsf2_list = [ndr32,ndr32]
+ tsf2_list = [ndr32, ndr32]
ctx2 = dcerpc.ctx_list()
ctx2.context_id = 2
ctx2.num_transfer_syntaxes = len(tsf2_list)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx2.context_id,
opnum=0,
stub="")
ctx4.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
ctx4.transfer_syntaxes = tsf4_list
- req = self.generate_alter(call_id=34, ctx_list=[ctx3,ctx4])
+ req = self.generate_alter(call_id=34, ctx_list=[ctx3, ctx4])
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 2)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.ctx_list[1].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
+ dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
self.assertEquals(rep.u.ctx_list[1].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx3.context_id,
opnum=0,
stub="")
self.assertEquals(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- req = self.generate_alter(call_id=43, ctx_list=[ctx4,ctx3])
+ req = self.generate_alter(call_id=43, ctx_list=[ctx4, ctx3])
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 2)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.ctx_list[1].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
+ dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
self.assertEquals(rep.u.ctx_list[1].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx4.context_id,
opnum=0,
stub="")
self.assertEquals(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx3.context_id,
opnum=0,
stub="")
self.assertEquals(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- req = self.generate_alter(call_id=44, ctx_list=[ctx4,ctx4])
+ req = self.generate_alter(call_id=44, ctx_list=[ctx4, ctx4])
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 2)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.ctx_list[1].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
+ dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
self.assertEquals(rep.u.ctx_list[1].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx4.context_id,
opnum=0,
stub="")
self.assertEquals(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx3.context_id,
opnum=0,
stub="")
ctx5epm.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
ctx5epm.transfer_syntaxes = tsf5epm_list
- req = self.generate_alter(call_id=55, ctx_list=[ctx5mgmt,ctx5epm])
+ req = self.generate_alter(call_id=55, ctx_list=[ctx5mgmt, ctx5epm])
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 2)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.ctx_list[1].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
+ dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
self.assertEquals(rep.u.ctx_list[1].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx5mgmt.context_id,
opnum=0,
stub="")
self.assertEquals(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- req = self.generate_alter(call_id=55, ctx_list=[ctx5mgmt,ctx5epm])
+ req = self.generate_alter(call_id=55, ctx_list=[ctx5mgmt, ctx5epm])
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 2)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.ctx_list[1].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
+ dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
self.assertEquals(rep.u.ctx_list[1].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx5mgmt.context_id,
opnum=0,
stub="")
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
+ dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
self.assertEquals(rep.u.ctx_list[0].reason, features)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
features1 = 0
btf1 = base.bind_time_features_syntax(features1)
- features2 = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
+ features2 = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
features2 |= dcerpc.DCERPC_BIND_TIME_SECURITY_CONTEXT_MULTIPLEXING
btf2 = base.bind_time_features_syntax(features2)
zero_syntax = misc.ndr_syntax_id()
ndr64 = base.transfer_syntax_ndr64()
- tsf1_list = [btf1,btf2,zero_syntax]
+ tsf1_list = [btf1, btf2, zero_syntax]
ctx1 = dcerpc.ctx_list()
ctx1.context_id = 1
ctx1.num_transfer_syntaxes = len(tsf1_list)
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
+ dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
self.assertEquals(rep.u.ctx_list[0].reason, features1)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
zero_syntax = misc.ndr_syntax_id()
- tsf1_list = [zero_syntax,btf1,btf2,zero_syntax]
+ tsf1_list = [zero_syntax, btf1, btf2, zero_syntax]
ctx1 = dcerpc.ctx_list()
ctx1.context_id = 1
ctx1.num_transfer_syntaxes = len(tsf1_list)
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
+ dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
ctx2.abstract_syntax = zero_syntax
ctx2.transfer_syntaxes = tsf2_list
- req = self.generate_bind(call_id=0, ctx_list=[ctx1,ctx2])
+ req = self.generate_bind(call_id=0, ctx_list=[ctx1, ctx2])
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
self.assertEquals(rep.u.reject_reason,
- dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
self.assertEquals(rep.u.num_versions, 1)
self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
+ dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
self.assertEquals(rep.u.ctx_list[0].reason, features)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
zero_syntax = misc.ndr_syntax_id()
ndr64 = base.transfer_syntax_ndr64()
- tsf1_list = [btf1,btf2,zero_syntax]
+ tsf1_list = [btf1, btf2, zero_syntax]
ctx1 = dcerpc.ctx_list()
ctx1.context_id = 1
ctx1.num_transfer_syntaxes = len(tsf1_list)
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
+ dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
self.assertEquals(rep.u.ctx_list[0].reason, features1)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
self.assertEquals(rep.u.auth_info, '\0' * 0)
def _test_auth_type_level_bind_nak(self, auth_type, auth_level, creds=None,
- reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE):
+ reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE):
ndr32 = base.transfer_syntax_ndr()
tsf1_list = [ndr32]
if creds is not None:
# We always start with DCERPC_AUTH_LEVEL_INTEGRITY
auth_context = self.get_auth_context_creds(creds,
- auth_type=auth_type,
- auth_level=auth_level,
- auth_context_id=auth_context_id,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY)
+ auth_type=auth_type,
+ auth_level=auth_level,
+ auth_context_id=auth_context_id,
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY)
from_server = ""
(finished, to_server) = auth_context["gensec"].update(from_server)
self.assertFalse(finished)
def _test_auth_none_level_bind(self, auth_level,
reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE):
return self._test_auth_type_level_bind_nak(auth_type=dcerpc.DCERPC_AUTH_LEVEL_NONE,
- auth_level=auth_level, reason=reason)
+ auth_level=auth_level, reason=reason)
def test_auth_none_none_bind(self):
return self._test_auth_none_level_bind(dcerpc.DCERPC_AUTH_LEVEL_NONE,
- reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
def test_auth_none_connect_bind(self):
return self._test_auth_none_level_bind(dcerpc.DCERPC_AUTH_LEVEL_CONNECT)
def test_auth_none_0_bind(self):
return self._test_auth_none_level_bind(0,
- reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
def test_auth_none_7_bind(self):
return self._test_auth_none_level_bind(7,
- reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
def test_auth_none_255_bind(self):
return self._test_auth_none_level_bind(255,
- reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
def _test_auth_none_level_request(self, auth_level):
ndr32 = base.transfer_syntax_ndr()
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(len(rep.u.auth_info), 0)
# And now try a request without auth_info
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx1.context_id,
opnum=0,
stub="")
auth_context_id=auth_context_id,
auth_blob="none")
- req = self.generate_request(call_id = 3,
+ req = self.generate_request(call_id=3,
context_id=ctx1.context_id,
opnum=0,
stub="",
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
req = self.generate_alter(call_id=1,
max_xmit_frag=alter_xmit,
max_recv_frag=alter_recv,
- assoc_group_id=0xffffffff-rep.u.assoc_group_id,
+ assoc_group_id=0xffffffff - rep.u.assoc_group_id,
ctx_list=[ctx1])
self.send_pdu(req)
rep = self.recv_pdu()
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
chunk_size = rep_both - dcerpc.DCERPC_REQUEST_LENGTH
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx1.context_id,
opnum=0,
alloc_hint=0xffffffff,
stub="\00" * chunk_size)
- self.send_pdu(req,ndr_print=True,hexdump=True)
- rep = self.recv_pdu(ndr_print=True,hexdump=True)
+ self.send_pdu(req, ndr_print=True, hexdump=True)
+ rep = self.recv_pdu(ndr_print=True, hexdump=True)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
chunk_size = 5840 - dcerpc.DCERPC_REQUEST_LENGTH
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx1.context_id,
opnum=0,
alloc_hint=0xffffffff,
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
chunk_size += 1
- req = self.generate_request(call_id = 3,
+ req = self.generate_request(call_id=3,
context_id=ctx1.context_id,
opnum=0,
alloc_hint=0xffffffff,
return self._test_neg_xmit_check_values(req_xmit=3199,
req_recv=0,
rep_both=2048)
+
def test_neg_xmit_0_3199(self):
return self._test_neg_xmit_check_values(req_xmit=0,
req_recv=3199,
return self._test_neg_xmit_check_values(req_xmit=3199,
req_recv=0xffff,
rep_both=3192)
+
def test_neg_xmit_ffff_3199(self):
return self._test_neg_xmit_check_values(req_xmit=0xffff,
req_recv=3199,
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertEquals(rep.u.auth_info, '\0' * 0)
# And now try a request without auth_info
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx.context_id,
opnum=0,
alloc_hint=0xffffffff,
self.assertEquals(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- req = self.generate_request(call_id = 3,
+ req = self.generate_request(call_id=3,
context_id=ctx.context_id,
opnum=1,
alloc_hint=0xffffffff,
self.assertEquals(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- req = self.generate_request(call_id = 4,
+ req = self.generate_request(call_id=4,
context_id=ctx.context_id,
opnum=1,
alloc_hint=1,
computer = 'UNKNOWNCOMPUTER'
computer_utf16 = unicode(computer, 'utf-8').encode('utf-16-le')
- real_stub = struct.pack('<IIII', 0x00200000,
- len(server)+1, 0, len(server)+1)
+ real_stub = struct.pack('<IIII', 0x00200000,
+ len(server) + 1, 0, len(server) + 1)
real_stub += server_utf16 + '\x00\x00'
mod_len = len(real_stub) % 4
if mod_len != 0:
real_stub += '\x00' * (4 - mod_len)
real_stub += struct.pack('<III',
- len(computer)+1, 0, len(computer)+1)
+ len(computer) + 1, 0, len(computer) + 1)
real_stub += computer_utf16 + '\x00\x00'
real_stub += '\x11\x22\x33\x44\x55\x66\x77\x88'
# And now try a request without auth_info
# netr_ServerReqChallenge()
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=0x21234,
pfc_flags=pfc_flags,
context_id=ctx.context_id,
opnum=4,
alloc_hint -= thistime
else:
alloc_hint = 0
- self.send_pdu(req,hexdump=False)
+ self.send_pdu(req, hexdump=False)
if fault_first is not None:
rep = self.recv_pdu()
# We get a fault back
(ctx, rep, real_stub) = self._get_netlogon_ctx()
# netr_ServerReqChallenge with given flags
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
pfc_flags=pfc_flags,
context_id=ctx.context_id,
opnum=4,
# netr_ServerReqChallenge without DCERPC_PFC_FLAG_LAST
# with the same call_id
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
pfc_flags=pfc_flags,
context_id=ctx.context_id,
opnum=4,
(ctx, rep, real_stub) = self._get_netlogon_ctx()
# netr_ServerReqChallenge with given flags
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST |
- dcerpc.DCERPC_PFC_FLAG_PENDING_CANCEL,
+ dcerpc.DCERPC_PFC_FLAG_PENDING_CANCEL,
context_id=ctx.context_id,
opnum=4,
stub=real_stub)
(ctx, rep, real_stub) = self._get_netlogon_ctx()
# netr_ServerReqChallenge with given flags
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
context_id=ctx.context_id,
opnum=4,
self.assertIsConnected()
# netr_ServerReqChallenge with given flags
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_PENDING_CANCEL,
context_id=ctx.context_id,
opnum=4,
self.assertIsConnected()
# netr_ServerReqChallenge with given flags
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST,
context_id=ctx.context_id,
opnum=4,
(ctx, rep, real_stub) = self._get_netlogon_ctx()
# netr_ServerReqChallenge with given flags
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
context_id=ctx.context_id,
opnum=4,
self.assertIsConnected()
# netr_ServerReqChallenge with given flags
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST |
dcerpc.DCERPC_PFC_FLAG_PENDING_CANCEL,
context_id=ctx.context_id,
(ctx, rep, real_stub) = self._get_netlogon_ctx()
# netr_ServerReqChallenge with given flags
- req = self.generate_request(call_id = 50,
+ req = self.generate_request(call_id=50,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
context_id=ctx.context_id,
opnum=4,
self.assertIsConnected()
# netr_ServerReqChallenge with given flags
- req = self.generate_request(call_id = 51,
+ req = self.generate_request(call_id=51,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
context_id=ctx.context_id,
opnum=4,
abstract = samba.dcerpc.mgmt.abstract_syntax()
ctx = self.prepare_presentation(abstract, ndr32, context_id=0xff)
- req = self.generate_co_cancel(call_id = 3)
+ req = self.generate_co_cancel(call_id=3)
self.send_pdu(req)
rep = self.recv_pdu(timeout=0.01)
self.assertIsNone(rep)
self.assertIsConnected()
# And now try a request
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx.context_id,
opnum=0,
stub="")
abstract = samba.dcerpc.mgmt.abstract_syntax()
ctx = self.prepare_presentation(abstract, ndr32, context_id=0xff)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
context_id=ctx.context_id,
opnum=0,
self.assertIsNone(rep)
self.assertIsConnected()
- req = self.generate_co_cancel(call_id = 1)
+ req = self.generate_co_cancel(call_id=1)
self.send_pdu(req)
rep = self.recv_pdu(timeout=0.01)
self.assertIsNone(rep)
self.assertIsConnected()
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST,
context_id=ctx.context_id,
opnum=0,
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# And now try a request
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx.context_id,
opnum=0,
stub="")
abstract = samba.dcerpc.mgmt.abstract_syntax()
ctx = self.prepare_presentation(abstract, ndr32)
- req = self.generate_orphaned(call_id = 3)
+ req = self.generate_orphaned(call_id=3)
self.send_pdu(req)
rep = self.recv_pdu(timeout=0.01)
self.assertIsNone(rep)
self.assertIsConnected()
# And now try a request
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
context_id=ctx.context_id,
opnum=0,
stub="")
abstract = samba.dcerpc.mgmt.abstract_syntax()
ctx = self.prepare_presentation(abstract, ndr32)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
context_id=ctx.context_id,
opnum=0,
self.assertIsNone(rep)
self.assertIsConnected()
- req = self.generate_orphaned(call_id = 1)
+ req = self.generate_orphaned(call_id=1)
self.send_pdu(req)
rep = self.recv_pdu(timeout=0.1)
self.assertIsNone(rep)
self.assertIsConnected()
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST,
context_id=ctx.context_id,
opnum=0,
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# And now try a request
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx.context_id,
opnum=0,
stub="")
pfc_flags |= samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_CONC_MPX
ctx = self.prepare_presentation(abstract, ndr32, pfc_flags=pfc_flags)
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
context_id=ctx.context_id,
opnum=0,
self.assertIsNone(rep)
self.assertIsConnected()
- req = self.generate_orphaned(call_id = 1)
+ req = self.generate_orphaned(call_id=1)
self.send_pdu(req)
rep = self.recv_pdu(timeout=0.1)
self.assertIsNone(rep)
self.assertIsConnected()
- req = self.generate_request(call_id = 1,
+ req = self.generate_request(call_id=1,
pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST,
context_id=ctx.context_id,
opnum=0,
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# And now try a request
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx.context_id,
opnum=0,
stub="")
abstract = samba.dcerpc.mgmt.abstract_syntax()
ctx = self.prepare_presentation(abstract, ndr32)
- req1 = self.generate_request(call_id = 1,
- pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
- context_id=ctx.context_id,
- opnum=0,
- stub="")
+ req1 = self.generate_request(call_id=1,
+ pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
+ context_id=ctx.context_id,
+ opnum=0,
+ stub="")
self.send_pdu(req1)
rep = self.recv_pdu(timeout=0.1)
self.assertIsNone(rep)
self.assertIsConnected()
- req = self.generate_orphaned(call_id = 1)
+ req = self.generate_orphaned(call_id=1)
self.send_pdu(req)
rep = self.recv_pdu(timeout=0.1)
self.assertIsNone(rep)
self.assertIsConnected()
# And now try a new request
- req2 = self.generate_request(call_id = 2,
- context_id=ctx.context_id,
- opnum=0,
- stub="")
+ req2 = self.generate_request(call_id=2,
+ context_id=ctx.context_id,
+ opnum=0,
+ stub="")
self.send_pdu(req2)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req1.call_id,
ctx = self.prepare_presentation(abstract, ndr32,
pfc_flags=pfc_flags)
- req1 = self.generate_request(call_id = 1,
- pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
- context_id=ctx.context_id,
- opnum=0,
- stub="")
+ req1 = self.generate_request(call_id=1,
+ pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
+ context_id=ctx.context_id,
+ opnum=0,
+ stub="")
self.send_pdu(req1)
rep = self.recv_pdu(timeout=0.1)
self.assertIsNone(rep)
self.assertIsConnected()
- req = self.generate_orphaned(call_id = 1)
+ req = self.generate_orphaned(call_id=1)
self.send_pdu(req)
rep = self.recv_pdu(timeout=0.1)
self.assertIsNone(rep)
self.assertIsConnected()
# And now try a new request
- req2 = self.generate_request(call_id = 2,
- context_id=ctx.context_id-1,
- opnum=0,
- stub="")
+ req2 = self.generate_request(call_id=2,
+ context_id=ctx.context_id - 1,
+ opnum=0,
+ stub="")
self.send_pdu(req2)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req2.call_id,
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
self.assertTrue(finished)
# And now try a request without auth_info
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx1.context_id,
opnum=0,
stub="")
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=auth_level,
auth_context_id=auth_context_id,
- auth_blob="\x01"+"\x00"*15)
- req = self.generate_request(call_id = 3,
+ auth_blob="\x01" +"\x00" *15)
+ req = self.generate_request(call_id=3,
context_id=ctx1.context_id,
opnum=0,
stub="",
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
auth_context_id=auth_context_id,
- auth_blob="\x01"+"\x00"*15)
- req = self.generate_request(call_id = 4,
+ auth_blob="\x01" + "\x00" * 15)
+ req = self.generate_request(call_id=4,
context_id=ctx1.context_id,
opnum=0,
stub="",
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
auth_context_id=auth_context_id,
- auth_blob="\x01"+"\x00"*15)
- req = self.generate_request(call_id = 3,
+ auth_blob="\x01" + "\x00" * 15)
+ req = self.generate_request(call_id=3,
context_id=ctx1.context_id,
opnum=0,
stub="",
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=auth_level,
auth_context_id=auth_context_id,
- auth_blob="\x01"+"\x00"*15)
- req = self.generate_request(call_id = 1,
+ auth_blob="\x01" + "\x00" * 15)
+ req = self.generate_request(call_id=1,
context_id=ctx1.context_id,
opnum=0,
stub="",
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
self.assertIsConnected()
# And now try a request without auth_info
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx1.context_id,
opnum=0,
stub="")
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
self.assertTrue(finished)
# And now try a request without auth_info
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx1.context_id,
opnum=0,
stub="")
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=auth_level,
auth_context_id=auth_context_id,
- auth_blob="\x01"+"\x00"*15)
- req = self.generate_request(call_id = 3,
+ auth_blob="\x01" + "\x00" * 15)
+ req = self.generate_request(call_id=3,
context_id=ctx1.context_id,
opnum=0,
stub="",
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
self.assertTrue(finished)
# And now try a request without auth_info
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx1.context_id,
opnum=0,
stub="")
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=auth_level,
auth_context_id=auth_context_id,
- auth_blob="\x01"+"\x00"*15)
- req = self.generate_request(call_id = 3,
+ auth_blob="\x01" + "\x00" * 15)
+ req = self.generate_request(call_id=3,
context_id=ctx1.context_id,
opnum=0,
stub="",
self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
ctx1.transfer_syntaxes = tsf1_list
- tsf1b_list = [ndr32,ndr64]
+ tsf1b_list = [ndr32, ndr64]
ctx1b = dcerpc.ctx_list()
ctx1b.context_id = 1
ctx1b.num_transfer_syntaxes = len(tsf1b_list)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
ctx1.transfer_syntaxes = tsf1_list
- tsf1b_list = [ndr32,ndr64]
+ tsf1b_list = [ndr32, ndr64]
ctx1b = dcerpc.ctx_list()
ctx1b.context_id = 1
ctx1b.num_transfer_syntaxes = len(tsf1b_list)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
ctx1.transfer_syntaxes = tsf1_list
- tsf1b_list = [ndr32,ndr64]
+ tsf1b_list = [ndr32, ndr64]
ctx1b = dcerpc.ctx_list()
ctx1b.context_id = 1
ctx1b.num_transfer_syntaxes = len(tsf1b_list)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
self.assertTrue(finished)
# And now try a request without auth_info
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx1.context_id,
opnum=0,
stub="")
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=auth_level,
auth_context_id=auth_context_id,
- auth_blob="\x01"+"\x00"*15)
- req = self.generate_request(call_id = 3,
+ auth_blob="\x01" + "\x00" * 15)
+ req = self.generate_request(call_id=3,
context_id=ctx1.context_id,
opnum=0,
stub="",
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
self.assertEquals(rep.u.reject_reason,
- dcerpc.DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED)
+ dcerpc.DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED)
self.assertEquals(rep.u.num_versions, 1)
self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
self.assertIsConnected()
# And now try a request without auth_info
- req = self.generate_request(call_id = 2,
+ req = self.generate_request(call_id=2,
context_id=ctx1.context_id,
opnum=0,
stub="")
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=auth_level,
auth_context_id=auth_context_id,
- auth_blob="\x01"+"\x00"*15)
- req = self.generate_request(call_id = 3,
+ auth_blob="\x01" + "\x00" * 15)
+ req = self.generate_request(call_id=3,
context_id=ctx1.context_id,
opnum=0,
stub="",
#self.assertEquals(rep.u._pad1, '\0' * 2)
self.assertEquals(rep.u.num_results, 1)
self.assertEquals(rep.u.ctx_list[0].result,
- dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
+ dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
self.assertEquals(rep.u.ctx_list[0].reason,
- dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
+ dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
a = self.parse_auth(rep.u.auth_info)
return auth_context["gensec"]
def _test_spnego_level_bind_nak(self, auth_level,
- reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_CHECKSUM):
+ reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_CHECKSUM):
c = self.get_user_creds()
return self._test_auth_type_level_bind_nak(auth_type=dcerpc.DCERPC_AUTH_TYPE_SPNEGO,
auth_level=auth_level, creds=c, reason=reason)
sig_size = g.sig_size(len(stub_bin))
else:
sig_size = 16
- zero_sig = "\x00"*sig_size
+ zero_sig = "\x00" * sig_size
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=auth_level,
auth_pad_length=auth_pad_length,
auth_context_id=auth_context_id,
auth_blob=zero_sig)
- req = self.generate_request(call_id = 4,
+ req = self.generate_request(call_id=4,
context_id=ctx1.context_id,
opnum=0xffff,
stub=stub_bin,
auth_pad_length=auth_pad_length,
auth_context_id=auth_context_id,
auth_blob=sig)
- req = self.generate_request(call_id = 4,
+ req = self.generate_request(call_id=4,
context_id=ctx1.context_id,
opnum=0xffff,
stub=stub_bin,
def test_spnego_none_bind(self):
return self._test_spnego_level_bind_nak(dcerpc.DCERPC_AUTH_LEVEL_NONE,
- reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
def test_spnego_call_bind(self):
return self._test_spnego_level_bind_nak(dcerpc.DCERPC_AUTH_LEVEL_CALL,
- reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_CHECKSUM)
+ reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_CHECKSUM)
def test_spnego_0_bind(self):
return self._test_spnego_level_bind_nak(0,
- reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
def test_spnego_7_bind(self):
return self._test_spnego_level_bind_nak(7,
- reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
def test_spnego_255_bind(self):
return self._test_spnego_level_bind_nak(255,
- reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
+ reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
def test_spnego_connect_bind_none(self):
return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT)
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT)
def test_spnego_connect_bind_sign(self):
return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY)
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY)
def test_spnego_connect_bind_seal(self):
return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY)
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY)
def test_spnego_packet_bind_none(self):
# DCERPC_AUTH_LEVEL_PACKET is handled as alias of
# DCERPC_AUTH_LEVEL_INTEGRITY
return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_PACKET,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
- request_fault=dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
+ request_fault=dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
def test_spnego_packet_bind_sign(self):
# DCERPC_AUTH_LEVEL_PACKET is handled as alias of
# DCERPC_AUTH_LEVEL_INTEGRITY
return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_PACKET,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
- request_fault=dcerpc.DCERPC_NCA_S_OP_RNG_ERROR,
- response_fault_flags=dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE)
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
+ request_fault=dcerpc.DCERPC_NCA_S_OP_RNG_ERROR,
+ response_fault_flags=dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE)
def test_spnego_packet_bind_sign(self):
# DCERPC_AUTH_LEVEL_PACKET is handled as alias of
# DCERPC_AUTH_LEVEL_INTEGRITY
return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_PACKET,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
- request_fault=dcerpc.DCERPC_NCA_S_OP_RNG_ERROR,
- response_fault_flags=dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE)
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
+ request_fault=dcerpc.DCERPC_NCA_S_OP_RNG_ERROR,
+ response_fault_flags=dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE)
def test_spnego_integrity_bind_none(self):
return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
- request_fault=dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
+ request_fault=dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
def test_spnego_integrity_bind_sign(self):
return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
- request_fault=dcerpc.DCERPC_NCA_S_OP_RNG_ERROR,
- response_fault_flags=dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE)
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
+ request_fault=dcerpc.DCERPC_NCA_S_OP_RNG_ERROR,
+ response_fault_flags=dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE)
def test_spnego_integrity_bind_seal(self):
return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
- request_fault=dcerpc.DCERPC_NCA_S_OP_RNG_ERROR,
- response_fault_flags=dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE)
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
+ request_fault=dcerpc.DCERPC_NCA_S_OP_RNG_ERROR,
+ response_fault_flags=dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE)
def test_spnego_privacy_bind_none(self):
# This fails...
return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
- alter_fault=dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
+ alter_fault=dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
def test_spnego_privacy_bind_sign(self):
# This fails...
return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
- alter_fault=dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
+ alter_fault=dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
def test_spnego_privacy_bind_seal(self):
return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
- g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY)
+ g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY)
stub_bin += '\x00' * auth_pad_length
sig_size = g.sig_size(len(stub_bin))
- zero_sig = "\x00"*sig_size
+ zero_sig = "\x00" * sig_size
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=auth_level,
auth_pad_length=auth_pad_length,
auth_context_id=auth_context_id,
auth_blob=zero_sig)
- req = self.generate_request(call_id = 3,
+ req = self.generate_request(call_id=3,
context_id=ctx1.context_id,
opnum=0,
stub=stub_bin,
auth_pad_length=auth_pad_length,
auth_context_id=auth_context_id,
auth_blob=sig)
- req = self.generate_request(call_id = 3,
+ req = self.generate_request(call_id=3,
context_id=ctx1.context_id,
opnum=0,
stub=stub_bin,
stub_bin += '\x00' * auth_pad_length
sig_size = g.sig_size(len(stub_bin))
- zero_sig = "\x00"*sig_size
+ zero_sig = "\x00" * sig_size
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=auth_level,
auth_pad_length=auth_pad_length,
auth_context_id=auth_context_id,
auth_blob=zero_sig)
- req = self.generate_request(call_id = 4,
+ req = self.generate_request(call_id=4,
context_id=ctx1.context_id,
opnum=0xffff,
stub=stub_bin,
auth_pad_length=auth_pad_length,
auth_context_id=auth_context_id,
auth_blob=sig)
- req = self.generate_request(call_id = 4,
+ req = self.generate_request(call_id=4,
context_id=ctx1.context_id,
opnum=0xffff,
stub=stub_bin,
stub_bin += '\x00' * auth_pad_length
sig_size = g.sig_size(len(stub_bin))
- zero_sig = "\x00"*sig_size
+ zero_sig = "\x00" * sig_size
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=auth_level,
auth_pad_length=auth_pad_length,
auth_context_id=auth_context_id,
auth_blob=zero_sig)
- req = self.generate_request(call_id = 5,
+ req = self.generate_request(call_id=5,
context_id=ctx1.context_id,
opnum=1,
stub=stub_bin,
auth_pad_length=auth_pad_length,
auth_context_id=auth_context_id,
auth_blob=sig)
- req = self.generate_request(call_id = 5,
+ req = self.generate_request(call_id=5,
context_id=ctx1.context_id,
opnum=1,
stub=stub_bin,
stub_bin += '\x00' * auth_pad_length
sig_size = g.sig_size(len(stub_bin))
- zero_sig = "\x00"*sig_size
+ zero_sig = "\x00" * sig_size
auth_info = self.generate_auth(auth_type=auth_type,
auth_level=auth_level,
auth_pad_length=auth_pad_length,
auth_context_id=auth_context_id,
auth_blob=zero_sig)
- req = self.generate_request(call_id = 6,
+ req = self.generate_request(call_id=6,
context_id=ctx1.context_id,
opnum=3,
stub=stub_bin,
auth_pad_length=auth_pad_length,
auth_context_id=auth_context_id,
auth_blob=sig)
- req = self.generate_request(call_id = 6,
+ req = self.generate_request(call_id=6,
context_id=ctx1.context_id,
opnum=3,
stub=stub_bin,
ack = self.do_generic_bind(ctx=ctx)
self._disconnect("test_assoc_group_fail2")
+ self.assertNotConnected()
+ time.sleep(0.5)
self.connect()
- ack2 = self.do_generic_bind(ctx=ctx,assoc_group_id=ack.u.assoc_group_id,
+ ack2 = self.do_generic_bind(ctx=ctx, assoc_group_id=ack.u.assoc_group_id,
nak_reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
return
context_id=2, return_ack=True)
inq_if_ids = samba.dcerpc.mgmt.inq_if_ids()
- self.do_single_request(call_id = 1, ctx=ctx1, io=inq_if_ids)
- conn2.do_single_request(call_id = 1, ctx=ctx2, io=inq_if_ids)
+ self.do_single_request(call_id=1, ctx=ctx1, io=inq_if_ids)
+ conn2.do_single_request(call_id=1, ctx=ctx2, io=inq_if_ids)
- conn2.do_single_request(call_id = 1, ctx=ctx1, io=inq_if_ids,
- fault_pfc_flags = samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_FIRST |
- samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_LAST |
- samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
+ conn2.do_single_request(call_id=1, ctx=ctx1, io=inq_if_ids,
+ fault_pfc_flags=samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_FIRST |
+ samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_LAST |
+ samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
fault_status=dcerpc.DCERPC_NCA_S_UNKNOWN_IF,
fault_context_id=0)
- self.do_single_request(call_id = 1, ctx=ctx1, io=inq_if_ids)
- conn2.do_single_request(call_id = 1, ctx=ctx2, io=inq_if_ids)
+ self.do_single_request(call_id=1, ctx=ctx1, io=inq_if_ids)
+ conn2.do_single_request(call_id=1, ctx=ctx2, io=inq_if_ids)
return
if __name__ == "__main__":
git.samba.org / samba.git / blobdiff