python/samba/tests/dcerpc/raw_protocol.py

   1 #!/usr/bin/env python
   2 # Unix SMB/CIFS implementation.
   3 # Copyright (C) Stefan Metzmacher 2014,2015
   4 #
   5 # This program is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 3 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 #
  18
  19 import sys
  20 import os
  21 import time
  22
  23 sys.path.insert(0, "bin/python")
  24 os.environ["PYTHONUNBUFFERED"] = "1"
  25
  26 import samba.dcerpc.dcerpc as dcerpc
  27 import samba.dcerpc.base as base
  28 import samba.dcerpc.misc as misc
  29 import samba.dcerpc.epmapper
  30 import samba.dcerpc.mgmt
  31 import samba.dcerpc.netlogon
  32 import struct
  33 from samba import gensec
  34 from samba.tests.dcerpc.raw_testcase import RawDCERPCTest
  35 from samba.compat import binary_type
  36
  37 global_ndr_print = False
  38 global_hexdump = False
  39
  40
  41 class TestDCERPC_BIND(RawDCERPCTest):
  42
  43     def setUp(self):
  44         super(TestDCERPC_BIND, self).setUp()
  45         self.do_ndr_print = global_ndr_print
  46         self.do_hexdump = global_hexdump
  47
  48     def _test_no_auth_request_bind_pfc_flags(self, req_pfc_flags, rep_pfc_flags):
  49         ndr32 = base.transfer_syntax_ndr()
  50
  51         tsf1_list = [ndr32]
  52         ctx1 = dcerpc.ctx_list()
  53         ctx1.context_id = 1
  54         ctx1.num_transfer_syntaxes = len(tsf1_list)
  55         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
  56         ctx1.transfer_syntaxes = tsf1_list
  57
  58         req = self.generate_bind(call_id=0, pfc_flags=req_pfc_flags, ctx_list=[ctx1])
  59         self.send_pdu(req)
  60         rep = self.recv_pdu()
  61         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
  62                         pfc_flags=rep_pfc_flags, auth_length=0)
  63         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
  64         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
  65         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
  66         self.assertEquals(rep.u.secondary_address_size, 4)
  67         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
  68         self.assertEquals(len(rep.u._pad1), 2)
  69         # sometimes windows sends random bytes
  70         # self.assertEquals(rep.u._pad1, '\0' * 2)
  71         self.assertEquals(rep.u.num_results, 1)
  72         self.assertEquals(rep.u.ctx_list[0].result,
  73                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
  74         self.assertEquals(rep.u.ctx_list[0].reason,
  75                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
  76         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
  77         self.assertEquals(rep.u.auth_info, b'\0' * 0)
  78
  79         # And now try a request
  80         req = self.generate_request(call_id=1,
  81                                     context_id=ctx1.context_id,
  82                                     opnum=0,
  83                                     stub=b"")
  84         self.send_pdu(req)
  85         rep = self.recv_pdu()
  86         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
  87                         auth_length=0)
  88         self.assertNotEquals(rep.u.alloc_hint, 0)
  89         self.assertEquals(rep.u.context_id, req.u.context_id)
  90         self.assertEquals(rep.u.cancel_count, 0)
  91         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
  92
  93     def _test_no_auth_request_alter_pfc_flags(self, req_pfc_flags, rep_pfc_flags):
  94         ndr32 = base.transfer_syntax_ndr()
  95
  96         tsf1_list = [ndr32]
  97         ctx1 = dcerpc.ctx_list()
  98         ctx1.context_id = 1
  99         ctx1.num_transfer_syntaxes = len(tsf1_list)
 100         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 101         ctx1.transfer_syntaxes = tsf1_list
 102
 103         req = self.generate_bind(call_id=0, ctx_list=[ctx1])
 104         self.send_pdu(req)
 105         rep = self.recv_pdu()
 106         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
 107                         auth_length=0)
 108         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 109         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 110         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 111         self.assertEquals(rep.u.secondary_address_size, 4)
 112         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
 113         self.assertEquals(len(rep.u._pad1), 2)
 114         # sometimes windows sends random bytes
 115         # self.assertEquals(rep.u._pad1, '\0' * 2)
 116         self.assertEquals(rep.u.num_results, 1)
 117         self.assertEquals(rep.u.ctx_list[0].result,
 118                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
 119         self.assertEquals(rep.u.ctx_list[0].reason,
 120                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
 121         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
 122         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 123
 124         # And now try a alter context
 125         req = self.generate_alter(call_id=0, pfc_flags=req_pfc_flags, ctx_list=[ctx1])
 126         self.send_pdu(req)
 127         rep = self.recv_pdu()
 128         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
 129                         pfc_flags=rep_pfc_flags, auth_length=0)
 130         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 131         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 132         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 133         self.assertEquals(rep.u.secondary_address_size, 0)
 134         self.assertEquals(rep.u.secondary_address, "")
 135         self.assertEquals(len(rep.u._pad1), 2)
 136         # sometimes windows sends random bytes
 137         # self.assertEquals(rep.u._pad1, '\0' * 2)
 138         self.assertEquals(rep.u.num_results, 1)
 139         self.assertEquals(rep.u.ctx_list[0].result,
 140                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
 141         self.assertEquals(rep.u.ctx_list[0].reason,
 142                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
 143         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
 144         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 145
 146         # And now try a request
 147         req = self.generate_request(call_id=1,
 148                                     context_id=ctx1.context_id,
 149                                     opnum=0,
 150                                     stub=b"")
 151         self.send_pdu(req)
 152         rep = self.recv_pdu()
 153         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
 154                         auth_length=0)
 155         self.assertNotEquals(rep.u.alloc_hint, 0)
 156         self.assertEquals(rep.u.context_id, req.u.context_id)
 157         self.assertEquals(rep.u.cancel_count, 0)
 158         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
 159
 160     def test_no_auth_request(self):
 161         return self._test_no_auth_request_bind_pfc_flags(
 162                                         req_pfc_flags=0 |
 163                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 164                                         dcerpc.DCERPC_PFC_FLAG_LAST,
 165                                         rep_pfc_flags=0 |
 166                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 167                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 168
 169     def test_no_auth_request_bind_pfc_00(self):
 170         return self._test_no_auth_request_bind_pfc_flags(
 171                                         req_pfc_flags=0 |
 172                                         0,
 173                                         rep_pfc_flags=0 |
 174                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 175                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 176
 177     def test_no_auth_request_bind_pfc_FIRST(self):
 178         return self._test_no_auth_request_bind_pfc_flags(
 179                                         req_pfc_flags=0 |
 180                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 181                                         0,
 182                                         rep_pfc_flags=0 |
 183                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 184                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 185
 186     def test_no_auth_request_bind_pfc_LAST(self):
 187         return self._test_no_auth_request_bind_pfc_flags(
 188                                         req_pfc_flags=0 |
 189                                         dcerpc.DCERPC_PFC_FLAG_LAST |
 190                                         0,
 191                                         rep_pfc_flags=0 |
 192                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 193                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 194
 195     # TODO: doesn't announce DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN
 196     # without authentication
 197     def _test_no_auth_request_bind_pfc_HDR_SIGNING(self):
 198         return self._test_no_auth_request_bind_pfc_flags(
 199                                         req_pfc_flags=0 |
 200                                         dcerpc.DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN |
 201                                         0,
 202                                         rep_pfc_flags=0 |
 203                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 204                                         dcerpc.DCERPC_PFC_FLAG_LAST |
 205                                         dcerpc.DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN)
 206
 207     def test_no_auth_request_bind_pfc_08(self):
 208         return self._test_no_auth_request_bind_pfc_flags(
 209                                         req_pfc_flags=0 |
 210                                         8 |
 211                                         0,
 212                                         rep_pfc_flags=0 |
 213                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 214                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 215
 216     def test_no_auth_request_bind_pfc_CONC_MPX(self):
 217         return self._test_no_auth_request_bind_pfc_flags(
 218                                         req_pfc_flags=0 |
 219                                         dcerpc.DCERPC_PFC_FLAG_CONC_MPX |
 220                                         0,
 221                                         rep_pfc_flags=0 |
 222                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 223                                         dcerpc.DCERPC_PFC_FLAG_LAST |
 224                                         dcerpc.DCERPC_PFC_FLAG_CONC_MPX)
 225
 226     def test_no_auth_request_bind_pfc_DID_NOT_EXECUTE(self):
 227         return self._test_no_auth_request_bind_pfc_flags(
 228                                         req_pfc_flags=0 |
 229                                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
 230                                         0,
 231                                         rep_pfc_flags=0 |
 232                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 233                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 234
 235     def test_no_auth_request_bind_pfc_MAYBE(self):
 236         return self._test_no_auth_request_bind_pfc_flags(
 237                                         req_pfc_flags=0 |
 238                                         dcerpc.DCERPC_PFC_FLAG_MAYBE |
 239                                         0,
 240                                         rep_pfc_flags=0 |
 241                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 242                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 243
 244     def test_no_auth_request_bind_pfc_OBJECT_UUID(self):
 245         return self._test_no_auth_request_bind_pfc_flags(
 246                                         req_pfc_flags=0 |
 247                                         dcerpc.DCERPC_PFC_FLAG_OBJECT_UUID |
 248                                         0,
 249                                         rep_pfc_flags=0 |
 250                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 251                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 252
 253     # TODO: doesn't announce DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN
 254     # without authentication
 255     # TODO: doesn't announce DCERPC_PFC_FLAG_CONC_MPX
 256     # by default
 257     def _test_no_auth_request_bind_pfc_ff(self):
 258         return self._test_no_auth_request_bind_pfc_flags(
 259                                         req_pfc_flags=0 |
 260                                         0xff |
 261                                         0,
 262                                         rep_pfc_flags=0 |
 263                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 264                                         dcerpc.DCERPC_PFC_FLAG_LAST |
 265                                         dcerpc.DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN |
 266                                         dcerpc.DCERPC_PFC_FLAG_CONC_MPX)
 267
 268     def test_no_auth_request_alter_pfc_00(self):
 269         return self._test_no_auth_request_alter_pfc_flags(
 270                                         req_pfc_flags=0 |
 271                                         0,
 272                                         rep_pfc_flags=0 |
 273                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 274                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 275
 276     def test_no_auth_request_alter_pfc_FIRST(self):
 277         return self._test_no_auth_request_alter_pfc_flags(
 278                                         req_pfc_flags=0 |
 279                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 280                                         0,
 281                                         rep_pfc_flags=0 |
 282                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 283                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 284
 285     def test_no_auth_request_alter_pfc_LAST(self):
 286         return self._test_no_auth_request_alter_pfc_flags(
 287                                         req_pfc_flags=0 |
 288                                         dcerpc.DCERPC_PFC_FLAG_LAST |
 289                                         0,
 290                                         rep_pfc_flags=0 |
 291                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 292                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 293
 294     # TODO: doesn't announce DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN
 295     # without authentication
 296     def _test_no_auth_request_alter_pfc_HDR_SIGNING(self):
 297         return self._test_no_auth_request_alter_pfc_flags(
 298                                         req_pfc_flags=0 |
 299                                         dcerpc.DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN |
 300                                         0,
 301                                         rep_pfc_flags=0 |
 302                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 303                                         dcerpc.DCERPC_PFC_FLAG_LAST |
 304                                         dcerpc.DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN)
 305
 306     def test_no_auth_request_alter_pfc_08(self):
 307         return self._test_no_auth_request_alter_pfc_flags(
 308                                         req_pfc_flags=0 |
 309                                         8 |
 310                                         0,
 311                                         rep_pfc_flags=0 |
 312                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 313                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 314
 315     def test_no_auth_request_alter_pfc_CONC_MPX(self):
 316         return self._test_no_auth_request_alter_pfc_flags(
 317                                         req_pfc_flags=0 |
 318                                         dcerpc.DCERPC_PFC_FLAG_CONC_MPX |
 319                                         0,
 320                                         rep_pfc_flags=0 |
 321                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 322                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 323
 324     def test_no_auth_request_alter_pfc_DID_NOT_EXECUTE(self):
 325         return self._test_no_auth_request_alter_pfc_flags(
 326                                         req_pfc_flags=0 |
 327                                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
 328                                         0,
 329                                         rep_pfc_flags=0 |
 330                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 331                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 332
 333     def test_no_auth_request_alter_pfc_MAYBE(self):
 334         return self._test_no_auth_request_alter_pfc_flags(
 335                                         req_pfc_flags=0 |
 336                                         dcerpc.DCERPC_PFC_FLAG_MAYBE |
 337                                         0,
 338                                         rep_pfc_flags=0 |
 339                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 340                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 341
 342     def test_no_auth_request_alter_pfc_OBJECT_UUID(self):
 343         return self._test_no_auth_request_alter_pfc_flags(
 344                                         req_pfc_flags=0 |
 345                                         dcerpc.DCERPC_PFC_FLAG_OBJECT_UUID |
 346                                         0,
 347                                         rep_pfc_flags=0 |
 348                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 349                                         dcerpc.DCERPC_PFC_FLAG_LAST)
 350
 351     # TODO: doesn't announce DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN
 352     # without authentication
 353     def _test_no_auth_request_alter_pfc_ff(self):
 354         return self._test_no_auth_request_alter_pfc_flags(
 355                                         req_pfc_flags=0 |
 356                                         0xff |
 357                                         0,
 358                                         rep_pfc_flags=0 |
 359                                         dcerpc.DCERPC_PFC_FLAG_FIRST |
 360                                         dcerpc.DCERPC_PFC_FLAG_LAST |
 361                                         dcerpc.DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN)
 362
 363     def test_no_auth_no_ctx(self):
 364         # send an useless bind
 365         req = self.generate_bind(call_id=0)
 366         self.send_pdu(req)
 367         rep = self.recv_pdu()
 368         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
 369                         auth_length=0)
 370         self.assertEquals(rep.u.reject_reason,
 371                           dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
 372         self.assertEquals(rep.u.num_versions, 1)
 373         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
 374         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
 375         self.assertEquals(len(rep.u._pad), 3)
 376         self.assertEquals(rep.u._pad, b'\0' * 3)
 377
 378     def test_invalid_auth_noctx(self):
 379         req = self.generate_bind(call_id=0)
 380         req.auth_length = dcerpc.DCERPC_AUTH_TRAILER_LENGTH
 381         self.send_pdu(req)
 382         rep = self.recv_pdu()
 383         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
 384                         auth_length=0)
 385         self.assertEquals(rep.u.reject_reason,
 386                           dcerpc.DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED)
 387         self.assertEquals(rep.u.num_versions, 1)
 388         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
 389         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
 390         self.assertEquals(len(rep.u._pad), 3)
 391         self.assertEquals(rep.u._pad, b'\0' * 3)
 392
 393     def test_no_auth_valid_valid_request(self):
 394         ndr32 = base.transfer_syntax_ndr()
 395
 396         tsf1_list = [ndr32]
 397         ctx1 = dcerpc.ctx_list()
 398         ctx1.context_id = 1
 399         ctx1.num_transfer_syntaxes = len(tsf1_list)
 400         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 401         ctx1.transfer_syntaxes = tsf1_list
 402
 403         req = self.generate_bind(call_id=0, ctx_list=[ctx1])
 404         self.send_pdu(req)
 405         rep = self.recv_pdu()
 406         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
 407                         auth_length=0)
 408         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 409         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 410         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 411         self.assertEquals(rep.u.secondary_address_size, 4)
 412         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
 413         self.assertEquals(len(rep.u._pad1), 2)
 414         self.assertEquals(rep.u._pad1, b'\0' * 2)
 415         self.assertEquals(rep.u.num_results, 1)
 416         self.assertEquals(rep.u.ctx_list[0].result,
 417                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
 418         self.assertEquals(rep.u.ctx_list[0].reason,
 419                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
 420         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
 421         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 422
 423         # Send a bind again
 424         tsf2_list = [ndr32]
 425         ctx2 = dcerpc.ctx_list()
 426         ctx2.context_id = 2
 427         ctx2.num_transfer_syntaxes = len(tsf2_list)
 428         ctx2.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 429         ctx2.transfer_syntaxes = tsf2_list
 430
 431         req = self.generate_bind(call_id=1, ctx_list=[ctx2])
 432         self.send_pdu(req)
 433         rep = self.recv_pdu()
 434         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
 435                         auth_length=0)
 436         self.assertEquals(rep.u.reject_reason,
 437                           dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
 438         self.assertEquals(rep.u.num_versions, 1)
 439         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
 440         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
 441         self.assertEquals(len(rep.u._pad), 3)
 442         self.assertEquals(rep.u._pad, b'\0' * 3)
 443
 444         # wait for a disconnect
 445         rep = self.recv_pdu()
 446         self.assertIsNone(rep)
 447         self.assertNotConnected()
 448
 449     def test_no_auth_invalid_valid_request(self):
 450         # send an useless bind
 451         req = self.generate_bind(call_id=0)
 452         self.send_pdu(req)
 453         rep = self.recv_pdu()
 454         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
 455                         auth_length=0)
 456         self.assertEquals(rep.u.reject_reason,
 457                           dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
 458         self.assertEquals(rep.u.num_versions, 1)
 459         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
 460         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
 461         self.assertEquals(len(rep.u._pad), 3)
 462         self.assertEquals(rep.u._pad, b'\0' * 3)
 463
 464         # wait for a disconnect
 465         rep = self.recv_pdu()
 466         self.assertIsNone(rep)
 467         self.assertNotConnected()
 468
 469     def test_alter_no_auth_no_ctx(self):
 470         ndr32 = base.transfer_syntax_ndr()
 471
 472         tsf1_list = [ndr32]
 473         ctx1 = dcerpc.ctx_list()
 474         ctx1.context_id = 1
 475         ctx1.num_transfer_syntaxes = len(tsf1_list)
 476         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 477         ctx1.transfer_syntaxes = tsf1_list
 478
 479         req = self.generate_bind(call_id=0, ctx_list=[ctx1])
 480         self.send_pdu(req)
 481         rep = self.recv_pdu()
 482         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
 483                         auth_length=0)
 484         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 485         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 486         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 487         self.assertEquals(rep.u.secondary_address_size, 4)
 488         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
 489         self.assertEquals(len(rep.u._pad1), 2)
 490         self.assertEquals(rep.u._pad1, b'\0' * 2)
 491         self.assertEquals(rep.u.num_results, 1)
 492         self.assertEquals(rep.u.ctx_list[0].result,
 493                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
 494         self.assertEquals(rep.u.ctx_list[0].reason,
 495                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
 496         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
 497         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 498
 499         # Send a alter
 500         req = self.generate_alter(call_id=1, ctx_list=[])
 501         self.send_pdu(req)
 502         rep = self.recv_pdu()
 503         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
 504                         pfc_flags=req.pfc_flags |
 505                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
 506                         auth_length=0)
 507         self.assertNotEquals(rep.u.alloc_hint, 0)
 508         self.assertEquals(rep.u.context_id, 0)
 509         self.assertEquals(rep.u.cancel_count, 0)
 510         self.assertEquals(rep.u.flags, 0)
 511         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
 512         self.assertEquals(rep.u.reserved, 0)
 513         self.assertEquals(len(rep.u.error_and_verifier), 0)
 514
 515         # wait for a disconnect
 516         rep = self.recv_pdu()
 517         self.assertIsNone(rep)
 518         self.assertNotConnected()
 519
 520     def test_no_auth_presentation_ctx_valid1(self):
 521         ndr32 = base.transfer_syntax_ndr()
 522
 523         zero_syntax = misc.ndr_syntax_id()
 524
 525         tsf1_list = [zero_syntax, ndr32]
 526         ctx1 = dcerpc.ctx_list()
 527         ctx1.context_id = 1
 528         ctx1.num_transfer_syntaxes = len(tsf1_list)
 529         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 530         ctx1.transfer_syntaxes = tsf1_list
 531
 532         req = self.generate_bind(call_id=0, ctx_list=[ctx1])
 533         self.send_pdu(req)
 534         rep = self.recv_pdu()
 535         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
 536                         auth_length=0)
 537         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 538         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 539         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 540         self.assertEquals(rep.u.secondary_address_size, 4)
 541         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
 542         self.assertEquals(len(rep.u._pad1), 2)
 543         self.assertEquals(rep.u._pad1, b'\0' * 2)
 544         self.assertEquals(rep.u.num_results, 1)
 545         self.assertEquals(rep.u.ctx_list[0].result,
 546                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
 547         self.assertEquals(rep.u.ctx_list[0].reason,
 548                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
 549         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
 550         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 551
 552         # Send a alter
 553         req = self.generate_alter(call_id=1, ctx_list=[ctx1])
 554         self.send_pdu(req)
 555         rep = self.recv_pdu()
 556         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
 557                         auth_length=0)
 558         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 559         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 560         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 561         self.assertEquals(rep.u.secondary_address_size, 0)
 562         self.assertEquals(len(rep.u._pad1), 2)
 563         #self.assertEquals(rep.u._pad1, '\0' * 2)
 564         self.assertEquals(rep.u.num_results, 1)
 565         self.assertEquals(rep.u.ctx_list[0].result,
 566                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
 567         self.assertEquals(rep.u.ctx_list[0].reason,
 568                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
 569         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
 570         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 571
 572         req = self.generate_request(call_id=2,
 573                                     context_id=ctx1.context_id,
 574                                     opnum=0xffff,
 575                                     stub=b"")
 576         self.send_pdu(req)
 577         rep = self.recv_pdu()
 578         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
 579                         pfc_flags=req.pfc_flags |
 580                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
 581                         auth_length=0)
 582         self.assertNotEquals(rep.u.alloc_hint, 0)
 583         self.assertEquals(rep.u.context_id, ctx1.context_id)
 584         self.assertEquals(rep.u.cancel_count, 0)
 585         self.assertEquals(rep.u.flags, 0)
 586         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_OP_RNG_ERROR)
 587         self.assertEquals(rep.u.reserved, 0)
 588         self.assertEquals(len(rep.u.error_and_verifier), 0)
 589
 590     def test_no_auth_presentation_ctx_invalid1(self):
 591         ndr32 = base.transfer_syntax_ndr()
 592
 593         zero_syntax = misc.ndr_syntax_id()
 594
 595         tsf1_list = [ndr32]
 596         ctx1 = dcerpc.ctx_list()
 597         ctx1.context_id = 1
 598         ctx1.num_transfer_syntaxes = len(tsf1_list)
 599         ctx1.abstract_syntax = ndr32
 600         ctx1.transfer_syntaxes = tsf1_list
 601
 602         req = self.generate_bind(call_id=0, ctx_list=[ctx1])
 603         self.send_pdu(req)
 604         rep = self.recv_pdu()
 605         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
 606                         auth_length=0)
 607         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 608         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 609         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 610         self.assertEquals(rep.u.secondary_address_size, 4)
 611         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
 612         self.assertEquals(len(rep.u._pad1), 2)
 613         self.assertEquals(rep.u._pad1, b'\0' * 2)
 614         self.assertEquals(rep.u.num_results, 1)
 615         self.assertEquals(rep.u.ctx_list[0].result,
 616                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
 617         self.assertEquals(rep.u.ctx_list[0].reason,
 618                           dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
 619         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
 620         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 621
 622         # Send a alter
 623         req = self.generate_alter(call_id=1, ctx_list=[ctx1])
 624         self.send_pdu(req)
 625         rep = self.recv_pdu()
 626         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
 627                         auth_length=0)
 628         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 629         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 630         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 631         self.assertEquals(rep.u.secondary_address_size, 0)
 632         self.assertEquals(len(rep.u._pad1), 2)
 633         #self.assertEquals(rep.u._pad1, '\0' * 2)
 634         self.assertEquals(rep.u.num_results, 1)
 635         self.assertEquals(rep.u.ctx_list[0].result,
 636                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
 637         self.assertEquals(rep.u.ctx_list[0].reason,
 638                           dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
 639         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
 640         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 641
 642         req = self.generate_request(call_id=2,
 643                                     context_id=12345,
 644                                     opnum=0,
 645                                     stub=b"")
 646         self.send_pdu(req)
 647         rep = self.recv_pdu()
 648         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
 649                         pfc_flags=req.pfc_flags |
 650                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
 651                         auth_length=0)
 652         self.assertNotEquals(rep.u.alloc_hint, 0)
 653         self.assertEquals(rep.u.context_id, 0)
 654         self.assertEquals(rep.u.cancel_count, 0)
 655         self.assertEquals(rep.u.flags, 0)
 656         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_UNKNOWN_IF)
 657         self.assertEquals(rep.u.reserved, 0)
 658         self.assertEquals(len(rep.u.error_and_verifier), 0)
 659
 660         # Send a alter again to prove the connection is still alive
 661         req = self.generate_alter(call_id=3, ctx_list=[ctx1])
 662         self.send_pdu(req)
 663         rep = self.recv_pdu()
 664         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
 665                         auth_length=0)
 666         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 667         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 668         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 669         self.assertEquals(rep.u.secondary_address_size, 0)
 670         self.assertEquals(len(rep.u._pad1), 2)
 671         #self.assertEquals(rep.u._pad1, '\0' * 2)
 672         self.assertEquals(rep.u.num_results, 1)
 673         self.assertEquals(rep.u.ctx_list[0].result,
 674                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
 675         self.assertEquals(rep.u.ctx_list[0].reason,
 676                           dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
 677         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
 678         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 679
 680     def test_no_auth_presentation_ctx_invalid2(self):
 681         ndr32 = base.transfer_syntax_ndr()
 682
 683         zero_syntax = misc.ndr_syntax_id()
 684
 685         tsf1a_list = []
 686         ctx1a = dcerpc.ctx_list()
 687         ctx1a.context_id = 1
 688         ctx1a.num_transfer_syntaxes = len(tsf1a_list)
 689         ctx1a.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 690         ctx1a.transfer_syntaxes = tsf1a_list
 691
 692         req = self.generate_bind(call_id=0, ctx_list=[ctx1a])
 693         self.send_pdu(req)
 694         rep = self.recv_pdu()
 695         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
 696                         auth_length=0)
 697         self.assertEquals(rep.u.reject_reason,
 698                           dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
 699         self.assertEquals(rep.u.num_versions, 1)
 700         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
 701         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
 702         self.assertEquals(len(rep.u._pad), 3)
 703         self.assertEquals(rep.u._pad, b'\0' * 3)
 704
 705         # wait for a disconnect
 706         rep = self.recv_pdu()
 707         self.assertIsNone(rep)
 708         self.assertNotConnected()
 709
 710     def test_no_auth_presentation_ctx_invalid3(self):
 711         ndr32 = base.transfer_syntax_ndr()
 712
 713         zero_syntax = misc.ndr_syntax_id()
 714
 715         tsf1a_list = [zero_syntax, ndr32, ndr32, ndr32]
 716         ctx1a = dcerpc.ctx_list()
 717         ctx1a.context_id = 1
 718         ctx1a.num_transfer_syntaxes = len(tsf1a_list)
 719         ctx1a.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 720         ctx1a.transfer_syntaxes = tsf1a_list
 721
 722         req = self.generate_bind(call_id=0, ctx_list=[ctx1a])
 723         self.send_pdu(req)
 724         rep = self.recv_pdu()
 725         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
 726                         auth_length=0)
 727         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 728         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 729         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 730         self.assertEquals(rep.u.secondary_address_size, 4)
 731         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
 732         self.assertEquals(len(rep.u._pad1), 2)
 733         self.assertEquals(rep.u._pad1, b'\0' * 2)
 734         self.assertEquals(rep.u.num_results, 1)
 735         self.assertEquals(rep.u.ctx_list[0].result,
 736                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
 737         self.assertEquals(rep.u.ctx_list[0].reason,
 738                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
 739         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
 740         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 741
 742         tsf1b_list = []
 743         ctx1b = dcerpc.ctx_list()
 744         ctx1b.context_id = 1
 745         ctx1b.num_transfer_syntaxes = len(tsf1b_list)
 746         ctx1b.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 747         ctx1b.transfer_syntaxes = tsf1b_list
 748
 749         # Send a alter
 750         req = self.generate_alter(call_id=1, ctx_list=[ctx1b])
 751         self.send_pdu(req)
 752         rep = self.recv_pdu()
 753         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
 754                         pfc_flags=req.pfc_flags |
 755                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
 756                         auth_length=0)
 757         self.assertNotEquals(rep.u.alloc_hint, 0)
 758         self.assertEquals(rep.u.context_id, 0)
 759         self.assertEquals(rep.u.cancel_count, 0)
 760         self.assertEquals(rep.u.flags, 0)
 761         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
 762         self.assertEquals(rep.u.reserved, 0)
 763         self.assertEquals(len(rep.u.error_and_verifier), 0)
 764
 765         # wait for a disconnect
 766         rep = self.recv_pdu()
 767         self.assertIsNone(rep)
 768         self.assertNotConnected()
 769
 770     def test_no_auth_presentation_ctx_invalid4(self):
 771         ndr32 = base.transfer_syntax_ndr()
 772         ndr64 = base.transfer_syntax_ndr64()
 773
 774         zero_syntax = misc.ndr_syntax_id()
 775
 776         tsf1a_list = [zero_syntax, ndr32, ndr32, ndr32]
 777         ctx1a = dcerpc.ctx_list()
 778         ctx1a.context_id = 1
 779         ctx1a.num_transfer_syntaxes = len(tsf1a_list)
 780         ctx1a.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 781         ctx1a.transfer_syntaxes = tsf1a_list
 782
 783         req = self.generate_bind(call_id=0, ctx_list=[ctx1a])
 784         self.send_pdu(req)
 785         rep = self.recv_pdu()
 786         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
 787                         auth_length=0)
 788         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 789         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 790         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 791         self.assertEquals(rep.u.secondary_address_size, 4)
 792         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
 793         self.assertEquals(len(rep.u._pad1), 2)
 794         self.assertEquals(rep.u._pad1, b'\0' * 2)
 795         self.assertEquals(rep.u.num_results, 1)
 796         self.assertEquals(rep.u.ctx_list[0].result,
 797                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
 798         self.assertEquals(rep.u.ctx_list[0].reason,
 799                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
 800         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
 801         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 802
 803         # With a known but wrong syntax we get a protocol error
 804         # see test_no_auth_presentation_ctx_valid2
 805         tsf1b_list = [zero_syntax, samba.dcerpc.epmapper.abstract_syntax(), ndr64]
 806         ctx1b = dcerpc.ctx_list()
 807         ctx1b.context_id = 1
 808         ctx1b.num_transfer_syntaxes = len(tsf1b_list)
 809         ctx1b.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 810         ctx1b.transfer_syntaxes = tsf1b_list
 811
 812         # Send a alter
 813         req = self.generate_alter(call_id=1, ctx_list=[ctx1b])
 814         self.send_pdu(req)
 815         rep = self.recv_pdu()
 816         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
 817                         pfc_flags=req.pfc_flags |
 818                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
 819                         auth_length=0)
 820         self.assertNotEquals(rep.u.alloc_hint, 0)
 821         self.assertEquals(rep.u.context_id, 0)
 822         self.assertEquals(rep.u.cancel_count, 0)
 823         self.assertEquals(rep.u.flags, 0)
 824         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
 825         self.assertEquals(rep.u.reserved, 0)
 826         self.assertEquals(len(rep.u.error_and_verifier), 0)
 827
 828         # wait for a disconnect
 829         rep = self.recv_pdu()
 830         self.assertIsNone(rep)
 831         self.assertNotConnected()
 832
 833     def test_no_auth_presentation_ctx_valid2(self):
 834         ndr32 = base.transfer_syntax_ndr()
 835
 836         zero_syntax = misc.ndr_syntax_id()
 837
 838         tsf1a_list = [zero_syntax, ndr32, ndr32, ndr32]
 839         ctx1a = dcerpc.ctx_list()
 840         ctx1a.context_id = 1
 841         ctx1a.num_transfer_syntaxes = len(tsf1a_list)
 842         ctx1a.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 843         ctx1a.transfer_syntaxes = tsf1a_list
 844
 845         req = self.generate_bind(call_id=0, ctx_list=[ctx1a])
 846         self.send_pdu(req)
 847         rep = self.recv_pdu()
 848         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
 849                         auth_length=0)
 850         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 851         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 852         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 853         self.assertEquals(rep.u.secondary_address_size, 4)
 854         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
 855         self.assertEquals(len(rep.u._pad1), 2)
 856         self.assertEquals(rep.u._pad1, b'\0' * 2)
 857         self.assertEquals(rep.u.num_results, 1)
 858         self.assertEquals(rep.u.ctx_list[0].result,
 859                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
 860         self.assertEquals(rep.u.ctx_list[0].reason,
 861                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
 862         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
 863         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 864
 865         # With a unknown but wrong syntaxes we get NO protocol error
 866         # see test_no_auth_presentation_ctx_invalid4
 867         tsf1b_list = [zero_syntax, samba.dcerpc.epmapper.abstract_syntax()]
 868         ctx1b = dcerpc.ctx_list()
 869         ctx1b.context_id = 1
 870         ctx1b.num_transfer_syntaxes = len(tsf1b_list)
 871         ctx1b.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 872         ctx1b.transfer_syntaxes = tsf1b_list
 873
 874         # Send a alter
 875         req = self.generate_alter(call_id=1, ctx_list=[ctx1b])
 876         self.send_pdu(req)
 877         rep = self.recv_pdu()
 878         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
 879                         auth_length=0)
 880         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 881         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 882         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 883         self.assertEquals(rep.u.secondary_address_size, 0)
 884         self.assertEquals(len(rep.u._pad1), 2)
 885         #self.assertEquals(rep.u._pad1, '\0' * 2)
 886         self.assertEquals(rep.u.num_results, 1)
 887         self.assertEquals(rep.u.ctx_list[0].result,
 888                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
 889         self.assertEquals(rep.u.ctx_list[0].reason,
 890                           dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
 891         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
 892         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 893
 894         req = self.generate_request(call_id=2,
 895                                     context_id=ctx1a.context_id,
 896                                     opnum=0xffff,
 897                                     stub=b"")
 898         self.send_pdu(req)
 899         rep = self.recv_pdu()
 900         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
 901                         pfc_flags=req.pfc_flags |
 902                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
 903                         auth_length=0)
 904         self.assertNotEquals(rep.u.alloc_hint, 0)
 905         self.assertEquals(rep.u.context_id, ctx1a.context_id)
 906         self.assertEquals(rep.u.cancel_count, 0)
 907         self.assertEquals(rep.u.flags, 0)
 908         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_OP_RNG_ERROR)
 909         self.assertEquals(rep.u.reserved, 0)
 910         self.assertEquals(len(rep.u.error_and_verifier), 0)
 911
 912     def test_no_auth_presentation_ctx_no_ndr64(self):
 913         ndr32 = base.transfer_syntax_ndr()
 914         zero_syntax = misc.ndr_syntax_id()
 915
 916         tsfZ_list = [zero_syntax]
 917         ctxZ = dcerpc.ctx_list()
 918         ctxZ.context_id = 54321
 919         ctxZ.num_transfer_syntaxes = len(tsfZ_list)
 920         ctxZ.abstract_syntax = zero_syntax
 921         ctxZ.transfer_syntaxes = tsfZ_list
 922
 923         req = self.generate_bind(call_id=0, ctx_list=[ctxZ])
 924         self.send_pdu(req)
 925         rep = self.recv_pdu()
 926         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
 927                         auth_length=0)
 928         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 929         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 930         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 931         self.assertEquals(rep.u.secondary_address_size, 4)
 932         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
 933         self.assertEquals(len(rep.u._pad1), 2)
 934         self.assertEquals(rep.u._pad1, b'\0' * 2)
 935         self.assertEquals(rep.u.num_results, 1)
 936         self.assertEquals(rep.u.ctx_list[0].result,
 937                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
 938         self.assertEquals(rep.u.ctx_list[0].reason,
 939                           dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
 940         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
 941         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 942
 943         tsf0_list = [ndr32]
 944         ctx0 = dcerpc.ctx_list()
 945         ctx0.context_id = 0
 946         ctx0.num_transfer_syntaxes = len(tsf0_list)
 947         ctx0.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 948         ctx0.transfer_syntaxes = tsf0_list
 949
 950         req = self.generate_alter(call_id=0, ctx_list=[ctx0])
 951         self.send_pdu(req)
 952         rep = self.recv_pdu()
 953         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
 954                         auth_length=0)
 955         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 956         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 957         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 958         self.assertEquals(rep.u.secondary_address_size, 0)
 959         self.assertEquals(len(rep.u._pad1), 2)
 960         #self.assertEquals(rep.u._pad1, '\0' * 2)
 961         self.assertEquals(rep.u.num_results, 1)
 962         self.assertEquals(rep.u.ctx_list[0].result,
 963                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
 964         self.assertEquals(rep.u.ctx_list[0].reason,
 965                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
 966         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
 967         self.assertEquals(rep.u.auth_info, b'\0' * 0)
 968
 969         req = self.generate_request(call_id=1,
 970                                     context_id=ctx0.context_id,
 971                                     opnum=0,
 972                                     stub=b"")
 973         self.send_pdu(req)
 974         rep = self.recv_pdu()
 975         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
 976                         auth_length=0)
 977         self.assertNotEquals(rep.u.alloc_hint, 0)
 978         self.assertEquals(rep.u.context_id, req.u.context_id)
 979         self.assertEquals(rep.u.cancel_count, 0)
 980         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
 981
 982         tsf1_list = [zero_syntax, ndr32]
 983         ctx1 = dcerpc.ctx_list()
 984         ctx1.context_id = 1
 985         ctx1.num_transfer_syntaxes = len(tsf1_list)
 986         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
 987         ctx1.transfer_syntaxes = tsf1_list
 988
 989         req = self.generate_alter(call_id=1, ctx_list=[ctx1])
 990         self.send_pdu(req)
 991         rep = self.recv_pdu()
 992         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
 993                         auth_length=0)
 994         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
 995         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
 996         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
 997         self.assertEquals(rep.u.secondary_address_size, 0)
 998         self.assertEquals(len(rep.u._pad1), 2)
 999         #self.assertEquals(rep.u._pad1, '\0' * 2)
1000         self.assertEquals(rep.u.num_results, 1)
1001         self.assertEquals(rep.u.ctx_list[0].result,
1002                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
1003         self.assertEquals(rep.u.ctx_list[0].reason,
1004                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
1005         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
1006         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1007
1008         req = self.generate_request(call_id=1,
1009                                     context_id=ctx1.context_id,
1010                                     opnum=0,
1011                                     stub=b"")
1012         self.send_pdu(req)
1013         rep = self.recv_pdu()
1014         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1015                         auth_length=0)
1016         self.assertNotEquals(rep.u.alloc_hint, 0)
1017         self.assertEquals(rep.u.context_id, req.u.context_id)
1018         self.assertEquals(rep.u.cancel_count, 0)
1019         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1020
1021         tsf2_list = [ndr32, ndr32]
1022         ctx2 = dcerpc.ctx_list()
1023         ctx2.context_id = 2
1024         ctx2.num_transfer_syntaxes = len(tsf2_list)
1025         ctx2.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
1026         ctx2.transfer_syntaxes = tsf2_list
1027
1028         req = self.generate_alter(call_id=2, ctx_list=[ctx2])
1029         self.send_pdu(req)
1030         rep = self.recv_pdu()
1031         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
1032                         auth_length=0)
1033         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1034         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1035         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1036         self.assertEquals(rep.u.secondary_address_size, 0)
1037         self.assertEquals(len(rep.u._pad1), 2)
1038         #self.assertEquals(rep.u._pad1, '\0' * 2)
1039         self.assertEquals(rep.u.num_results, 1)
1040         self.assertEquals(rep.u.ctx_list[0].result,
1041                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
1042         self.assertEquals(rep.u.ctx_list[0].reason,
1043                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
1044         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
1045         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1046
1047         req = self.generate_request(call_id=1,
1048                                     context_id=ctx2.context_id,
1049                                     opnum=0,
1050                                     stub=b"")
1051         self.send_pdu(req)
1052         rep = self.recv_pdu()
1053         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1054                         auth_length=0)
1055         self.assertNotEquals(rep.u.alloc_hint, 0)
1056         self.assertEquals(rep.u.context_id, req.u.context_id)
1057         self.assertEquals(rep.u.cancel_count, 0)
1058         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1059
1060         tsf3_list = [ndr32]
1061         ctx3 = dcerpc.ctx_list()
1062         ctx3.context_id = 3
1063         ctx3.num_transfer_syntaxes = len(tsf3_list)
1064         ctx3.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
1065         ctx3.transfer_syntaxes = tsf3_list
1066
1067         tsf4_list = [ndr32]
1068         ctx4 = dcerpc.ctx_list()
1069         ctx4.context_id = 4
1070         ctx4.num_transfer_syntaxes = len(tsf4_list)
1071         ctx4.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
1072         ctx4.transfer_syntaxes = tsf4_list
1073
1074         req = self.generate_alter(call_id=34, ctx_list=[ctx3, ctx4])
1075         self.send_pdu(req)
1076         rep = self.recv_pdu()
1077         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
1078                         auth_length=0)
1079         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1080         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1081         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1082         self.assertEquals(rep.u.secondary_address_size, 0)
1083         self.assertEquals(len(rep.u._pad1), 2)
1084         #self.assertEquals(rep.u._pad1, '\0' * 2)
1085         self.assertEquals(rep.u.num_results, 2)
1086         self.assertEquals(rep.u.ctx_list[0].result,
1087                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
1088         self.assertEquals(rep.u.ctx_list[0].reason,
1089                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
1090         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
1091         self.assertEquals(rep.u.ctx_list[1].result,
1092                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
1093         self.assertEquals(rep.u.ctx_list[1].reason,
1094                           dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
1095         self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
1096         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1097
1098         req = self.generate_request(call_id=1,
1099                                     context_id=ctx3.context_id,
1100                                     opnum=0,
1101                                     stub=b"")
1102         self.send_pdu(req)
1103         rep = self.recv_pdu()
1104         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1105                         auth_length=0)
1106         self.assertNotEquals(rep.u.alloc_hint, 0)
1107         self.assertEquals(rep.u.context_id, req.u.context_id)
1108         self.assertEquals(rep.u.cancel_count, 0)
1109         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1110
1111         req = self.generate_alter(call_id=43, ctx_list=[ctx4, ctx3])
1112         self.send_pdu(req)
1113         rep = self.recv_pdu()
1114         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
1115                         auth_length=0)
1116         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1117         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1118         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1119         self.assertEquals(rep.u.secondary_address_size, 0)
1120         self.assertEquals(len(rep.u._pad1), 2)
1121         #self.assertEquals(rep.u._pad1, '\0' * 2)
1122         self.assertEquals(rep.u.num_results, 2)
1123         self.assertEquals(rep.u.ctx_list[0].result,
1124                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
1125         self.assertEquals(rep.u.ctx_list[0].reason,
1126                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
1127         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
1128         self.assertEquals(rep.u.ctx_list[1].result,
1129                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
1130         self.assertEquals(rep.u.ctx_list[1].reason,
1131                           dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
1132         self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
1133         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1134
1135         req = self.generate_request(call_id=1,
1136                                     context_id=ctx4.context_id,
1137                                     opnum=0,
1138                                     stub=b"")
1139         self.send_pdu(req)
1140         rep = self.recv_pdu()
1141         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1142                         auth_length=0)
1143         self.assertNotEquals(rep.u.alloc_hint, 0)
1144         self.assertEquals(rep.u.context_id, req.u.context_id)
1145         self.assertEquals(rep.u.cancel_count, 0)
1146         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1147
1148         req = self.generate_request(call_id=1,
1149                                     context_id=ctx3.context_id,
1150                                     opnum=0,
1151                                     stub=b"")
1152         self.send_pdu(req)
1153         rep = self.recv_pdu()
1154         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1155                         auth_length=0)
1156         self.assertNotEquals(rep.u.alloc_hint, 0)
1157         self.assertEquals(rep.u.context_id, req.u.context_id)
1158         self.assertEquals(rep.u.cancel_count, 0)
1159         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1160
1161         req = self.generate_alter(call_id=44, ctx_list=[ctx4, ctx4])
1162         self.send_pdu(req)
1163         rep = self.recv_pdu()
1164         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
1165                         auth_length=0)
1166         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1167         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1168         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1169         self.assertEquals(rep.u.secondary_address_size, 0)
1170         self.assertEquals(len(rep.u._pad1), 2)
1171         #self.assertEquals(rep.u._pad1, '\0' * 2)
1172         self.assertEquals(rep.u.num_results, 2)
1173         self.assertEquals(rep.u.ctx_list[0].result,
1174                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
1175         self.assertEquals(rep.u.ctx_list[0].reason,
1176                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
1177         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
1178         self.assertEquals(rep.u.ctx_list[1].result,
1179                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
1180         self.assertEquals(rep.u.ctx_list[1].reason,
1181                           dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
1182         self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
1183         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1184
1185         req = self.generate_request(call_id=1,
1186                                     context_id=ctx4.context_id,
1187                                     opnum=0,
1188                                     stub=b"")
1189         self.send_pdu(req)
1190         rep = self.recv_pdu()
1191         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1192                         auth_length=0)
1193         self.assertNotEquals(rep.u.alloc_hint, 0)
1194         self.assertEquals(rep.u.context_id, req.u.context_id)
1195         self.assertEquals(rep.u.cancel_count, 0)
1196         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1197
1198         req = self.generate_request(call_id=1,
1199                                     context_id=ctx3.context_id,
1200                                     opnum=0,
1201                                     stub=b"")
1202         self.send_pdu(req)
1203         rep = self.recv_pdu()
1204         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1205                         auth_length=0)
1206         self.assertNotEquals(rep.u.alloc_hint, 0)
1207         self.assertEquals(rep.u.context_id, req.u.context_id)
1208         self.assertEquals(rep.u.cancel_count, 0)
1209         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1210
1211         tsf5mgmt_list = [ndr32]
1212         ctx5mgmt = dcerpc.ctx_list()
1213         ctx5mgmt.context_id = 5
1214         ctx5mgmt.num_transfer_syntaxes = len(tsf5mgmt_list)
1215         ctx5mgmt.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
1216         ctx5mgmt.transfer_syntaxes = tsf5mgmt_list
1217
1218         tsf5epm_list = [ndr32]
1219         ctx5epm = dcerpc.ctx_list()
1220         ctx5epm.context_id = 5
1221         ctx5epm.num_transfer_syntaxes = len(tsf5epm_list)
1222         ctx5epm.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
1223         ctx5epm.transfer_syntaxes = tsf5epm_list
1224
1225         req = self.generate_alter(call_id=55, ctx_list=[ctx5mgmt, ctx5epm])
1226         self.send_pdu(req)
1227         rep = self.recv_pdu()
1228         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
1229                         auth_length=0)
1230         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1231         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1232         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1233         self.assertEquals(rep.u.secondary_address_size, 0)
1234         self.assertEquals(len(rep.u._pad1), 2)
1235         #self.assertEquals(rep.u._pad1, '\0' * 2)
1236         self.assertEquals(rep.u.num_results, 2)
1237         self.assertEquals(rep.u.ctx_list[0].result,
1238                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
1239         self.assertEquals(rep.u.ctx_list[0].reason,
1240                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
1241         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
1242         self.assertEquals(rep.u.ctx_list[1].result,
1243                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
1244         self.assertEquals(rep.u.ctx_list[1].reason,
1245                           dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
1246         self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
1247         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1248
1249         req = self.generate_request(call_id=1,
1250                                     context_id=ctx5mgmt.context_id,
1251                                     opnum=0,
1252                                     stub=b"")
1253         self.send_pdu(req)
1254         rep = self.recv_pdu()
1255         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1256                         auth_length=0)
1257         self.assertNotEquals(rep.u.alloc_hint, 0)
1258         self.assertEquals(rep.u.context_id, req.u.context_id)
1259         self.assertEquals(rep.u.cancel_count, 0)
1260         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1261
1262         req = self.generate_alter(call_id=55, ctx_list=[ctx5mgmt, ctx5epm])
1263         self.send_pdu(req)
1264         rep = self.recv_pdu()
1265         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
1266                         auth_length=0)
1267         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1268         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1269         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1270         self.assertEquals(rep.u.secondary_address_size, 0)
1271         self.assertEquals(len(rep.u._pad1), 2)
1272         #self.assertEquals(rep.u._pad1, '\0' * 2)
1273         self.assertEquals(rep.u.num_results, 2)
1274         self.assertEquals(rep.u.ctx_list[0].result,
1275                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
1276         self.assertEquals(rep.u.ctx_list[0].reason,
1277                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
1278         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
1279         self.assertEquals(rep.u.ctx_list[1].result,
1280                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
1281         self.assertEquals(rep.u.ctx_list[1].reason,
1282                           dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
1283         self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
1284         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1285
1286         req = self.generate_request(call_id=1,
1287                                     context_id=ctx5mgmt.context_id,
1288                                     opnum=0,
1289                                     stub=b"")
1290         self.send_pdu(req)
1291         rep = self.recv_pdu()
1292         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1293                         auth_length=0)
1294         self.assertNotEquals(rep.u.alloc_hint, 0)
1295         self.assertEquals(rep.u.context_id, req.u.context_id)
1296         self.assertEquals(rep.u.cancel_count, 0)
1297         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1298
1299     def test_no_auth_bind_time_none_simple(self):
1300         features = 0
1301         btf = base.bind_time_features_syntax(features)
1302
1303         zero_syntax = misc.ndr_syntax_id()
1304
1305         tsf1_list = [btf]
1306         ctx1 = dcerpc.ctx_list()
1307         ctx1.context_id = 1
1308         ctx1.num_transfer_syntaxes = len(tsf1_list)
1309         ctx1.abstract_syntax = zero_syntax
1310         ctx1.transfer_syntaxes = tsf1_list
1311
1312         req = self.generate_bind(call_id=0, ctx_list=[ctx1])
1313         self.send_pdu(req)
1314         rep = self.recv_pdu()
1315         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
1316                         auth_length=0)
1317         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1318         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1319         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1320         self.assertEquals(rep.u.secondary_address_size, 4)
1321         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
1322         self.assertEquals(len(rep.u._pad1), 2)
1323         self.assertEquals(rep.u._pad1, b'\0' * 2)
1324         self.assertEquals(rep.u.num_results, 1)
1325         self.assertEquals(rep.u.ctx_list[0].result,
1326                           dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
1327         self.assertEquals(rep.u.ctx_list[0].reason, features)
1328         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
1329         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1330
1331     def test_no_auth_bind_time_none_ignore_additional(self):
1332         features1 = 0
1333         btf1 = base.bind_time_features_syntax(features1)
1334
1335         features2 = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
1336         features2 |= dcerpc.DCERPC_BIND_TIME_SECURITY_CONTEXT_MULTIPLEXING
1337         btf2 = base.bind_time_features_syntax(features2)
1338
1339         zero_syntax = misc.ndr_syntax_id()
1340         ndr64 = base.transfer_syntax_ndr64()
1341
1342         tsf1_list = [btf1, btf2, zero_syntax]
1343         ctx1 = dcerpc.ctx_list()
1344         ctx1.context_id = 1
1345         ctx1.num_transfer_syntaxes = len(tsf1_list)
1346         ctx1.abstract_syntax = ndr64
1347         ctx1.transfer_syntaxes = tsf1_list
1348
1349         req = self.generate_bind(call_id=0, ctx_list=[ctx1])
1350         self.send_pdu(req)
1351         rep = self.recv_pdu()
1352         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
1353                         auth_length=0)
1354         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1355         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1356         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1357         self.assertEquals(rep.u.secondary_address_size, 4)
1358         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
1359         self.assertEquals(len(rep.u._pad1), 2)
1360         self.assertEquals(rep.u._pad1, b'\0' * 2)
1361         self.assertEquals(rep.u.num_results, 1)
1362         self.assertEquals(rep.u.ctx_list[0].result,
1363                           dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
1364         self.assertEquals(rep.u.ctx_list[0].reason, features1)
1365         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
1366         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1367
1368     def test_no_auth_bind_time_only_first(self):
1369         features1 = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
1370         btf1 = base.bind_time_features_syntax(features1)
1371
1372         features2 = dcerpc.DCERPC_BIND_TIME_SECURITY_CONTEXT_MULTIPLEXING
1373         btf2 = base.bind_time_features_syntax(features2)
1374
1375         zero_syntax = misc.ndr_syntax_id()
1376
1377         tsf1_list = [zero_syntax, btf1, btf2, zero_syntax]
1378         ctx1 = dcerpc.ctx_list()
1379         ctx1.context_id = 1
1380         ctx1.num_transfer_syntaxes = len(tsf1_list)
1381         ctx1.abstract_syntax = zero_syntax
1382         ctx1.transfer_syntaxes = tsf1_list
1383
1384         req = self.generate_bind(call_id=0, ctx_list=[ctx1])
1385         self.send_pdu(req)
1386         rep = self.recv_pdu()
1387         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
1388                         auth_length=0)
1389         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1390         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1391         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1392         self.assertEquals(rep.u.secondary_address_size, 4)
1393         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
1394         self.assertEquals(len(rep.u._pad1), 2)
1395         self.assertEquals(rep.u._pad1, b'\0' * 2)
1396         self.assertEquals(rep.u.num_results, 1)
1397         self.assertEquals(rep.u.ctx_list[0].result,
1398                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
1399         self.assertEquals(rep.u.ctx_list[0].reason,
1400                           dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
1401         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
1402         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1403
1404     def test_no_auth_bind_time_twice(self):
1405         features1 = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
1406         btf1 = base.bind_time_features_syntax(features1)
1407
1408         features2 = dcerpc.DCERPC_BIND_TIME_SECURITY_CONTEXT_MULTIPLEXING
1409         btf2 = base.bind_time_features_syntax(features2)
1410
1411         zero_syntax = misc.ndr_syntax_id()
1412
1413         tsf1_list = [btf1]
1414         ctx1 = dcerpc.ctx_list()
1415         ctx1.context_id = 1
1416         ctx1.num_transfer_syntaxes = len(tsf1_list)
1417         ctx1.abstract_syntax = zero_syntax
1418         ctx1.transfer_syntaxes = tsf1_list
1419
1420         tsf2_list = [btf2]
1421         ctx2 = dcerpc.ctx_list()
1422         ctx2.context_id = 2
1423         ctx2.num_transfer_syntaxes = len(tsf2_list)
1424         ctx2.abstract_syntax = zero_syntax
1425         ctx2.transfer_syntaxes = tsf2_list
1426
1427         req = self.generate_bind(call_id=0, ctx_list=[ctx1, ctx2])
1428         self.send_pdu(req)
1429         rep = self.recv_pdu()
1430         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
1431                         auth_length=0)
1432         self.assertEquals(rep.u.reject_reason,
1433                           dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
1434         self.assertEquals(rep.u.num_versions, 1)
1435         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
1436         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
1437         self.assertEquals(len(rep.u._pad), 3)
1438         self.assertEquals(rep.u._pad, b'\0' * 3)
1439
1440         # wait for a disconnect
1441         rep = self.recv_pdu()
1442         self.assertIsNone(rep)
1443         self.assertNotConnected()
1444
1445     def test_no_auth_bind_time_keep_on_orphan_simple(self):
1446         features = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
1447         btf = base.bind_time_features_syntax(features)
1448
1449         zero_syntax = misc.ndr_syntax_id()
1450
1451         tsf1_list = [btf]
1452         ctx1 = dcerpc.ctx_list()
1453         ctx1.context_id = 1
1454         ctx1.num_transfer_syntaxes = len(tsf1_list)
1455         ctx1.abstract_syntax = zero_syntax
1456         ctx1.transfer_syntaxes = tsf1_list
1457
1458         req = self.generate_bind(call_id=0, ctx_list=[ctx1])
1459         self.send_pdu(req)
1460         rep = self.recv_pdu()
1461         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
1462                         auth_length=0)
1463         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1464         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1465         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1466         self.assertEquals(rep.u.secondary_address_size, 4)
1467         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
1468         self.assertEquals(len(rep.u._pad1), 2)
1469         self.assertEquals(rep.u._pad1, b'\0' * 2)
1470         self.assertEquals(rep.u.num_results, 1)
1471         self.assertEquals(rep.u.ctx_list[0].result,
1472                           dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
1473         self.assertEquals(rep.u.ctx_list[0].reason, features)
1474         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
1475         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1476
1477     def test_no_auth_bind_time_keep_on_orphan_ignore_additional(self):
1478         features1 = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
1479         btf1 = base.bind_time_features_syntax(features1)
1480
1481         features2 = dcerpc.DCERPC_BIND_TIME_SECURITY_CONTEXT_MULTIPLEXING
1482         btf2 = base.bind_time_features_syntax(features2)
1483
1484         zero_syntax = misc.ndr_syntax_id()
1485         ndr64 = base.transfer_syntax_ndr64()
1486
1487         tsf1_list = [btf1, btf2, zero_syntax]
1488         ctx1 = dcerpc.ctx_list()
1489         ctx1.context_id = 1
1490         ctx1.num_transfer_syntaxes = len(tsf1_list)
1491         ctx1.abstract_syntax = ndr64
1492         ctx1.transfer_syntaxes = tsf1_list
1493
1494         req = self.generate_bind(call_id=0, ctx_list=[ctx1])
1495         self.send_pdu(req)
1496         rep = self.recv_pdu()
1497         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
1498                         auth_length=0)
1499         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1500         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1501         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1502         self.assertEquals(rep.u.secondary_address_size, 4)
1503         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
1504         self.assertEquals(len(rep.u._pad1), 2)
1505         self.assertEquals(rep.u._pad1, b'\0' * 2)
1506         self.assertEquals(rep.u.num_results, 1)
1507         self.assertEquals(rep.u.ctx_list[0].result,
1508                           dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
1509         self.assertEquals(rep.u.ctx_list[0].reason, features1)
1510         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
1511         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1512
1513     def _test_auth_type_level_bind_nak(self, auth_type, auth_level, creds=None,
1514                                        reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE):
1515         ndr32 = base.transfer_syntax_ndr()
1516
1517         tsf1_list = [ndr32]
1518         ctx1 = dcerpc.ctx_list()
1519         ctx1.context_id = 1
1520         ctx1.num_transfer_syntaxes = len(tsf1_list)
1521         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
1522         ctx1.transfer_syntaxes = tsf1_list
1523         ctx_list = [ctx1]
1524
1525         auth_context_id = 0
1526
1527         if creds is not None:
1528             # We always start with DCERPC_AUTH_LEVEL_INTEGRITY
1529             auth_context = self.get_auth_context_creds(creds,
1530                                                        auth_type=auth_type,
1531                                                        auth_level=auth_level,
1532                                                        auth_context_id=auth_context_id,
1533                                                        g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY)
1534             from_server = b""
1535             (finished, to_server) = auth_context["gensec"].update(from_server)
1536             self.assertFalse(finished)
1537
1538             auth_info = self.generate_auth(auth_type=auth_context["auth_type"],
1539                                            auth_level=auth_context["auth_level"],
1540                                            auth_context_id=auth_context["auth_context_id"],
1541                                            auth_blob=to_server)
1542         else:
1543             to_server = b"none"
1544             auth_info = self.generate_auth(auth_type=auth_type,
1545                                            auth_level=auth_level,
1546                                            auth_context_id=auth_context_id,
1547                                            auth_blob=to_server)
1548
1549         req = self.generate_bind(call_id=0,
1550                                  ctx_list=ctx_list,
1551                                  auth_info=auth_info)
1552         self.send_pdu(req)
1553         rep = self.recv_pdu()
1554         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
1555                         auth_length=0)
1556         self.assertEquals(rep.u.reject_reason, reason)
1557         self.assertEquals(rep.u.num_versions, 1)
1558         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
1559         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
1560         self.assertEquals(len(rep.u._pad), 3)
1561         self.assertEquals(rep.u._pad, b'\0' * 3)
1562
1563         # wait for a disconnect
1564         rep = self.recv_pdu()
1565         self.assertIsNone(rep)
1566         self.assertNotConnected()
1567
1568     def _test_auth_none_level_bind(self, auth_level,
1569                                    reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE):
1570         return self._test_auth_type_level_bind_nak(auth_type=dcerpc.DCERPC_AUTH_LEVEL_NONE,
1571                                                    auth_level=auth_level, reason=reason)
1572
1573     def test_auth_none_none_bind(self):
1574         return self._test_auth_none_level_bind(dcerpc.DCERPC_AUTH_LEVEL_NONE,
1575                                                reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
1576
1577     def test_auth_none_connect_bind(self):
1578         return self._test_auth_none_level_bind(dcerpc.DCERPC_AUTH_LEVEL_CONNECT)
1579
1580     def test_auth_none_call_bind(self):
1581         return self._test_auth_none_level_bind(dcerpc.DCERPC_AUTH_LEVEL_CALL)
1582
1583     def test_auth_none_packet_bind(self):
1584         return self._test_auth_none_level_bind(dcerpc.DCERPC_AUTH_LEVEL_PACKET)
1585
1586     def test_auth_none_integrity_bind(self):
1587         return self._test_auth_none_level_bind(dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY)
1588
1589     def test_auth_none_privacy_bind(self):
1590         return self._test_auth_none_level_bind(dcerpc.DCERPC_AUTH_LEVEL_PRIVACY)
1591
1592     def test_auth_none_0_bind(self):
1593         return self._test_auth_none_level_bind(0,
1594                                                reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
1595
1596     def test_auth_none_7_bind(self):
1597         return self._test_auth_none_level_bind(7,
1598                                                reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
1599
1600     def test_auth_none_255_bind(self):
1601         return self._test_auth_none_level_bind(255,
1602                                                reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
1603
1604     def _test_auth_none_level_request(self, auth_level):
1605         ndr32 = base.transfer_syntax_ndr()
1606
1607         tsf1_list = [ndr32]
1608         ctx1 = dcerpc.ctx_list()
1609         ctx1.context_id = 1
1610         ctx1.num_transfer_syntaxes = len(tsf1_list)
1611         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
1612         ctx1.transfer_syntaxes = tsf1_list
1613         ctx_list = [ctx1]
1614
1615         auth_type = dcerpc.DCERPC_AUTH_TYPE_NONE
1616         auth_context_id = 0
1617
1618         req = self.generate_bind(call_id=0,
1619                                  ctx_list=ctx_list)
1620
1621         self.send_pdu(req)
1622         rep = self.recv_pdu()
1623         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
1624         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1625         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1626         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1627         self.assertEquals(rep.u.secondary_address_size, 4)
1628         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
1629         self.assertEquals(len(rep.u._pad1), 2)
1630         self.assertEquals(rep.u._pad1, b'\0' * 2)
1631         self.assertEquals(rep.u.num_results, 1)
1632         self.assertEquals(rep.u.ctx_list[0].result,
1633                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
1634         self.assertEquals(rep.u.ctx_list[0].reason,
1635                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
1636         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
1637         self.assertEquals(len(rep.u.auth_info), 0)
1638
1639         # And now try a request without auth_info
1640         req = self.generate_request(call_id=2,
1641                                     context_id=ctx1.context_id,
1642                                     opnum=0,
1643                                     stub=b"")
1644         self.send_pdu(req)
1645         rep = self.recv_pdu()
1646         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1647                         auth_length=0)
1648         self.assertNotEquals(rep.u.alloc_hint, 0)
1649         self.assertEquals(rep.u.context_id, req.u.context_id)
1650         self.assertEquals(rep.u.cancel_count, 0)
1651         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1652
1653         auth_info = self.generate_auth(auth_type=auth_type,
1654                                        auth_level=auth_level,
1655                                        auth_context_id=auth_context_id,
1656                                        auth_blob=b"none")
1657
1658         req = self.generate_request(call_id=3,
1659                                     context_id=ctx1.context_id,
1660                                     opnum=0,
1661                                     stub=b"",
1662                                     auth_info=auth_info)
1663         self.send_pdu(req)
1664         rep = self.recv_pdu()
1665         # We get a fault back
1666         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
1667                         auth_length=0)
1668         self.assertNotEquals(rep.u.alloc_hint, 0)
1669         self.assertEquals(rep.u.context_id, req.u.context_id)
1670         self.assertEquals(rep.u.cancel_count, 0)
1671         self.assertEquals(rep.u.flags, 0)
1672         self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
1673         self.assertEquals(rep.u.reserved, 0)
1674         self.assertEquals(len(rep.u.error_and_verifier), 0)
1675
1676         # wait for a disconnect
1677         rep = self.recv_pdu()
1678         self.assertIsNone(rep)
1679         self.assertNotConnected()
1680
1681     def test_auth_none_none_request(self):
1682         return self._test_auth_none_level_request(dcerpc.DCERPC_AUTH_LEVEL_NONE)
1683
1684     def test_auth_none_connect_request(self):
1685         return self._test_auth_none_level_request(dcerpc.DCERPC_AUTH_LEVEL_CONNECT)
1686
1687     def test_auth_none_call_request(self):
1688         return self._test_auth_none_level_request(dcerpc.DCERPC_AUTH_LEVEL_CALL)
1689
1690     def _test_neg_xmit_check_values(self,
1691                                     req_xmit=None,
1692                                     req_recv=None,
1693                                     rep_both=None,
1694                                     alter_xmit=None,
1695                                     alter_recv=None):
1696         ndr32 = base.transfer_syntax_ndr()
1697
1698         tsf1_list = [ndr32]
1699         ctx1 = dcerpc.ctx_list()
1700         ctx1.context_id = 1
1701         ctx1.num_transfer_syntaxes = len(tsf1_list)
1702         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
1703         ctx1.transfer_syntaxes = tsf1_list
1704
1705         req = self.generate_bind(call_id=0,
1706                                  max_xmit_frag=req_xmit,
1707                                  max_recv_frag=req_recv,
1708                                  ctx_list=[ctx1])
1709         self.send_pdu(req)
1710         rep = self.recv_pdu()
1711         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
1712                         auth_length=0)
1713         self.assertEquals(rep.u.max_xmit_frag, rep_both)
1714         self.assertEquals(rep.u.max_recv_frag, rep_both)
1715         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1716         self.assertEquals(rep.u.secondary_address_size, 4)
1717         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
1718         self.assertEquals(len(rep.u._pad1), 2)
1719         self.assertEquals(rep.u._pad1, b'\0' * 2)
1720         self.assertEquals(rep.u.num_results, 1)
1721         self.assertEquals(rep.u.ctx_list[0].result,
1722                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
1723         self.assertEquals(rep.u.ctx_list[0].reason,
1724                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
1725         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
1726         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1727
1728         assoc_group_id = rep.u.assoc_group_id
1729         if alter_xmit is None:
1730             alter_xmit = rep_both - 8
1731         if alter_recv is None:
1732             alter_recv = rep_both - 8
1733
1734         # max_{xmit,recv}_frag and assoc_group_id are completely
1735         # ignored in alter_context requests
1736         req = self.generate_alter(call_id=1,
1737                                   max_xmit_frag=alter_xmit,
1738                                   max_recv_frag=alter_recv,
1739                                   assoc_group_id=0xffffffff - rep.u.assoc_group_id,
1740                                   ctx_list=[ctx1])
1741         self.send_pdu(req)
1742         rep = self.recv_pdu()
1743         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
1744                         auth_length=0)
1745         self.assertEquals(rep.u.max_xmit_frag, rep_both)
1746         self.assertEquals(rep.u.max_recv_frag, rep_both)
1747         self.assertEquals(rep.u.assoc_group_id, rep.u.assoc_group_id)
1748         self.assertEquals(rep.u.secondary_address_size, 0)
1749         self.assertEquals(len(rep.u._pad1), 2)
1750         #self.assertEquals(rep.u._pad1, '\0' * 2)
1751         self.assertEquals(rep.u.num_results, 1)
1752         self.assertEquals(rep.u.ctx_list[0].result,
1753                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
1754         self.assertEquals(rep.u.ctx_list[0].reason,
1755                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
1756         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
1757         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1758
1759         chunk_size = rep_both - dcerpc.DCERPC_REQUEST_LENGTH
1760         req = self.generate_request(call_id=2,
1761                                     context_id=ctx1.context_id,
1762                                     opnum=0,
1763                                     alloc_hint=0xffffffff,
1764                                     stub=b"\00" * chunk_size)
1765         self.send_pdu(req, ndr_print=True, hexdump=True)
1766         rep = self.recv_pdu(ndr_print=True, hexdump=True)
1767         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1768                         auth_length=0)
1769         self.assertNotEquals(rep.u.alloc_hint, 0)
1770         self.assertEquals(rep.u.context_id, req.u.context_id)
1771         self.assertEquals(rep.u.cancel_count, 0)
1772         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1773
1774         chunk_size = 5840 - dcerpc.DCERPC_REQUEST_LENGTH
1775         req = self.generate_request(call_id=2,
1776                                     context_id=ctx1.context_id,
1777                                     opnum=0,
1778                                     alloc_hint=0xffffffff,
1779                                     stub=b"\00" * chunk_size)
1780         self.send_pdu(req)
1781         rep = self.recv_pdu()
1782         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1783                         auth_length=0)
1784         self.assertNotEquals(rep.u.alloc_hint, 0)
1785         self.assertEquals(rep.u.context_id, req.u.context_id)
1786         self.assertEquals(rep.u.cancel_count, 0)
1787         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1788
1789         chunk_size += 1
1790         req = self.generate_request(call_id=3,
1791                                     context_id=ctx1.context_id,
1792                                     opnum=0,
1793                                     alloc_hint=0xffffffff,
1794                                     stub=b"\00" * chunk_size)
1795         self.send_pdu(req)
1796         rep = self.recv_pdu()
1797         # We get a fault
1798         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
1799                         auth_length=0)
1800         self.assertNotEquals(rep.u.alloc_hint, 0)
1801         self.assertEquals(rep.u.context_id, 0)
1802         self.assertEquals(rep.u.cancel_count, 0)
1803         self.assertEquals(rep.u.flags, 0)
1804         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
1805         self.assertEquals(rep.u.reserved, 0)
1806         self.assertEquals(len(rep.u.error_and_verifier), 0)
1807
1808         # wait for a disconnect
1809         rep = self.recv_pdu()
1810         self.assertIsNone(rep)
1811         self.assertNotConnected()
1812
1813     def test_neg_xmit_ffff_ffff(self):
1814         return self._test_neg_xmit_check_values(req_xmit=0xffff,
1815                                                 req_recv=0xffff,
1816                                                 rep_both=5840)
1817
1818     def test_neg_xmit_0_ffff(self):
1819         return self._test_neg_xmit_check_values(req_xmit=0,
1820                                                 req_recv=0xffff,
1821                                                 rep_both=2048,
1822                                                 alter_xmit=0xffff,
1823                                                 alter_recv=0xffff)
1824
1825     def test_neg_xmit_ffff_0(self):
1826         return self._test_neg_xmit_check_values(req_xmit=0xffff,
1827                                                 req_recv=0,
1828                                                 rep_both=2048)
1829
1830     def test_neg_xmit_0_0(self):
1831         return self._test_neg_xmit_check_values(req_xmit=0,
1832                                                 req_recv=0,
1833                                                 rep_both=2048,
1834                                                 alter_xmit=0xffff,
1835                                                 alter_recv=0xffff)
1836
1837     def test_neg_xmit_3199_0(self):
1838         return self._test_neg_xmit_check_values(req_xmit=3199,
1839                                                 req_recv=0,
1840                                                 rep_both=2048)
1841
1842     def test_neg_xmit_0_3199(self):
1843         return self._test_neg_xmit_check_values(req_xmit=0,
1844                                                 req_recv=3199,
1845                                                 rep_both=2048)
1846
1847     def test_neg_xmit_3199_ffff(self):
1848         return self._test_neg_xmit_check_values(req_xmit=3199,
1849                                                 req_recv=0xffff,
1850                                                 rep_both=3192)
1851
1852     def test_neg_xmit_ffff_3199(self):
1853         return self._test_neg_xmit_check_values(req_xmit=0xffff,
1854                                                 req_recv=3199,
1855                                                 rep_both=3192)
1856
1857     def test_alloc_hint(self):
1858         ndr32 = base.transfer_syntax_ndr()
1859
1860         tsf1_list = [ndr32]
1861         ctx = dcerpc.ctx_list()
1862         ctx.context_id = 0
1863         ctx.num_transfer_syntaxes = len(tsf1_list)
1864         ctx.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
1865         ctx.transfer_syntaxes = tsf1_list
1866
1867         req = self.generate_bind(call_id=0,
1868                                  ctx_list=[ctx])
1869         self.send_pdu(req)
1870         rep = self.recv_pdu()
1871         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
1872                         auth_length=0)
1873         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
1874         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
1875         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
1876         self.assertEquals(rep.u.secondary_address_size, 4)
1877         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
1878         self.assertEquals(len(rep.u._pad1), 2)
1879         self.assertEquals(rep.u._pad1, b'\0' * 2)
1880         self.assertEquals(rep.u.num_results, 1)
1881         self.assertEquals(rep.u.ctx_list[0].result,
1882                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
1883         self.assertEquals(rep.u.ctx_list[0].reason,
1884                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
1885         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
1886         self.assertEquals(rep.u.auth_info, b'\0' * 0)
1887
1888         # And now try a request without auth_info
1889         req = self.generate_request(call_id=2,
1890                                     context_id=ctx.context_id,
1891                                     opnum=0,
1892                                     alloc_hint=0xffffffff,
1893                                     stub=b"")
1894         self.send_pdu(req)
1895         rep = self.recv_pdu()
1896         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1897                         auth_length=0)
1898         self.assertNotEquals(rep.u.alloc_hint, 0)
1899         self.assertEquals(rep.u.context_id, req.u.context_id)
1900         self.assertEquals(rep.u.cancel_count, 0)
1901         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1902
1903         req = self.generate_request(call_id=3,
1904                                     context_id=ctx.context_id,
1905                                     opnum=1,
1906                                     alloc_hint=0xffffffff,
1907                                     stub=b"\04\00\00\00\00\00\00\00")
1908         self.send_pdu(req)
1909         rep = self.recv_pdu()
1910         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1911                         auth_length=0)
1912         self.assertNotEquals(rep.u.alloc_hint, 0)
1913         self.assertEquals(rep.u.context_id, req.u.context_id)
1914         self.assertEquals(rep.u.cancel_count, 0)
1915         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1916
1917         req = self.generate_request(call_id=4,
1918                                     context_id=ctx.context_id,
1919                                     opnum=1,
1920                                     alloc_hint=1,
1921                                     stub=b"\04\00\00\00\00\00\00\00")
1922         self.send_pdu(req)
1923         rep = self.recv_pdu()
1924         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
1925                         auth_length=0)
1926         self.assertNotEquals(rep.u.alloc_hint, 0)
1927         self.assertEquals(rep.u.context_id, req.u.context_id)
1928         self.assertEquals(rep.u.cancel_count, 0)
1929         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
1930
1931     def _get_netlogon_ctx(self):
1932         abstract = samba.dcerpc.netlogon.abstract_syntax()
1933         ndr32 = base.transfer_syntax_ndr()
1934
1935         (ctx, ack) = self.prepare_presentation(abstract, ndr32, context_id=0,
1936                                                epmap=True, return_ack=True)
1937
1938         server = '\\\\' + self.target_hostname
1939         if isinstance(server, binary_type):
1940             server_utf16 = server.decode('utf-8').encode('utf-16-le')
1941         else:
1942             server_utf16 = server.encode('utf-16-le')
1943         computer = 'UNKNOWNCOMPUTER'
1944         if isinstance(server, binary_type):
1945             computer_utf16 = computer.decode('utf-8').encode('utf-16-le')
1946         else:
1947             computer_utf16 = computer.encode('utf-16-le')
1948
1949         real_stub = struct.pack('<IIII', 0x00200000,
1950                                 len(server) + 1, 0, len(server) + 1)
1951         real_stub += server_utf16 + b'\x00\x00'
1952         mod_len = len(real_stub) % 4
1953         if mod_len != 0:
1954             real_stub += b'\x00' * (4 - mod_len)
1955         real_stub += struct.pack('<III',
1956                                  len(computer) + 1, 0, len(computer) + 1)
1957         real_stub += computer_utf16 + b'\x00\x00'
1958         real_stub += b'\x11\x22\x33\x44\x55\x66\x77\x88'
1959
1960         return (ctx, ack, real_stub)
1961
1962     def _test_fragmented_requests(self, remaining=None, alloc_hint=None,
1963                                   fault_first=None, fault_last=None):
1964         (ctx, rep, real_stub) = self._get_netlogon_ctx()
1965
1966         chunk = rep.u.max_recv_frag - dcerpc.DCERPC_REQUEST_LENGTH
1967
1968         total = 0
1969         first = True
1970         while remaining > 0:
1971             thistime = min(remaining, chunk)
1972             remaining -= thistime
1973             total += thistime
1974
1975             pfc_flags = 0
1976             if first:
1977                 pfc_flags |= dcerpc.DCERPC_PFC_FLAG_FIRST
1978                 first = False
1979                 stub = real_stub + b'\x00' * (thistime - len(real_stub))
1980             else:
1981                 stub = b"\x00" * thistime
1982
1983             if remaining == 0:
1984                 pfc_flags |= dcerpc.DCERPC_PFC_FLAG_LAST
1985
1986             # And now try a request without auth_info
1987             # netr_ServerReqChallenge()
1988             req = self.generate_request(call_id=0x21234,
1989                                         pfc_flags=pfc_flags,
1990                                         context_id=ctx.context_id,
1991                                         opnum=4,
1992                                         alloc_hint=alloc_hint,
1993                                         stub=stub)
1994             if alloc_hint >= thistime:
1995                 alloc_hint -= thistime
1996             else:
1997                 alloc_hint = 0
1998             self.send_pdu(req, hexdump=False)
1999             if fault_first is not None:
2000                 rep = self.recv_pdu()
2001                 # We get a fault back
2002                 self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
2003                                 auth_length=0)
2004                 self.assertNotEquals(rep.u.alloc_hint, 0)
2005                 self.assertEquals(rep.u.context_id, req.u.context_id)
2006                 self.assertEquals(rep.u.cancel_count, 0)
2007                 self.assertEquals(rep.u.flags, 0)
2008                 self.assertEquals(rep.u.status, fault_first)
2009                 self.assertEquals(rep.u.reserved, 0)
2010                 self.assertEquals(len(rep.u.error_and_verifier), 0)
2011
2012                 # wait for a disconnect
2013                 rep = self.recv_pdu()
2014                 self.assertIsNone(rep)
2015                 self.assertNotConnected()
2016                 return
2017             if remaining == 0:
2018                 break
2019             if total >= 0x400000 and fault_last is not None:
2020                 rep = self.recv_pdu()
2021                 # We get a fault back
2022                 self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
2023                                 auth_length=0)
2024                 self.assertNotEquals(rep.u.alloc_hint, 0)
2025                 self.assertEquals(rep.u.context_id, req.u.context_id)
2026                 self.assertEquals(rep.u.cancel_count, 0)
2027                 self.assertEquals(rep.u.flags, 0)
2028                 self.assertEquals(rep.u.status, fault_last)
2029                 self.assertEquals(rep.u.reserved, 0)
2030                 self.assertEquals(len(rep.u.error_and_verifier), 0)
2031
2032                 # wait for a disconnect
2033                 rep = self.recv_pdu()
2034                 self.assertIsNone(rep)
2035                 self.assertNotConnected()
2036                 return
2037             rep = self.recv_pdu(timeout=0.01)
2038             self.assertIsNone(rep)
2039             self.assertIsConnected()
2040
2041         if total >= 0x400000 and fault_last is not None:
2042             rep = self.recv_pdu()
2043             # We get a fault back
2044             self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
2045                             auth_length=0)
2046             self.assertNotEquals(rep.u.alloc_hint, 0)
2047             self.assertEquals(rep.u.context_id, req.u.context_id)
2048             self.assertEquals(rep.u.cancel_count, 0)
2049             self.assertEquals(rep.u.flags, 0)
2050             self.assertEquals(rep.u.status, fault_last)
2051             self.assertEquals(rep.u.reserved, 0)
2052             self.assertEquals(len(rep.u.error_and_verifier), 0)
2053
2054             # wait for a disconnect
2055             rep = self.recv_pdu()
2056             self.assertIsNone(rep)
2057             self.assertNotConnected()
2058             return
2059         rep = self.recv_pdu()
2060         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2061                         auth_length=0)
2062         self.assertNotEquals(rep.u.alloc_hint, 0)
2063         self.assertEquals(rep.u.context_id, req.u.context_id)
2064         self.assertEquals(rep.u.cancel_count, 0)
2065         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2066
2067         self.assertEquals(len(rep.u.stub_and_verifier), 12)
2068         status = struct.unpack_from("<I", rep.u.stub_and_verifier, len(rep.u.stub_and_verifier) - 4)
2069         self.assertEquals(status[0], 0)
2070
2071     def test_fragmented_requests01(self):
2072         return self._test_fragmented_requests(remaining=0x400000,
2073                                               alloc_hint=0x400000)
2074
2075     def test_fragmented_requests02(self):
2076         return self._test_fragmented_requests(remaining=0x400000,
2077                                               alloc_hint=0x100000)
2078
2079     def test_fragmented_requests03(self):
2080         return self._test_fragmented_requests(remaining=0x400000,
2081                                               alloc_hint=0)
2082
2083     def test_fragmented_requests04(self):
2084         return self._test_fragmented_requests(remaining=0x400000,
2085                                               alloc_hint=0x400001,
2086                                               fault_first=dcerpc.DCERPC_FAULT_ACCESS_DENIED)
2087
2088     def test_fragmented_requests05(self):
2089         return self._test_fragmented_requests(remaining=0x500001,
2090                                               alloc_hint=0,
2091                                               fault_last=dcerpc.DCERPC_FAULT_ACCESS_DENIED)
2092
2093     def _test_same_requests(self, pfc_flags, fault_1st=False, fault_2nd=False):
2094         (ctx, rep, real_stub) = self._get_netlogon_ctx()
2095
2096         # netr_ServerReqChallenge with given flags
2097         req = self.generate_request(call_id=2,
2098                                     pfc_flags=pfc_flags,
2099                                     context_id=ctx.context_id,
2100                                     opnum=4,
2101                                     stub=real_stub)
2102         self.send_pdu(req)
2103         if fault_1st:
2104             rep = self.recv_pdu()
2105             # We get a fault back
2106             self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
2107                             auth_length=0)
2108             self.assertNotEquals(rep.u.alloc_hint, 0)
2109             self.assertEquals(rep.u.context_id, 0)
2110             self.assertEquals(rep.u.cancel_count, 0)
2111             self.assertEquals(rep.u.flags, 0)
2112             self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
2113             self.assertEquals(rep.u.reserved, 0)
2114             self.assertEquals(len(rep.u.error_and_verifier), 0)
2115
2116             # wait for a disconnect
2117             rep = self.recv_pdu()
2118             self.assertIsNone(rep)
2119             self.assertNotConnected()
2120             return
2121         rep = self.recv_pdu(timeout=0.1)
2122         self.assertIsNone(rep)
2123         self.assertIsConnected()
2124
2125         # netr_ServerReqChallenge without DCERPC_PFC_FLAG_LAST
2126         # with the same call_id
2127         req = self.generate_request(call_id=2,
2128                                     pfc_flags=pfc_flags,
2129                                     context_id=ctx.context_id,
2130                                     opnum=4,
2131                                     stub=real_stub)
2132         self.send_pdu(req)
2133         if fault_2nd:
2134             rep = self.recv_pdu()
2135             # We get a fault back
2136             self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
2137                             auth_length=0)
2138             self.assertNotEquals(rep.u.alloc_hint, 0)
2139             self.assertEquals(rep.u.context_id, req.u.context_id)
2140             self.assertEquals(rep.u.cancel_count, 0)
2141             self.assertEquals(rep.u.flags, 0)
2142             self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
2143             self.assertEquals(rep.u.reserved, 0)
2144             self.assertEquals(len(rep.u.error_and_verifier), 0)
2145
2146             # wait for a disconnect
2147             rep = self.recv_pdu()
2148             self.assertIsNone(rep)
2149             self.assertNotConnected()
2150             return
2151
2152         rep = self.recv_pdu(timeout=0.1)
2153         self.assertIsNone(rep)
2154         self.assertIsConnected()
2155
2156     def test_first_only_requests(self):
2157         return self._test_same_requests(pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
2158                                         fault_2nd=True)
2159
2160     def test_none_only_requests(self):
2161         return self._test_same_requests(pfc_flags=0, fault_1st=True)
2162
2163     def test_last_only_requests(self):
2164         return self._test_same_requests(pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST,
2165                                         fault_1st=True)
2166
2167     def test_first_maybe_requests(self):
2168         return self._test_same_requests(pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST |
2169                                         dcerpc.DCERPC_PFC_FLAG_MAYBE,
2170                                         fault_2nd=True)
2171
2172     def test_first_didnot_requests(self):
2173         return self._test_same_requests(pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST |
2174                                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
2175                                         fault_2nd=True)
2176
2177     def test_first_cmpx_requests(self):
2178         return self._test_same_requests(pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST |
2179                                         dcerpc.DCERPC_PFC_FLAG_CONC_MPX,
2180                                         fault_2nd=True)
2181
2182     def test_first_08_requests(self):
2183         return self._test_same_requests(pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST |
2184                                         0x08,
2185                                         fault_2nd=True)
2186
2187     def test_first_cancel_requests(self):
2188         (ctx, rep, real_stub) = self._get_netlogon_ctx()
2189
2190         # netr_ServerReqChallenge with given flags
2191         req = self.generate_request(call_id=2,
2192                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST |
2193                                     dcerpc.DCERPC_PFC_FLAG_PENDING_CANCEL,
2194                                     context_id=ctx.context_id,
2195                                     opnum=4,
2196                                     stub=real_stub)
2197         self.send_pdu(req)
2198         rep = self.recv_pdu()
2199         # We get a fault back
2200         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
2201                         pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST |
2202                         dcerpc.DCERPC_PFC_FLAG_LAST |
2203                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
2204                         auth_length=0)
2205         self.assertNotEquals(rep.u.alloc_hint, 0)
2206         self.assertEquals(rep.u.context_id, 0)
2207         self.assertEquals(rep.u.cancel_count, 0)
2208         self.assertEquals(rep.u.flags, 0)
2209         self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_NO_CALL_ACTIVE)
2210         self.assertEquals(rep.u.reserved, 0)
2211         self.assertEquals(len(rep.u.error_and_verifier), 0)
2212
2213         # wait for a disconnect
2214         rep = self.recv_pdu()
2215         self.assertIsNone(rep)
2216         self.assertNotConnected()
2217
2218     def test_2nd_cancel_requests(self):
2219         (ctx, rep, real_stub) = self._get_netlogon_ctx()
2220
2221         # netr_ServerReqChallenge with given flags
2222         req = self.generate_request(call_id=2,
2223                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
2224                                     context_id=ctx.context_id,
2225                                     opnum=4,
2226                                     stub=real_stub)
2227         self.send_pdu(req)
2228         rep = self.recv_pdu(timeout=0.1)
2229         self.assertIsNone(rep)
2230         self.assertIsConnected()
2231
2232         # netr_ServerReqChallenge with given flags
2233         req = self.generate_request(call_id=2,
2234                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_PENDING_CANCEL,
2235                                     context_id=ctx.context_id,
2236                                     opnum=4,
2237                                     stub=real_stub)
2238         self.send_pdu(req)
2239         rep = self.recv_pdu(timeout=0.1)
2240         self.assertIsNone(rep)
2241         self.assertIsConnected()
2242
2243         # netr_ServerReqChallenge with given flags
2244         req = self.generate_request(call_id=2,
2245                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST,
2246                                     context_id=ctx.context_id,
2247                                     opnum=4,
2248                                     stub=real_stub)
2249         self.send_pdu(req)
2250         rep = self.recv_pdu()
2251         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2252                         auth_length=0)
2253         self.assertNotEquals(rep.u.alloc_hint, 0)
2254         self.assertEquals(rep.u.context_id, req.u.context_id)
2255         self.assertEquals(rep.u.cancel_count, 0)
2256         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2257
2258         self.assertEquals(len(rep.u.stub_and_verifier), 12)
2259         status = struct.unpack_from("<I", rep.u.stub_and_verifier, len(rep.u.stub_and_verifier) - 4)
2260         self.assertEquals(status[0], 0)
2261
2262     def test_last_cancel_requests(self):
2263         (ctx, rep, real_stub) = self._get_netlogon_ctx()
2264
2265         # netr_ServerReqChallenge with given flags
2266         req = self.generate_request(call_id=2,
2267                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
2268                                     context_id=ctx.context_id,
2269                                     opnum=4,
2270                                     stub=real_stub[:4])
2271         self.send_pdu(req)
2272         rep = self.recv_pdu(timeout=0.1)
2273         self.assertIsNone(rep)
2274         self.assertIsConnected()
2275
2276         # netr_ServerReqChallenge with given flags
2277         req = self.generate_request(call_id=2,
2278                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST |
2279                                     dcerpc.DCERPC_PFC_FLAG_PENDING_CANCEL,
2280                                     context_id=ctx.context_id,
2281                                     opnum=4,
2282                                     stub=real_stub[4:])
2283         self.send_pdu(req)
2284         rep = self.recv_pdu()
2285         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2286                         auth_length=0)
2287         self.assertNotEquals(rep.u.alloc_hint, 0)
2288         self.assertEquals(rep.u.context_id, req.u.context_id)
2289         self.assertEquals(rep.u.cancel_count, 0)
2290         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2291
2292         self.assertEquals(len(rep.u.stub_and_verifier), 12)
2293         status = struct.unpack_from("<I", rep.u.stub_and_verifier, len(rep.u.stub_and_verifier) - 4)
2294         self.assertEquals(status[0], 0)
2295
2296     def test_mix_requests(self):
2297         (ctx, rep, real_stub) = self._get_netlogon_ctx()
2298
2299         # netr_ServerReqChallenge with given flags
2300         req = self.generate_request(call_id=50,
2301                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
2302                                     context_id=ctx.context_id,
2303                                     opnum=4,
2304                                     stub=real_stub)
2305         self.send_pdu(req)
2306         rep = self.recv_pdu(timeout=0.1)
2307         self.assertIsNone(rep)
2308         self.assertIsConnected()
2309
2310         # netr_ServerReqChallenge with given flags
2311         req = self.generate_request(call_id=51,
2312                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
2313                                     context_id=ctx.context_id,
2314                                     opnum=4,
2315                                     stub=real_stub)
2316         self.send_pdu(req)
2317         rep = self.recv_pdu()
2318         # We get a fault back
2319         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, 50,
2320                         pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST |
2321                         dcerpc.DCERPC_PFC_FLAG_LAST,
2322                         auth_length=0)
2323         self.assertNotEquals(rep.u.alloc_hint, 0)
2324         self.assertEquals(rep.u.context_id, req.u.context_id)
2325         self.assertEquals(rep.u.cancel_count, 0)
2326         self.assertEquals(rep.u.flags, 0)
2327         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
2328         self.assertEquals(rep.u.reserved, 0)
2329         self.assertEquals(len(rep.u.error_and_verifier), 0)
2330
2331     def test_co_cancel_no_request(self):
2332         ndr32 = base.transfer_syntax_ndr()
2333         abstract = samba.dcerpc.mgmt.abstract_syntax()
2334         ctx = self.prepare_presentation(abstract, ndr32, context_id=0xff)
2335
2336         req = self.generate_co_cancel(call_id=3)
2337         self.send_pdu(req)
2338         rep = self.recv_pdu(timeout=0.01)
2339         self.assertIsNone(rep)
2340         self.assertIsConnected()
2341
2342         # And now try a request
2343         req = self.generate_request(call_id=1,
2344                                     context_id=ctx.context_id,
2345                                     opnum=0,
2346                                     stub=b"")
2347         self.send_pdu(req)
2348         rep = self.recv_pdu()
2349         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2350                         auth_length=0)
2351         self.assertNotEquals(rep.u.alloc_hint, 0)
2352         self.assertEquals(rep.u.context_id, req.u.context_id)
2353         self.assertEquals(rep.u.cancel_count, 0)
2354         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2355
2356     def test_co_cancel_request_after_first(self):
2357         ndr32 = base.transfer_syntax_ndr()
2358         abstract = samba.dcerpc.mgmt.abstract_syntax()
2359         ctx = self.prepare_presentation(abstract, ndr32, context_id=0xff)
2360
2361         req = self.generate_request(call_id=1,
2362                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
2363                                     context_id=ctx.context_id,
2364                                     opnum=0,
2365                                     stub=b"")
2366         self.send_pdu(req)
2367         rep = self.recv_pdu(timeout=0.01)
2368         self.assertIsNone(rep)
2369         self.assertIsConnected()
2370
2371         req = self.generate_co_cancel(call_id=1)
2372         self.send_pdu(req)
2373         rep = self.recv_pdu(timeout=0.01)
2374         self.assertIsNone(rep)
2375         self.assertIsConnected()
2376
2377         req = self.generate_request(call_id=1,
2378                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST,
2379                                     context_id=ctx.context_id,
2380                                     opnum=0,
2381                                     stub=b"")
2382         self.send_pdu(req)
2383         rep = self.recv_pdu()
2384         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2385                         auth_length=0)
2386         self.assertNotEquals(rep.u.alloc_hint, 0)
2387         self.assertEquals(rep.u.context_id, req.u.context_id)
2388         self.assertEquals(rep.u.cancel_count, 0)
2389         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2390
2391         # And now try a request
2392         req = self.generate_request(call_id=2,
2393                                     context_id=ctx.context_id,
2394                                     opnum=0,
2395                                     stub=b"")
2396         self.send_pdu(req)
2397         rep = self.recv_pdu()
2398         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2399                         auth_length=0)
2400         self.assertNotEquals(rep.u.alloc_hint, 0)
2401         self.assertEquals(rep.u.context_id, req.u.context_id)
2402         self.assertEquals(rep.u.cancel_count, 0)
2403         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2404
2405     def test_orphaned_no_request(self):
2406         ndr32 = base.transfer_syntax_ndr()
2407         abstract = samba.dcerpc.mgmt.abstract_syntax()
2408         ctx = self.prepare_presentation(abstract, ndr32)
2409
2410         req = self.generate_orphaned(call_id=3)
2411         self.send_pdu(req)
2412         rep = self.recv_pdu(timeout=0.01)
2413         self.assertIsNone(rep)
2414         self.assertIsConnected()
2415
2416         # And now try a request
2417         req = self.generate_request(call_id=1,
2418                                     context_id=ctx.context_id,
2419                                     opnum=0,
2420                                     stub=b"")
2421         self.send_pdu(req)
2422         rep = self.recv_pdu()
2423         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2424                         auth_length=0)
2425         self.assertNotEquals(rep.u.alloc_hint, 0)
2426         self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
2427         self.assertEquals(rep.u.cancel_count, 0)
2428         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2429
2430     def test_orphaned_request_after_first_last(self):
2431         ndr32 = base.transfer_syntax_ndr()
2432         abstract = samba.dcerpc.mgmt.abstract_syntax()
2433         ctx = self.prepare_presentation(abstract, ndr32)
2434
2435         req = self.generate_request(call_id=1,
2436                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
2437                                     context_id=ctx.context_id,
2438                                     opnum=0,
2439                                     stub=b"")
2440         self.send_pdu(req)
2441         rep = self.recv_pdu(timeout=0.1)
2442         self.assertIsNone(rep)
2443         self.assertIsConnected()
2444
2445         req = self.generate_orphaned(call_id=1)
2446         self.send_pdu(req)
2447         rep = self.recv_pdu(timeout=0.1)
2448         self.assertIsNone(rep)
2449         self.assertIsConnected()
2450
2451         req = self.generate_request(call_id=1,
2452                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST,
2453                                     context_id=ctx.context_id,
2454                                     opnum=0,
2455                                     stub=b"")
2456         self.send_pdu(req)
2457         rep = self.recv_pdu()
2458         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2459                         auth_length=0)
2460         self.assertNotEquals(rep.u.alloc_hint, 0)
2461         self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
2462         self.assertEquals(rep.u.cancel_count, 0)
2463         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2464
2465         # And now try a request
2466         req = self.generate_request(call_id=2,
2467                                     context_id=ctx.context_id,
2468                                     opnum=0,
2469                                     stub=b"")
2470         self.send_pdu(req)
2471         rep = self.recv_pdu()
2472         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2473                         auth_length=0)
2474         self.assertNotEquals(rep.u.alloc_hint, 0)
2475         self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
2476         self.assertEquals(rep.u.cancel_count, 0)
2477         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2478
2479     def test_orphaned_request_after_first_mpx_last(self):
2480         ndr32 = base.transfer_syntax_ndr()
2481         abstract = samba.dcerpc.mgmt.abstract_syntax()
2482
2483         pfc_flags = samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_FIRST
2484         pfc_flags |= samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_LAST
2485         pfc_flags |= samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_CONC_MPX
2486         ctx = self.prepare_presentation(abstract, ndr32, pfc_flags=pfc_flags)
2487
2488         req = self.generate_request(call_id=1,
2489                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
2490                                     context_id=ctx.context_id,
2491                                     opnum=0,
2492                                     stub=b"")
2493         self.send_pdu(req)
2494         rep = self.recv_pdu(timeout=0.1)
2495         self.assertIsNone(rep)
2496         self.assertIsConnected()
2497
2498         req = self.generate_orphaned(call_id=1)
2499         self.send_pdu(req)
2500         rep = self.recv_pdu(timeout=0.1)
2501         self.assertIsNone(rep)
2502         self.assertIsConnected()
2503
2504         req = self.generate_request(call_id=1,
2505                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST,
2506                                     context_id=ctx.context_id,
2507                                     opnum=0,
2508                                     stub=b"")
2509         self.send_pdu(req)
2510         rep = self.recv_pdu()
2511         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2512                         auth_length=0)
2513         self.assertNotEquals(rep.u.alloc_hint, 0)
2514         self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
2515         self.assertEquals(rep.u.cancel_count, 0)
2516         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2517
2518         # And now try a request
2519         req = self.generate_request(call_id=2,
2520                                     context_id=ctx.context_id,
2521                                     opnum=0,
2522                                     stub=b"")
2523         self.send_pdu(req)
2524         rep = self.recv_pdu()
2525         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2526                         auth_length=0)
2527         self.assertNotEquals(rep.u.alloc_hint, 0)
2528         self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
2529         self.assertEquals(rep.u.cancel_count, 0)
2530         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2531
2532     def test_orphaned_request_after_first_no_last(self):
2533         ndr32 = base.transfer_syntax_ndr()
2534         abstract = samba.dcerpc.mgmt.abstract_syntax()
2535         ctx = self.prepare_presentation(abstract, ndr32)
2536
2537         req1 = self.generate_request(call_id=1,
2538                                      pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
2539                                      context_id=ctx.context_id,
2540                                      opnum=0,
2541                                      stub=b"")
2542         self.send_pdu(req1)
2543         rep = self.recv_pdu(timeout=0.1)
2544         self.assertIsNone(rep)
2545         self.assertIsConnected()
2546
2547         req = self.generate_orphaned(call_id=1)
2548         self.send_pdu(req)
2549         rep = self.recv_pdu(timeout=0.1)
2550         self.assertIsNone(rep)
2551         self.assertIsConnected()
2552
2553         # And now try a new request
2554         req2 = self.generate_request(call_id=2,
2555                                      context_id=ctx.context_id,
2556                                      opnum=0,
2557                                      stub=b"")
2558         self.send_pdu(req2)
2559         rep = self.recv_pdu()
2560         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req1.call_id,
2561                         auth_length=0)
2562         self.assertNotEquals(rep.u.alloc_hint, 0)
2563         self.assertEquals(rep.u.context_id, req1.u.context_id)
2564         self.assertEquals(rep.u.cancel_count, 0)
2565         self.assertEquals(rep.u.flags, 0)
2566         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
2567         self.assertEquals(rep.u.reserved, 0)
2568         self.assertEquals(len(rep.u.error_and_verifier), 0)
2569
2570         # wait for a disconnect
2571         rep = self.recv_pdu()
2572         self.assertIsNone(rep)
2573         self.assertNotConnected()
2574
2575     def test_orphaned_request_after_first_mpx_no_last(self):
2576         ndr32 = base.transfer_syntax_ndr()
2577         abstract = samba.dcerpc.mgmt.abstract_syntax()
2578
2579         pfc_flags = samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_FIRST
2580         pfc_flags |= samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_LAST
2581         pfc_flags |= samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_CONC_MPX
2582         ctx = self.prepare_presentation(abstract, ndr32,
2583                                         pfc_flags=pfc_flags)
2584
2585         req1 = self.generate_request(call_id=1,
2586                                      pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
2587                                      context_id=ctx.context_id,
2588                                      opnum=0,
2589                                      stub=b"")
2590         self.send_pdu(req1)
2591         rep = self.recv_pdu(timeout=0.1)
2592         self.assertIsNone(rep)
2593         self.assertIsConnected()
2594
2595         req = self.generate_orphaned(call_id=1)
2596         self.send_pdu(req)
2597         rep = self.recv_pdu(timeout=0.1)
2598         self.assertIsNone(rep)
2599         self.assertIsConnected()
2600
2601         # And now try a new request
2602         req2 = self.generate_request(call_id=2,
2603                                      context_id=ctx.context_id - 1,
2604                                      opnum=0,
2605                                      stub=b"")
2606         self.send_pdu(req2)
2607         rep = self.recv_pdu()
2608         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req2.call_id,
2609                         auth_length=0)
2610         self.assertNotEquals(rep.u.alloc_hint, 0)
2611         self.assertEquals(rep.u.context_id, 0)
2612         self.assertEquals(rep.u.cancel_count, 0)
2613         self.assertEquals(rep.u.flags, 0)
2614         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
2615         self.assertEquals(rep.u.reserved, 0)
2616         self.assertEquals(len(rep.u.error_and_verifier), 0)
2617
2618         # wait for a disconnect
2619         rep = self.recv_pdu()
2620         self.assertIsNone(rep)
2621         self.assertNotConnected()
2622
2623     def test_spnego_connect_request(self):
2624         ndr32 = base.transfer_syntax_ndr()
2625
2626         tsf1_list = [ndr32]
2627         ctx1 = dcerpc.ctx_list()
2628         ctx1.context_id = 1
2629         ctx1.num_transfer_syntaxes = len(tsf1_list)
2630         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
2631         ctx1.transfer_syntaxes = tsf1_list
2632         ctx_list = [ctx1]
2633
2634         c = self.get_anon_creds()
2635         g = gensec.Security.start_client(self.settings)
2636         g.set_credentials(c)
2637         g.want_feature(gensec.FEATURE_DCE_STYLE)
2638         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
2639         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
2640         auth_context_id = 2
2641         g.start_mech_by_authtype(auth_type, auth_level)
2642         from_server = b""
2643         (finished, to_server) = g.update(from_server)
2644         self.assertFalse(finished)
2645
2646         auth_info = self.generate_auth(auth_type=auth_type,
2647                                        auth_level=auth_level,
2648                                        auth_context_id=auth_context_id,
2649                                        auth_blob=to_server)
2650
2651         req = self.generate_bind(call_id=0,
2652                                  ctx_list=ctx_list,
2653                                  auth_info=auth_info)
2654
2655         self.send_pdu(req)
2656         rep = self.recv_pdu()
2657         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
2658         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
2659         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
2660         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
2661         self.assertEquals(rep.u.secondary_address_size, 4)
2662         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
2663         self.assertEquals(len(rep.u._pad1), 2)
2664         self.assertEquals(rep.u._pad1, b'\0' * 2)
2665         self.assertEquals(rep.u.num_results, 1)
2666         self.assertEquals(rep.u.ctx_list[0].result,
2667                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
2668         self.assertEquals(rep.u.ctx_list[0].reason,
2669                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
2670         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
2671         self.assertNotEquals(len(rep.u.auth_info), 0)
2672         a = self.parse_auth(rep.u.auth_info)
2673
2674         from_server = a.credentials
2675         (finished, to_server) = g.update(from_server)
2676         self.assertFalse(finished)
2677
2678         auth_info = self.generate_auth(auth_type=auth_type,
2679                                        auth_level=auth_level,
2680                                        auth_context_id=auth_context_id,
2681                                        auth_blob=to_server)
2682
2683         req = self.generate_alter(call_id=0,
2684                                   ctx_list=ctx_list,
2685                                   assoc_group_id=rep.u.assoc_group_id,
2686                                   auth_info=auth_info)
2687
2688         self.send_pdu(req)
2689         rep = self.recv_pdu()
2690         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id)
2691         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
2692         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
2693         self.assertEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
2694         self.assertEquals(rep.u.secondary_address_size, 0)
2695         self.assertEquals(len(rep.u._pad1), 2)
2696         # Windows sends garbage
2697         #self.assertEquals(rep.u._pad1, '\0' * 2)
2698         self.assertEquals(rep.u.num_results, 1)
2699         self.assertEquals(rep.u.ctx_list[0].result,
2700                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
2701         self.assertEquals(rep.u.ctx_list[0].reason,
2702                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
2703         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
2704         self.assertNotEquals(len(rep.u.auth_info), 0)
2705         a = self.parse_auth(rep.u.auth_info)
2706
2707         from_server = a.credentials
2708         (finished, to_server) = g.update(from_server)
2709         self.assertTrue(finished)
2710
2711         # And now try a request without auth_info
2712         req = self.generate_request(call_id=2,
2713                                     context_id=ctx1.context_id,
2714                                     opnum=0,
2715                                     stub=b"")
2716         self.send_pdu(req)
2717         rep = self.recv_pdu()
2718         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2719                         auth_length=0)
2720         self.assertNotEquals(rep.u.alloc_hint, 0)
2721         self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
2722         self.assertEquals(rep.u.cancel_count, 0)
2723         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2724
2725         # Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
2726         auth_info = self.generate_auth(auth_type=auth_type,
2727                                        auth_level=auth_level,
2728                                        auth_context_id=auth_context_id,
2729                                        auth_blob=b"\x01" +b"\x00" *15)
2730         req = self.generate_request(call_id=3,
2731                                     context_id=ctx1.context_id,
2732                                     opnum=0,
2733                                     stub=b"",
2734                                     auth_info=auth_info)
2735         self.send_pdu(req)
2736         rep = self.recv_pdu()
2737         # We don't get an auth_info back
2738         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
2739                         auth_length=0)
2740         self.assertNotEquals(rep.u.alloc_hint, 0)
2741         self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
2742         self.assertEquals(rep.u.cancel_count, 0)
2743         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
2744
2745         # Now a request with auth_info DCERPC_AUTH_LEVEL_INTEGRITY
2746         auth_info = self.generate_auth(auth_type=auth_type,
2747                                        auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
2748                                        auth_context_id=auth_context_id,
2749                                        auth_blob=b"\x01" + b"\x00" * 15)
2750         req = self.generate_request(call_id=4,
2751                                     context_id=ctx1.context_id,
2752                                     opnum=0,
2753                                     stub=b"",
2754                                     auth_info=auth_info)
2755         self.send_pdu(req)
2756         rep = self.recv_pdu()
2757         # We get a fault back
2758         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
2759                         auth_length=0)
2760         self.assertNotEquals(rep.u.alloc_hint, 0)
2761         self.assertEquals(rep.u.context_id, req.u.context_id)
2762         self.assertEquals(rep.u.cancel_count, 0)
2763         self.assertEquals(rep.u.flags, 0)
2764         self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
2765         self.assertEquals(rep.u.reserved, 0)
2766         self.assertEquals(len(rep.u.error_and_verifier), 0)
2767
2768         # wait for a disconnect
2769         rep = self.recv_pdu()
2770         self.assertIsNone(rep)
2771         self.assertNotConnected()
2772
2773     def test_spnego_integrity_request(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 = self.get_anon_creds()
2785         g = gensec.Security.start_client(self.settings)
2786         g.set_credentials(c)
2787         g.want_feature(gensec.FEATURE_DCE_STYLE)
2788         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
2789         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
2790         auth_context_id = 2
2791         g.start_mech_by_authtype(auth_type, auth_level)
2792         from_server = b""
2793         (finished, to_server) = g.update(from_server)
2794         self.assertFalse(finished)
2795
2796         auth_info = self.generate_auth(auth_type=auth_type,
2797                                        auth_level=auth_level,
2798                                        auth_context_id=auth_context_id,
2799                                        auth_blob=to_server)
2800
2801         req = self.generate_bind(call_id=0,
2802                                  ctx_list=ctx_list,
2803                                  auth_info=auth_info)
2804
2805         self.send_pdu(req)
2806         rep = self.recv_pdu()
2807         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
2808         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
2809         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
2810         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
2811         self.assertEquals(rep.u.secondary_address_size, 4)
2812         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
2813         self.assertEquals(len(rep.u._pad1), 2)
2814         self.assertEquals(rep.u._pad1, b'\0' * 2)
2815         self.assertEquals(rep.u.num_results, 1)
2816         self.assertEquals(rep.u.ctx_list[0].result,
2817                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
2818         self.assertEquals(rep.u.ctx_list[0].reason,
2819                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
2820         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
2821         self.assertNotEquals(len(rep.u.auth_info), 0)
2822         a = self.parse_auth(rep.u.auth_info)
2823
2824         from_server = a.credentials
2825         (finished, to_server) = g.update(from_server)
2826         self.assertFalse(finished)
2827
2828         auth_info = self.generate_auth(auth_type=auth_type,
2829                                        auth_level=auth_level,
2830                                        auth_context_id=auth_context_id,
2831                                        auth_blob=to_server)
2832
2833         req = self.generate_alter(call_id=0,
2834                                   ctx_list=ctx_list,
2835                                   assoc_group_id=rep.u.assoc_group_id,
2836                                   auth_info=auth_info)
2837
2838         self.send_pdu(req)
2839         rep = self.recv_pdu()
2840         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id)
2841         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
2842         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
2843         self.assertEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
2844         self.assertEquals(rep.u.secondary_address_size, 0)
2845         self.assertEquals(len(rep.u._pad1), 2)
2846         # Windows sends garbage
2847         #self.assertEquals(rep.u._pad1, '\0' * 2)
2848         self.assertEquals(rep.u.num_results, 1)
2849         self.assertEquals(rep.u.ctx_list[0].result,
2850                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
2851         self.assertEquals(rep.u.ctx_list[0].reason,
2852                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
2853         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
2854         self.assertNotEquals(len(rep.u.auth_info), 0)
2855         a = self.parse_auth(rep.u.auth_info)
2856
2857         from_server = a.credentials
2858         (finished, to_server) = g.update(from_server)
2859         self.assertTrue(finished)
2860
2861         # Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
2862         auth_info = self.generate_auth(auth_type=auth_type,
2863                                        auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
2864                                        auth_context_id=auth_context_id,
2865                                        auth_blob=b"\x01" + b"\x00" * 15)
2866         req = self.generate_request(call_id=3,
2867                                     context_id=ctx1.context_id,
2868                                     opnum=0,
2869                                     stub=b"",
2870                                     auth_info=auth_info)
2871         self.send_pdu(req)
2872         rep = self.recv_pdu()
2873         # We get a fault back
2874         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
2875                         auth_length=0)
2876         self.assertNotEquals(rep.u.alloc_hint, 0)
2877         self.assertEquals(rep.u.context_id, req.u.context_id)
2878         self.assertEquals(rep.u.cancel_count, 0)
2879         self.assertEquals(rep.u.flags, 0)
2880         self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
2881         self.assertEquals(rep.u.reserved, 0)
2882         self.assertEquals(len(rep.u.error_and_verifier), 0)
2883
2884         # wait for a disconnect
2885         rep = self.recv_pdu()
2886         self.assertIsNone(rep)
2887         self.assertNotConnected()
2888
2889     def test_spnego_unfinished_request(self):
2890         ndr32 = base.transfer_syntax_ndr()
2891
2892         tsf1_list = [ndr32]
2893         ctx1 = dcerpc.ctx_list()
2894         ctx1.context_id = 1
2895         ctx1.num_transfer_syntaxes = len(tsf1_list)
2896         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
2897         ctx1.transfer_syntaxes = tsf1_list
2898         ctx_list = [ctx1]
2899
2900         c = self.get_anon_creds()
2901         g = gensec.Security.start_client(self.settings)
2902         g.set_credentials(c)
2903         g.want_feature(gensec.FEATURE_DCE_STYLE)
2904         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
2905         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
2906         auth_context_id = 2
2907         g.start_mech_by_authtype(auth_type, auth_level)
2908         from_server = b""
2909         (finished, to_server) = g.update(from_server)
2910         self.assertFalse(finished)
2911
2912         auth_info = self.generate_auth(auth_type=auth_type,
2913                                        auth_level=auth_level,
2914                                        auth_context_id=auth_context_id,
2915                                        auth_blob=to_server)
2916
2917         req = self.generate_bind(call_id=0,
2918                                  ctx_list=ctx_list,
2919                                  auth_info=auth_info)
2920
2921         self.send_pdu(req)
2922         rep = self.recv_pdu()
2923         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
2924         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
2925         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
2926         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
2927         assoc_group_id = rep.u.assoc_group_id
2928         self.assertEquals(rep.u.secondary_address_size, 4)
2929         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
2930         self.assertEquals(len(rep.u._pad1), 2)
2931         self.assertEquals(rep.u._pad1, b'\0' * 2)
2932         self.assertEquals(rep.u.num_results, 1)
2933         self.assertEquals(rep.u.ctx_list[0].result,
2934                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
2935         self.assertEquals(rep.u.ctx_list[0].reason,
2936                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
2937         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
2938         self.assertNotEquals(len(rep.u.auth_info), 0)
2939         a = self.parse_auth(rep.u.auth_info)
2940
2941         from_server = a.credentials
2942         (finished, to_server) = g.update(from_server)
2943         self.assertFalse(finished)
2944
2945         # Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
2946         auth_info = self.generate_auth(auth_type=auth_type,
2947                                        auth_level=auth_level,
2948                                        auth_context_id=auth_context_id,
2949                                        auth_blob=b"\x01" + b"\x00" * 15)
2950         req = self.generate_request(call_id=1,
2951                                     context_id=ctx1.context_id,
2952                                     opnum=0,
2953                                     stub=b"",
2954                                     auth_info=auth_info)
2955         self.send_pdu(req)
2956         rep = self.recv_pdu()
2957         # We get a fault
2958         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
2959                         pfc_flags=req.pfc_flags |
2960                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
2961                         auth_length=0)
2962         self.assertNotEquals(rep.u.alloc_hint, 0)
2963         self.assertEquals(rep.u.context_id, 0)
2964         self.assertEquals(rep.u.cancel_count, 0)
2965         self.assertEquals(rep.u.flags, 0)
2966         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
2967         self.assertEquals(rep.u.reserved, 0)
2968         self.assertEquals(len(rep.u.error_and_verifier), 0)
2969
2970         # wait for a disconnect
2971         rep = self.recv_pdu()
2972         self.assertIsNone(rep)
2973         self.assertNotConnected()
2974
2975     def test_spnego_auth3(self):
2976         ndr32 = base.transfer_syntax_ndr()
2977
2978         tsf1_list = [ndr32]
2979         ctx1 = dcerpc.ctx_list()
2980         ctx1.context_id = 1
2981         ctx1.num_transfer_syntaxes = len(tsf1_list)
2982         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
2983         ctx1.transfer_syntaxes = tsf1_list
2984         ctx_list = [ctx1]
2985
2986         c = self.get_anon_creds()
2987         g = gensec.Security.start_client(self.settings)
2988         g.set_credentials(c)
2989         g.want_feature(gensec.FEATURE_DCE_STYLE)
2990         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
2991         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
2992         auth_context_id = 2
2993         g.start_mech_by_authtype(auth_type, auth_level)
2994         from_server = b""
2995         (finished, to_server) = g.update(from_server)
2996         self.assertFalse(finished)
2997
2998         auth_info = self.generate_auth(auth_type=auth_type,
2999                                        auth_level=auth_level,
3000                                        auth_context_id=auth_context_id,
3001                                        auth_blob=to_server)
3002         req = self.generate_bind(call_id=0,
3003                                  ctx_list=ctx_list,
3004                                  auth_info=auth_info)
3005         self.send_pdu(req)
3006         rep = self.recv_pdu()
3007         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
3008         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3009         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3010         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3011         self.assertEquals(rep.u.secondary_address_size, 4)
3012         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
3013         self.assertEquals(len(rep.u._pad1), 2)
3014         #self.assertEquals(rep.u._pad1, '\0' * 2)
3015         self.assertEquals(rep.u.num_results, 1)
3016         self.assertEquals(rep.u.ctx_list[0].result,
3017                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3018         self.assertEquals(rep.u.ctx_list[0].reason,
3019                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
3020         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
3021         self.assertNotEquals(len(rep.u.auth_info), 0)
3022         a = self.parse_auth(rep.u.auth_info)
3023
3024         from_server = a.credentials
3025         (finished, to_server) = g.update(from_server)
3026         self.assertFalse(finished)
3027
3028         auth_info = self.generate_auth(auth_type=auth_type,
3029                                        auth_level=auth_level,
3030                                        auth_context_id=auth_context_id,
3031                                        auth_blob=to_server)
3032         req = self.generate_auth3(call_id=0,
3033                                   auth_info=auth_info)
3034         self.send_pdu(req)
3035         rep = self.recv_pdu()
3036         self.assertIsNone(rep)
3037         self.assertIsConnected()
3038
3039         # And now try a request without auth_info
3040         req = self.generate_request(call_id=2,
3041                                     context_id=ctx1.context_id,
3042                                     opnum=0,
3043                                     stub=b"")
3044         self.send_pdu(req)
3045         rep = self.recv_pdu()
3046         # We get a fault back
3047         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
3048                         auth_length=0)
3049         self.assertNotEquals(rep.u.alloc_hint, 0)
3050         self.assertEquals(rep.u.context_id, req.u.context_id)
3051         self.assertEquals(rep.u.cancel_count, 0)
3052         self.assertEquals(rep.u.flags, 0)
3053         self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
3054         self.assertEquals(rep.u.reserved, 0)
3055         self.assertEquals(len(rep.u.error_and_verifier), 0)
3056
3057         # wait for a disconnect
3058         rep = self.recv_pdu()
3059         self.assertIsNone(rep)
3060         self.assertNotConnected()
3061
3062     def test_spnego_connect_reauth_alter(self):
3063         ndr32 = base.transfer_syntax_ndr()
3064         ndr64 = base.transfer_syntax_ndr64()
3065
3066         tsf1_list = [ndr32]
3067         ctx1 = dcerpc.ctx_list()
3068         ctx1.context_id = 1
3069         ctx1.num_transfer_syntaxes = len(tsf1_list)
3070         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
3071         ctx1.transfer_syntaxes = tsf1_list
3072         ctx_list = [ctx1]
3073
3074         c = self.get_anon_creds()
3075         g = gensec.Security.start_client(self.settings)
3076         g.set_credentials(c)
3077         g.want_feature(gensec.FEATURE_DCE_STYLE)
3078         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
3079         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
3080         auth_context_id = 2
3081         g.start_mech_by_authtype(auth_type, auth_level)
3082         from_server = b""
3083         (finished, to_server) = g.update(from_server)
3084         self.assertFalse(finished)
3085
3086         auth_info = self.generate_auth(auth_type=auth_type,
3087                                        auth_level=auth_level,
3088                                        auth_context_id=auth_context_id,
3089                                        auth_blob=to_server)
3090
3091         req = self.generate_bind(call_id=0,
3092                                  ctx_list=ctx_list,
3093                                  auth_info=auth_info)
3094
3095         self.send_pdu(req)
3096         rep = self.recv_pdu()
3097         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
3098         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3099         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3100         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3101         self.assertEquals(rep.u.secondary_address_size, 4)
3102         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
3103         self.assertEquals(len(rep.u._pad1), 2)
3104         self.assertEquals(rep.u._pad1, b'\0' * 2)
3105         self.assertEquals(rep.u.num_results, 1)
3106         self.assertEquals(rep.u.ctx_list[0].result,
3107                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3108         self.assertEquals(rep.u.ctx_list[0].reason,
3109                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
3110         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
3111         self.assertNotEquals(len(rep.u.auth_info), 0)
3112         a = self.parse_auth(rep.u.auth_info)
3113
3114         from_server = a.credentials
3115         (finished, to_server) = g.update(from_server)
3116         self.assertFalse(finished)
3117
3118         auth_info = self.generate_auth(auth_type=auth_type,
3119                                        auth_level=auth_level,
3120                                        auth_context_id=auth_context_id,
3121                                        auth_blob=to_server)
3122         req = self.generate_alter(call_id=0,
3123                                   ctx_list=[ctx1],
3124                                   assoc_group_id=rep.u.assoc_group_id,
3125                                   auth_info=auth_info)
3126         self.send_pdu(req)
3127         rep = self.recv_pdu()
3128         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id)
3129         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3130         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3131         self.assertEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3132         self.assertEquals(rep.u.secondary_address_size, 0)
3133         self.assertEquals(len(rep.u._pad1), 2)
3134         # Windows sends garbage
3135         #self.assertEquals(rep.u._pad1, '\0' * 2)
3136         self.assertEquals(rep.u.num_results, 1)
3137         self.assertEquals(rep.u.ctx_list[0].result,
3138                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3139         self.assertEquals(rep.u.ctx_list[0].reason,
3140                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
3141         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
3142         self.assertNotEquals(len(rep.u.auth_info), 0)
3143         a = self.parse_auth(rep.u.auth_info)
3144
3145         from_server = a.credentials
3146         (finished, to_server) = g.update(from_server)
3147         self.assertTrue(finished)
3148
3149         # And now try a request without auth_info
3150         req = self.generate_request(call_id=2,
3151                                     context_id=ctx1.context_id,
3152                                     opnum=0,
3153                                     stub=b"")
3154         self.send_pdu(req)
3155         rep = self.recv_pdu()
3156         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
3157                         auth_length=0)
3158         self.assertNotEquals(rep.u.alloc_hint, 0)
3159         self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
3160         self.assertEquals(rep.u.cancel_count, 0)
3161         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
3162
3163         # Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
3164         auth_info = self.generate_auth(auth_type=auth_type,
3165                                        auth_level=auth_level,
3166                                        auth_context_id=auth_context_id,
3167                                        auth_blob=b"\x01" + b"\x00" * 15)
3168         req = self.generate_request(call_id=3,
3169                                     context_id=ctx1.context_id,
3170                                     opnum=0,
3171                                     stub=b"",
3172                                     auth_info=auth_info)
3173         self.send_pdu(req)
3174         rep = self.recv_pdu()
3175         # We don't get an auth_info back
3176         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
3177                         auth_length=0)
3178         self.assertNotEquals(rep.u.alloc_hint, 0)
3179         self.assertEquals(rep.u.context_id, req.u.context_id)
3180         self.assertEquals(rep.u.cancel_count, 0)
3181         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
3182
3183         # Now a reauth
3184
3185         g = gensec.Security.start_client(self.settings)
3186         g.set_credentials(c)
3187         g.want_feature(gensec.FEATURE_DCE_STYLE)
3188         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
3189         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
3190         auth_context_id = 2
3191         g.start_mech_by_authtype(auth_type, auth_level)
3192         from_server = b""
3193         (finished, to_server) = g.update(from_server)
3194         self.assertFalse(finished)
3195
3196         auth_info = self.generate_auth(auth_type=auth_type,
3197                                        auth_level=auth_level,
3198                                        auth_context_id=auth_context_id,
3199                                        auth_blob=to_server)
3200         req = self.generate_alter(call_id=0,
3201                                   ctx_list=ctx_list,
3202                                   auth_info=auth_info)
3203         self.send_pdu(req)
3204         rep = self.recv_pdu()
3205         # We get a fault
3206         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
3207                         pfc_flags=req.pfc_flags |
3208                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
3209                         auth_length=0)
3210         self.assertNotEquals(rep.u.alloc_hint, 0)
3211         self.assertEquals(rep.u.context_id, 0)
3212         self.assertEquals(rep.u.cancel_count, 0)
3213         self.assertEquals(rep.u.flags, 0)
3214         self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
3215         self.assertEquals(rep.u.reserved, 0)
3216         self.assertEquals(len(rep.u.error_and_verifier), 0)
3217
3218         # wait for a disconnect
3219         rep = self.recv_pdu()
3220         self.assertIsNone(rep)
3221         self.assertNotConnected()
3222
3223     def test_spnego_connect_reauth_auth3(self):
3224         ndr32 = base.transfer_syntax_ndr()
3225         ndr64 = base.transfer_syntax_ndr64()
3226
3227         tsf1_list = [ndr32]
3228         ctx1 = dcerpc.ctx_list()
3229         ctx1.context_id = 1
3230         ctx1.num_transfer_syntaxes = len(tsf1_list)
3231         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
3232         ctx1.transfer_syntaxes = tsf1_list
3233         ctx_list = [ctx1]
3234
3235         c = self.get_anon_creds()
3236         g = gensec.Security.start_client(self.settings)
3237         g.set_credentials(c)
3238         g.want_feature(gensec.FEATURE_DCE_STYLE)
3239         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
3240         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
3241         auth_context_id = 2
3242         g.start_mech_by_authtype(auth_type, auth_level)
3243         from_server = b""
3244         (finished, to_server) = g.update(from_server)
3245         self.assertFalse(finished)
3246
3247         auth_info = self.generate_auth(auth_type=auth_type,
3248                                        auth_level=auth_level,
3249                                        auth_context_id=auth_context_id,
3250                                        auth_blob=to_server)
3251
3252         req = self.generate_bind(call_id=0,
3253                                  ctx_list=ctx_list,
3254                                  auth_info=auth_info)
3255
3256         self.send_pdu(req)
3257         rep = self.recv_pdu()
3258         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
3259         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3260         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3261         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3262         self.assertEquals(rep.u.secondary_address_size, 4)
3263         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
3264         self.assertEquals(len(rep.u._pad1), 2)
3265         self.assertEquals(rep.u._pad1, b'\0' * 2)
3266         self.assertEquals(rep.u.num_results, 1)
3267         self.assertEquals(rep.u.ctx_list[0].result,
3268                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3269         self.assertEquals(rep.u.ctx_list[0].reason,
3270                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
3271         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
3272         self.assertNotEquals(len(rep.u.auth_info), 0)
3273         a = self.parse_auth(rep.u.auth_info)
3274
3275         from_server = a.credentials
3276         (finished, to_server) = g.update(from_server)
3277         self.assertFalse(finished)
3278
3279         auth_info = self.generate_auth(auth_type=auth_type,
3280                                        auth_level=auth_level,
3281                                        auth_context_id=auth_context_id,
3282                                        auth_blob=to_server)
3283         req = self.generate_alter(call_id=0,
3284                                   ctx_list=[ctx1],
3285                                   assoc_group_id=rep.u.assoc_group_id,
3286                                   auth_info=auth_info)
3287         self.send_pdu(req)
3288         rep = self.recv_pdu()
3289         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id)
3290         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3291         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3292         self.assertEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3293         self.assertEquals(rep.u.secondary_address_size, 0)
3294         self.assertEquals(len(rep.u._pad1), 2)
3295         # Windows sends garbage
3296         #self.assertEquals(rep.u._pad1, '\0' * 2)
3297         self.assertEquals(rep.u.num_results, 1)
3298         self.assertEquals(rep.u.ctx_list[0].result,
3299                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3300         self.assertEquals(rep.u.ctx_list[0].reason,
3301                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
3302         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
3303         self.assertNotEquals(len(rep.u.auth_info), 0)
3304         a = self.parse_auth(rep.u.auth_info)
3305
3306         from_server = a.credentials
3307         (finished, to_server) = g.update(from_server)
3308         self.assertTrue(finished)
3309
3310         # And now try a request without auth_info
3311         req = self.generate_request(call_id=2,
3312                                     context_id=ctx1.context_id,
3313                                     opnum=0,
3314                                     stub=b"")
3315         self.send_pdu(req)
3316         rep = self.recv_pdu()
3317         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
3318                         auth_length=0)
3319         self.assertNotEquals(rep.u.alloc_hint, 0)
3320         self.assertEquals(rep.u.context_id, req.u.context_id)
3321         self.assertEquals(rep.u.cancel_count, 0)
3322         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
3323
3324         # Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
3325         auth_info = self.generate_auth(auth_type=auth_type,
3326                                        auth_level=auth_level,
3327                                        auth_context_id=auth_context_id,
3328                                        auth_blob=b"\x01" + b"\x00" * 15)
3329         req = self.generate_request(call_id=3,
3330                                     context_id=ctx1.context_id,
3331                                     opnum=0,
3332                                     stub=b"",
3333                                     auth_info=auth_info)
3334         self.send_pdu(req)
3335         rep = self.recv_pdu()
3336         # We don't get an auth_info back
3337         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
3338                         auth_length=0)
3339         self.assertNotEquals(rep.u.alloc_hint, 0)
3340         self.assertEquals(rep.u.context_id, req.u.context_id)
3341         self.assertEquals(rep.u.cancel_count, 0)
3342         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
3343
3344         # Now a reauth
3345
3346         g = gensec.Security.start_client(self.settings)
3347         g.set_credentials(c)
3348         g.want_feature(gensec.FEATURE_DCE_STYLE)
3349         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
3350         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
3351         auth_context_id = 2
3352         g.start_mech_by_authtype(auth_type, auth_level)
3353         from_server = b""
3354         (finished, to_server) = g.update(from_server)
3355         self.assertFalse(finished)
3356
3357         auth_info = self.generate_auth(auth_type=auth_type,
3358                                        auth_level=auth_level,
3359                                        auth_context_id=auth_context_id,
3360                                        auth_blob=to_server)
3361         req = self.generate_auth3(call_id=0,
3362                                   auth_info=auth_info)
3363         self.send_pdu(req)
3364         rep = self.recv_pdu()
3365         # We get a fault
3366         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
3367                         pfc_flags=req.pfc_flags |
3368                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
3369                         auth_length=0)
3370         self.assertNotEquals(rep.u.alloc_hint, 0)
3371         self.assertEquals(rep.u.context_id, 0)
3372         self.assertEquals(rep.u.cancel_count, 0)
3373         self.assertEquals(rep.u.flags, 0)
3374         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
3375         self.assertEquals(rep.u.reserved, 0)
3376         self.assertEquals(len(rep.u.error_and_verifier), 0)
3377
3378         # wait for a disconnect
3379         rep = self.recv_pdu()
3380         self.assertIsNone(rep)
3381         self.assertNotConnected()
3382
3383     def test_spnego_change_auth_level(self):
3384         ndr32 = base.transfer_syntax_ndr()
3385
3386         tsf1_list = [ndr32]
3387         ctx1 = dcerpc.ctx_list()
3388         ctx1.context_id = 1
3389         ctx1.num_transfer_syntaxes = len(tsf1_list)
3390         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
3391         ctx1.transfer_syntaxes = tsf1_list
3392
3393         c = self.get_anon_creds()
3394         g = gensec.Security.start_client(self.settings)
3395         g.set_credentials(c)
3396         g.want_feature(gensec.FEATURE_DCE_STYLE)
3397         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
3398         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
3399         auth_context_id = 2
3400         g.start_mech_by_authtype(auth_type, auth_level)
3401         from_server = b""
3402         (finished, to_server) = g.update(from_server)
3403         self.assertFalse(finished)
3404
3405         auth_info = self.generate_auth(auth_type=auth_type,
3406                                        auth_level=auth_level,
3407                                        auth_context_id=auth_context_id,
3408                                        auth_blob=to_server)
3409         req = self.generate_bind(call_id=0,
3410                                  ctx_list=[ctx1],
3411                                  auth_info=auth_info)
3412         self.send_pdu(req)
3413         rep = self.recv_pdu()
3414         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
3415         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3416         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3417         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3418         self.assertEquals(rep.u.secondary_address_size, 4)
3419         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
3420         self.assertEquals(len(rep.u._pad1), 2)
3421         self.assertEquals(rep.u._pad1, b'\0' * 2)
3422         self.assertEquals(rep.u.num_results, 1)
3423         self.assertEquals(rep.u.ctx_list[0].result,
3424                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3425         self.assertEquals(rep.u.ctx_list[0].reason,
3426                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
3427         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
3428         self.assertNotEquals(len(rep.u.auth_info), 0)
3429         a = self.parse_auth(rep.u.auth_info)
3430
3431         from_server = a.credentials
3432         (finished, to_server) = g.update(from_server)
3433         self.assertFalse(finished)
3434
3435         auth_info = self.generate_auth(auth_type=auth_type,
3436                                        auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
3437                                        auth_context_id=auth_context_id,
3438                                        auth_blob=to_server)
3439         req = self.generate_alter(call_id=0,
3440                                   ctx_list=[ctx1],
3441                                   assoc_group_id=rep.u.assoc_group_id,
3442                                   auth_info=auth_info)
3443         self.send_pdu(req)
3444         rep = self.recv_pdu()
3445         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
3446                         pfc_flags=req.pfc_flags |
3447                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
3448                         auth_length=0)
3449         self.assertNotEquals(rep.u.alloc_hint, 0)
3450         self.assertEquals(rep.u.context_id, 0)
3451         self.assertEquals(rep.u.cancel_count, 0)
3452         self.assertEquals(rep.u.flags, 0)
3453         self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
3454         self.assertEquals(rep.u.reserved, 0)
3455         self.assertEquals(len(rep.u.error_and_verifier), 0)
3456
3457         # wait for a disconnect
3458         rep = self.recv_pdu()
3459         self.assertIsNone(rep)
3460         self.assertNotConnected()
3461
3462     def test_spnego_change_abstract(self):
3463         ndr32 = base.transfer_syntax_ndr()
3464
3465         tsf1_list = [ndr32]
3466         ctx1 = dcerpc.ctx_list()
3467         ctx1.context_id = 1
3468         ctx1.num_transfer_syntaxes = len(tsf1_list)
3469         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
3470         ctx1.transfer_syntaxes = tsf1_list
3471
3472         ctx1b = dcerpc.ctx_list()
3473         ctx1b.context_id = 1
3474         ctx1b.num_transfer_syntaxes = len(tsf1_list)
3475         ctx1b.abstract_syntax = samba.dcerpc.epmapper.abstract_syntax()
3476         ctx1b.transfer_syntaxes = tsf1_list
3477
3478         c = self.get_anon_creds()
3479         g = gensec.Security.start_client(self.settings)
3480         g.set_credentials(c)
3481         g.want_feature(gensec.FEATURE_DCE_STYLE)
3482         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
3483         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
3484         auth_context_id = 2
3485         g.start_mech_by_authtype(auth_type, auth_level)
3486         from_server = b""
3487         (finished, to_server) = g.update(from_server)
3488         self.assertFalse(finished)
3489
3490         auth_info = self.generate_auth(auth_type=auth_type,
3491                                        auth_level=auth_level,
3492                                        auth_context_id=auth_context_id,
3493                                        auth_blob=to_server)
3494         req = self.generate_bind(call_id=0,
3495                                  ctx_list=[ctx1],
3496                                  auth_info=auth_info)
3497         self.send_pdu(req)
3498         rep = self.recv_pdu()
3499         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
3500         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3501         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3502         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3503         self.assertEquals(rep.u.secondary_address_size, 4)
3504         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
3505         self.assertEquals(len(rep.u._pad1), 2)
3506         #self.assertEquals(rep.u._pad1, '\0' * 2)
3507         self.assertEquals(rep.u.num_results, 1)
3508         self.assertEquals(rep.u.ctx_list[0].result,
3509                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3510         self.assertEquals(rep.u.ctx_list[0].reason,
3511                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
3512         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
3513         self.assertNotEquals(len(rep.u.auth_info), 0)
3514         a = self.parse_auth(rep.u.auth_info)
3515
3516         from_server = a.credentials
3517         (finished, to_server) = g.update(from_server)
3518         self.assertFalse(finished)
3519
3520         auth_info = self.generate_auth(auth_type=auth_type,
3521                                        auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
3522                                        auth_context_id=auth_context_id,
3523                                        auth_blob=to_server)
3524         req = self.generate_alter(call_id=0,
3525                                   ctx_list=[ctx1b],
3526                                   assoc_group_id=rep.u.assoc_group_id,
3527                                   auth_info=auth_info)
3528         self.send_pdu(req)
3529         rep = self.recv_pdu()
3530         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
3531                         pfc_flags=req.pfc_flags |
3532                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
3533                         auth_length=0)
3534         self.assertNotEquals(rep.u.alloc_hint, 0)
3535         self.assertEquals(rep.u.context_id, 0)
3536         self.assertEquals(rep.u.cancel_count, 0)
3537         self.assertEquals(rep.u.flags, 0)
3538         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
3539         self.assertEquals(rep.u.reserved, 0)
3540         self.assertEquals(len(rep.u.error_and_verifier), 0)
3541
3542         # wait for a disconnect
3543         rep = self.recv_pdu()
3544         self.assertIsNone(rep)
3545         self.assertNotConnected()
3546
3547     def test_spnego_change_transfer(self):
3548         ndr32 = base.transfer_syntax_ndr()
3549         ndr64 = base.transfer_syntax_ndr64()
3550
3551         tsf1_list = [ndr32]
3552         ctx1 = dcerpc.ctx_list()
3553         ctx1.context_id = 1
3554         ctx1.num_transfer_syntaxes = len(tsf1_list)
3555         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
3556         ctx1.transfer_syntaxes = tsf1_list
3557
3558         tsf1b_list = [ndr32, ndr64]
3559         ctx1b = dcerpc.ctx_list()
3560         ctx1b.context_id = 1
3561         ctx1b.num_transfer_syntaxes = len(tsf1b_list)
3562         ctx1b.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
3563         ctx1b.transfer_syntaxes = tsf1b_list
3564
3565         c = self.get_anon_creds()
3566         g = gensec.Security.start_client(self.settings)
3567         g.set_credentials(c)
3568         g.want_feature(gensec.FEATURE_DCE_STYLE)
3569         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
3570         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
3571         auth_context_id = 2
3572         g.start_mech_by_authtype(auth_type, auth_level)
3573         from_server = b""
3574         (finished, to_server) = g.update(from_server)
3575         self.assertFalse(finished)
3576
3577         auth_info = self.generate_auth(auth_type=auth_type,
3578                                        auth_level=auth_level,
3579                                        auth_context_id=auth_context_id,
3580                                        auth_blob=to_server)
3581         req = self.generate_bind(call_id=0,
3582                                  ctx_list=[ctx1],
3583                                  auth_info=auth_info)
3584         self.send_pdu(req)
3585         rep = self.recv_pdu()
3586         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
3587         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3588         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3589         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3590         self.assertEquals(rep.u.secondary_address_size, 4)
3591         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
3592         self.assertEquals(len(rep.u._pad1), 2)
3593         #self.assertEquals(rep.u._pad1, '\0' * 2)
3594         self.assertEquals(rep.u.num_results, 1)
3595         self.assertEquals(rep.u.ctx_list[0].result,
3596                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3597         self.assertEquals(rep.u.ctx_list[0].reason,
3598                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
3599         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
3600         self.assertNotEquals(len(rep.u.auth_info), 0)
3601         a = self.parse_auth(rep.u.auth_info)
3602
3603         from_server = a.credentials
3604         (finished, to_server) = g.update(from_server)
3605         self.assertFalse(finished)
3606
3607         # We change ctx_list and auth_level
3608         auth_info = self.generate_auth(auth_type=auth_type,
3609                                        auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
3610                                        auth_context_id=auth_context_id,
3611                                        auth_blob=to_server)
3612         req = self.generate_alter(call_id=0,
3613                                   ctx_list=[ctx1b],
3614                                   assoc_group_id=rep.u.assoc_group_id,
3615                                   auth_info=auth_info)
3616         self.send_pdu(req)
3617         rep = self.recv_pdu()
3618         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
3619                         pfc_flags=req.pfc_flags |
3620                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
3621                         auth_length=0)
3622         self.assertNotEquals(rep.u.alloc_hint, 0)
3623         self.assertEquals(rep.u.context_id, 0)
3624         self.assertEquals(rep.u.cancel_count, 0)
3625         self.assertEquals(rep.u.flags, 0)
3626         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
3627         self.assertEquals(rep.u.reserved, 0)
3628         self.assertEquals(len(rep.u.error_and_verifier), 0)
3629
3630         # wait for a disconnect
3631         rep = self.recv_pdu()
3632         self.assertIsNone(rep)
3633         self.assertNotConnected()
3634
3635     def test_spnego_change_auth_type1(self):
3636         ndr32 = base.transfer_syntax_ndr()
3637         ndr64 = base.transfer_syntax_ndr64()
3638
3639         tsf1_list = [ndr32]
3640         ctx1 = dcerpc.ctx_list()
3641         ctx1.context_id = 1
3642         ctx1.num_transfer_syntaxes = len(tsf1_list)
3643         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
3644         ctx1.transfer_syntaxes = tsf1_list
3645
3646         c = self.get_anon_creds()
3647         g = gensec.Security.start_client(self.settings)
3648         g.set_credentials(c)
3649         g.want_feature(gensec.FEATURE_DCE_STYLE)
3650         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
3651         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
3652         auth_context_id = 2
3653         g.start_mech_by_authtype(auth_type, auth_level)
3654         from_server = b""
3655         (finished, to_server) = g.update(from_server)
3656         self.assertFalse(finished)
3657
3658         auth_info = self.generate_auth(auth_type=auth_type,
3659                                        auth_level=auth_level,
3660                                        auth_context_id=auth_context_id,
3661                                        auth_blob=to_server)
3662         req = self.generate_bind(call_id=0,
3663                                  ctx_list=[ctx1],
3664                                  auth_info=auth_info)
3665         self.send_pdu(req)
3666         rep = self.recv_pdu()
3667         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
3668         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3669         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3670         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3671         self.assertEquals(rep.u.secondary_address_size, 4)
3672         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
3673         self.assertEquals(len(rep.u._pad1), 2)
3674         #self.assertEquals(rep.u._pad1, '\0' * 2)
3675         self.assertEquals(rep.u.num_results, 1)
3676         self.assertEquals(rep.u.ctx_list[0].result,
3677                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3678         self.assertEquals(rep.u.ctx_list[0].reason,
3679                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
3680         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
3681         self.assertNotEquals(len(rep.u.auth_info), 0)
3682         a = self.parse_auth(rep.u.auth_info)
3683
3684         from_server = a.credentials
3685         (finished, to_server) = g.update(from_server)
3686         self.assertFalse(finished)
3687
3688         # We change ctx_list and auth_level
3689         auth_info = self.generate_auth(auth_type=dcerpc.DCERPC_AUTH_TYPE_KRB5,
3690                                        auth_level=auth_level,
3691                                        auth_context_id=auth_context_id,
3692                                        auth_blob=to_server)
3693         req = self.generate_alter(call_id=0,
3694                                   ctx_list=[ctx1],
3695                                   assoc_group_id=rep.u.assoc_group_id,
3696                                   auth_info=auth_info)
3697         self.send_pdu(req)
3698         rep = self.recv_pdu()
3699         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
3700                         pfc_flags=req.pfc_flags |
3701                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
3702                         auth_length=0)
3703         self.assertNotEquals(rep.u.alloc_hint, 0)
3704         self.assertEquals(rep.u.context_id, 0)
3705         self.assertEquals(rep.u.cancel_count, 0)
3706         self.assertEquals(rep.u.flags, 0)
3707         self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
3708         self.assertEquals(rep.u.reserved, 0)
3709         self.assertEquals(len(rep.u.error_and_verifier), 0)
3710
3711         # wait for a disconnect
3712         rep = self.recv_pdu()
3713         self.assertIsNone(rep)
3714         self.assertNotConnected()
3715
3716     def test_spnego_change_auth_type2(self):
3717         ndr32 = base.transfer_syntax_ndr()
3718         ndr64 = base.transfer_syntax_ndr64()
3719
3720         tsf1_list = [ndr32]
3721         ctx1 = dcerpc.ctx_list()
3722         ctx1.context_id = 1
3723         ctx1.num_transfer_syntaxes = len(tsf1_list)
3724         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
3725         ctx1.transfer_syntaxes = tsf1_list
3726
3727         tsf1b_list = [ndr32, ndr64]
3728         ctx1b = dcerpc.ctx_list()
3729         ctx1b.context_id = 1
3730         ctx1b.num_transfer_syntaxes = len(tsf1b_list)
3731         ctx1b.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
3732         ctx1b.transfer_syntaxes = tsf1b_list
3733
3734         c = self.get_anon_creds()
3735         g = gensec.Security.start_client(self.settings)
3736         g.set_credentials(c)
3737         g.want_feature(gensec.FEATURE_DCE_STYLE)
3738         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
3739         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
3740         auth_context_id = 2
3741         g.start_mech_by_authtype(auth_type, auth_level)
3742         from_server = b""
3743         (finished, to_server) = g.update(from_server)
3744         self.assertFalse(finished)
3745
3746         auth_info = self.generate_auth(auth_type=auth_type,
3747                                        auth_level=auth_level,
3748                                        auth_context_id=auth_context_id,
3749                                        auth_blob=to_server)
3750         req = self.generate_bind(call_id=0,
3751                                  ctx_list=[ctx1],
3752                                  auth_info=auth_info)
3753         self.send_pdu(req)
3754         rep = self.recv_pdu()
3755         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
3756         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3757         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3758         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3759         self.assertEquals(rep.u.secondary_address_size, 4)
3760         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
3761         self.assertEquals(len(rep.u._pad1), 2)
3762         #self.assertEquals(rep.u._pad1, '\0' * 2)
3763         self.assertEquals(rep.u.num_results, 1)
3764         self.assertEquals(rep.u.ctx_list[0].result,
3765                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3766         self.assertEquals(rep.u.ctx_list[0].reason,
3767                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
3768         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
3769         self.assertNotEquals(len(rep.u.auth_info), 0)
3770         a = self.parse_auth(rep.u.auth_info)
3771
3772         from_server = a.credentials
3773         (finished, to_server) = g.update(from_server)
3774         self.assertFalse(finished)
3775
3776         # We change ctx_list and auth_level
3777         auth_info = self.generate_auth(auth_type=dcerpc.DCERPC_AUTH_TYPE_KRB5,
3778                                        auth_level=auth_level,
3779                                        auth_context_id=auth_context_id,
3780                                        auth_blob=to_server)
3781         req = self.generate_alter(call_id=0,
3782                                   ctx_list=[ctx1b],
3783                                   assoc_group_id=rep.u.assoc_group_id,
3784                                   auth_info=auth_info)
3785         self.send_pdu(req)
3786         rep = self.recv_pdu()
3787         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
3788                         pfc_flags=req.pfc_flags |
3789                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
3790                         auth_length=0)
3791         self.assertNotEquals(rep.u.alloc_hint, 0)
3792         self.assertEquals(rep.u.context_id, 0)
3793         self.assertEquals(rep.u.cancel_count, 0)
3794         self.assertEquals(rep.u.flags, 0)
3795         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
3796         self.assertEquals(rep.u.reserved, 0)
3797         self.assertEquals(len(rep.u.error_and_verifier), 0)
3798
3799         # wait for a disconnect
3800         rep = self.recv_pdu()
3801         self.assertIsNone(rep)
3802         self.assertNotConnected()
3803
3804     def test_spnego_change_auth_type3(self):
3805         ndr32 = base.transfer_syntax_ndr()
3806         ndr64 = base.transfer_syntax_ndr64()
3807
3808         tsf1_list = [ndr32]
3809         ctx1 = dcerpc.ctx_list()
3810         ctx1.context_id = 1
3811         ctx1.num_transfer_syntaxes = len(tsf1_list)
3812         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
3813         ctx1.transfer_syntaxes = tsf1_list
3814
3815         tsf1b_list = [ndr32, ndr64]
3816         ctx1b = dcerpc.ctx_list()
3817         ctx1b.context_id = 1
3818         ctx1b.num_transfer_syntaxes = len(tsf1b_list)
3819         ctx1b.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
3820         ctx1b.transfer_syntaxes = tsf1b_list
3821
3822         c = self.get_anon_creds()
3823         g = gensec.Security.start_client(self.settings)
3824         g.set_credentials(c)
3825         g.want_feature(gensec.FEATURE_DCE_STYLE)
3826         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
3827         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
3828         auth_context_id = 2
3829         g.start_mech_by_authtype(auth_type, auth_level)
3830         from_server = b""
3831         (finished, to_server) = g.update(from_server)
3832         self.assertFalse(finished)
3833
3834         auth_info = self.generate_auth(auth_type=auth_type,
3835                                        auth_level=auth_level,
3836                                        auth_context_id=auth_context_id,
3837                                        auth_blob=to_server)
3838         req = self.generate_bind(call_id=0,
3839                                  ctx_list=[ctx1],
3840                                  auth_info=auth_info)
3841         self.send_pdu(req)
3842         rep = self.recv_pdu()
3843         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
3844         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3845         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3846         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3847         self.assertEquals(rep.u.secondary_address_size, 4)
3848         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
3849         self.assertEquals(len(rep.u._pad1), 2)
3850         #self.assertEquals(rep.u._pad1, '\0' * 2)
3851         self.assertEquals(rep.u.num_results, 1)
3852         self.assertEquals(rep.u.ctx_list[0].result,
3853                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3854         self.assertEquals(rep.u.ctx_list[0].reason,
3855                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
3856         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
3857         self.assertNotEquals(len(rep.u.auth_info), 0)
3858         a = self.parse_auth(rep.u.auth_info)
3859
3860         from_server = a.credentials
3861         (finished, to_server) = g.update(from_server)
3862         self.assertFalse(finished)
3863
3864         # We change ctx_list and auth_level
3865         auth_info = self.generate_auth(auth_type=dcerpc.DCERPC_AUTH_TYPE_NONE,
3866                                        auth_level=auth_level,
3867                                        auth_context_id=auth_context_id,
3868                                        auth_blob=to_server)
3869         req = self.generate_alter(call_id=0,
3870                                   ctx_list=[ctx1b],
3871                                   assoc_group_id=rep.u.assoc_group_id,
3872                                   auth_info=auth_info)
3873         self.send_pdu(req)
3874         rep = self.recv_pdu()
3875         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
3876                         pfc_flags=req.pfc_flags |
3877                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
3878                         auth_length=0)
3879         self.assertNotEquals(rep.u.alloc_hint, 0)
3880         self.assertEquals(rep.u.context_id, 0)
3881         self.assertEquals(rep.u.cancel_count, 0)
3882         self.assertEquals(rep.u.flags, 0)
3883         self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
3884         self.assertEquals(rep.u.reserved, 0)
3885         self.assertEquals(len(rep.u.error_and_verifier), 0)
3886
3887         # wait for a disconnect
3888         rep = self.recv_pdu()
3889         self.assertIsNone(rep)
3890         self.assertNotConnected()
3891
3892     def test_spnego_auth_pad_ok(self):
3893         ndr32 = base.transfer_syntax_ndr()
3894
3895         tsf1_list = [ndr32]
3896         ctx1 = dcerpc.ctx_list()
3897         ctx1.context_id = 1
3898         ctx1.num_transfer_syntaxes = len(tsf1_list)
3899         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
3900         ctx1.transfer_syntaxes = tsf1_list
3901         ctx_list = [ctx1]
3902
3903         c = self.get_anon_creds()
3904         g = gensec.Security.start_client(self.settings)
3905         g.set_credentials(c)
3906         g.want_feature(gensec.FEATURE_DCE_STYLE)
3907         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
3908         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
3909         auth_context_id = 2
3910         g.start_mech_by_authtype(auth_type, auth_level)
3911         from_server = b""
3912         (finished, to_server) = g.update(from_server)
3913         self.assertFalse(finished)
3914
3915         auth_info = self.generate_auth(auth_type=auth_type,
3916                                        auth_level=auth_level,
3917                                        auth_context_id=auth_context_id,
3918                                        auth_blob=to_server)
3919
3920         req = self.generate_bind(call_id=0,
3921                                  ctx_list=ctx_list,
3922                                  auth_info=auth_info)
3923         req_pdu = samba.ndr.ndr_pack(req)
3924
3925         auth_pad_ok = len(req_pdu)
3926         auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
3927         auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
3928         auth_pad_ok -= len(to_server)
3929
3930         auth_info = self.generate_auth(auth_type=auth_type,
3931                                        auth_level=auth_level,
3932                                        auth_context_id=auth_context_id,
3933                                        auth_pad_length=auth_pad_ok,
3934                                        auth_blob=to_server)
3935
3936         req = self.generate_bind(call_id=0,
3937                                  ctx_list=ctx_list,
3938                                  auth_info=auth_info)
3939         self.send_pdu(req)
3940         rep = self.recv_pdu()
3941         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
3942         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3943         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3944         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3945         self.assertEquals(rep.u.secondary_address_size, 4)
3946         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
3947         self.assertEquals(len(rep.u._pad1), 2)
3948         #self.assertEquals(rep.u._pad1, '\0' * 2)
3949         self.assertEquals(rep.u.num_results, 1)
3950         self.assertEquals(rep.u.ctx_list[0].result,
3951                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3952         self.assertEquals(rep.u.ctx_list[0].reason,
3953                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
3954         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
3955         self.assertNotEquals(len(rep.u.auth_info), 0)
3956         a = self.parse_auth(rep.u.auth_info)
3957
3958         from_server = a.credentials
3959         (finished, to_server) = g.update(from_server)
3960         self.assertFalse(finished)
3961
3962         auth_info = self.generate_auth(auth_type=auth_type,
3963                                        auth_level=auth_level,
3964                                        auth_context_id=auth_context_id,
3965                                        auth_blob=to_server)
3966         req = self.generate_alter(call_id=0,
3967                                   ctx_list=ctx_list,
3968                                   assoc_group_id=rep.u.assoc_group_id,
3969                                   auth_info=auth_info)
3970         req_pdu = samba.ndr.ndr_pack(req)
3971
3972         auth_pad_ok = len(req_pdu)
3973         auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
3974         auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
3975         auth_pad_ok -= len(to_server)
3976         auth_info = self.generate_auth(auth_type=auth_type,
3977                                        auth_level=auth_level,
3978                                        auth_context_id=auth_context_id,
3979                                        auth_pad_length=auth_pad_ok,
3980                                        auth_blob=to_server)
3981         req = self.generate_alter(call_id=0,
3982                                   ctx_list=ctx_list,
3983                                   assoc_group_id=rep.u.assoc_group_id,
3984                                   auth_info=auth_info)
3985         self.send_pdu(req)
3986         rep = self.recv_pdu()
3987         self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id)
3988         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
3989         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
3990         self.assertEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
3991         self.assertEquals(rep.u.secondary_address_size, 0)
3992         self.assertEquals(len(rep.u._pad1), 2)
3993         # Windows sends garbage
3994         #self.assertEquals(rep.u._pad1, '\0' * 2)
3995         self.assertEquals(rep.u.num_results, 1)
3996         self.assertEquals(rep.u.ctx_list[0].result,
3997                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
3998         self.assertEquals(rep.u.ctx_list[0].reason,
3999                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
4000         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
4001         self.assertNotEquals(len(rep.u.auth_info), 0)
4002         a = self.parse_auth(rep.u.auth_info)
4003
4004         from_server = a.credentials
4005         (finished, to_server) = g.update(from_server)
4006         self.assertTrue(finished)
4007
4008         # And now try a request without auth_info
4009         req = self.generate_request(call_id=2,
4010                                     context_id=ctx1.context_id,
4011                                     opnum=0,
4012                                     stub=b"")
4013         self.send_pdu(req)
4014         rep = self.recv_pdu()
4015         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
4016                         auth_length=0)
4017         self.assertNotEquals(rep.u.alloc_hint, 0)
4018         self.assertEquals(rep.u.context_id, req.u.context_id)
4019         self.assertEquals(rep.u.cancel_count, 0)
4020         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
4021
4022         # Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
4023         auth_info = self.generate_auth(auth_type=auth_type,
4024                                        auth_level=auth_level,
4025                                        auth_context_id=auth_context_id,
4026                                        auth_blob=b"\x01" + b"\x00" * 15)
4027         req = self.generate_request(call_id=3,
4028                                     context_id=ctx1.context_id,
4029                                     opnum=0,
4030                                     stub=b"",
4031                                     auth_info=auth_info)
4032         self.send_pdu(req)
4033         rep = self.recv_pdu()
4034         # We don't get an auth_info back
4035         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
4036                         auth_length=0)
4037         self.assertNotEquals(rep.u.alloc_hint, 0)
4038         self.assertEquals(rep.u.context_id, req.u.context_id)
4039         self.assertEquals(rep.u.cancel_count, 0)
4040         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
4041
4042         self._disconnect("disconnect")
4043         self.assertNotConnected()
4044
4045     def test_spnego_auth_pad_fail_bind(self):
4046         ndr32 = base.transfer_syntax_ndr()
4047
4048         tsf1_list = [ndr32]
4049         ctx1 = dcerpc.ctx_list()
4050         ctx1.context_id = 1
4051         ctx1.num_transfer_syntaxes = len(tsf1_list)
4052         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
4053         ctx1.transfer_syntaxes = tsf1_list
4054         ctx_list = [ctx1]
4055
4056         c = self.get_anon_creds()
4057         g = gensec.Security.start_client(self.settings)
4058         g.set_credentials(c)
4059         g.want_feature(gensec.FEATURE_DCE_STYLE)
4060         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
4061         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
4062         auth_context_id = 2
4063         g.start_mech_by_authtype(auth_type, auth_level)
4064         from_server = b""
4065         (finished, to_server) = g.update(from_server)
4066         self.assertFalse(finished)
4067
4068         auth_info = self.generate_auth(auth_type=auth_type,
4069                                        auth_level=auth_level,
4070                                        auth_context_id=auth_context_id,
4071                                        auth_blob=to_server)
4072
4073         req = self.generate_bind(call_id=0,
4074                                  ctx_list=ctx_list,
4075                                  auth_info=auth_info)
4076         req_pdu = samba.ndr.ndr_pack(req)
4077
4078         auth_pad_ok = len(req_pdu)
4079         auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
4080         auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4081         auth_pad_ok -= len(to_server)
4082         auth_pad_bad = auth_pad_ok + 1
4083         auth_info = self.generate_auth(auth_type=auth_type,
4084                                        auth_level=auth_level,
4085                                        auth_context_id=auth_context_id,
4086                                        auth_pad_length=auth_pad_bad,
4087                                        auth_blob=to_server)
4088
4089         req = self.generate_bind(call_id=0,
4090                                  ctx_list=ctx_list,
4091                                  auth_info=auth_info)
4092         self.send_pdu(req)
4093         rep = self.recv_pdu()
4094         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
4095                         auth_length=0)
4096         self.assertEquals(rep.u.reject_reason,
4097                           dcerpc.DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED)
4098         self.assertEquals(rep.u.num_versions, 1)
4099         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
4100         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
4101         self.assertEquals(len(rep.u._pad), 3)
4102         self.assertEquals(rep.u._pad, b'\0' * 3)
4103
4104         # wait for a disconnect
4105         rep = self.recv_pdu()
4106         self.assertIsNone(rep)
4107         self.assertNotConnected()
4108
4109     def test_spnego_auth_pad_fail_alter(self):
4110         ndr32 = base.transfer_syntax_ndr()
4111
4112         tsf1_list = [ndr32]
4113         ctx1 = dcerpc.ctx_list()
4114         ctx1.context_id = 1
4115         ctx1.num_transfer_syntaxes = len(tsf1_list)
4116         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
4117         ctx1.transfer_syntaxes = tsf1_list
4118         ctx_list = [ctx1]
4119
4120         c = self.get_anon_creds()
4121         g = gensec.Security.start_client(self.settings)
4122         g.set_credentials(c)
4123         g.want_feature(gensec.FEATURE_DCE_STYLE)
4124         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
4125         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
4126         auth_context_id = 2
4127         g.start_mech_by_authtype(auth_type, auth_level)
4128         from_server = b""
4129         (finished, to_server) = g.update(from_server)
4130         self.assertFalse(finished)
4131
4132         auth_info = self.generate_auth(auth_type=auth_type,
4133                                        auth_level=auth_level,
4134                                        auth_context_id=auth_context_id,
4135                                        auth_blob=to_server)
4136
4137         req = self.generate_bind(call_id=0,
4138                                  ctx_list=ctx_list,
4139                                  auth_info=auth_info)
4140         req_pdu = samba.ndr.ndr_pack(req)
4141
4142         auth_pad_ok = len(req_pdu)
4143         auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
4144         auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4145         auth_pad_ok -= len(to_server)
4146
4147         auth_info = self.generate_auth(auth_type=auth_type,
4148                                        auth_level=auth_level,
4149                                        auth_context_id=auth_context_id,
4150                                        auth_pad_length=auth_pad_ok,
4151                                        auth_blob=to_server)
4152
4153         req = self.generate_bind(call_id=0,
4154                                  ctx_list=ctx_list,
4155                                  auth_info=auth_info)
4156         self.send_pdu(req)
4157         rep = self.recv_pdu()
4158         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
4159         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
4160         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
4161         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
4162         self.assertEquals(rep.u.secondary_address_size, 4)
4163         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
4164         self.assertEquals(len(rep.u._pad1), 2)
4165         #self.assertEquals(rep.u._pad1, '\0' * 2)
4166         self.assertEquals(rep.u.num_results, 1)
4167         self.assertEquals(rep.u.ctx_list[0].result,
4168                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
4169         self.assertEquals(rep.u.ctx_list[0].reason,
4170                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
4171         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
4172         self.assertNotEquals(len(rep.u.auth_info), 0)
4173         a = self.parse_auth(rep.u.auth_info)
4174
4175         from_server = a.credentials
4176         (finished, to_server) = g.update(from_server)
4177         self.assertFalse(finished)
4178
4179         auth_info = self.generate_auth(auth_type=auth_type,
4180                                        auth_level=auth_level,
4181                                        auth_context_id=auth_context_id,
4182                                        auth_blob=to_server)
4183         req = self.generate_alter(call_id=0,
4184                                   ctx_list=ctx_list,
4185                                   assoc_group_id=rep.u.assoc_group_id,
4186                                   auth_info=auth_info)
4187         req_pdu = samba.ndr.ndr_pack(req)
4188
4189         auth_pad_ok = len(req_pdu)
4190         auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
4191         auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4192         auth_pad_ok -= len(to_server)
4193         auth_pad_bad = auth_pad_ok + 1
4194         auth_info = self.generate_auth(auth_type=auth_type,
4195                                        auth_level=auth_level,
4196                                        auth_context_id=auth_context_id,
4197                                        auth_pad_length=auth_pad_bad,
4198                                        auth_blob=to_server)
4199         req = self.generate_alter(call_id=0,
4200                                   ctx_list=ctx_list,
4201                                   assoc_group_id=rep.u.assoc_group_id,
4202                                   auth_info=auth_info)
4203         self.send_pdu(req)
4204         rep = self.recv_pdu()
4205         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
4206                         pfc_flags=req.pfc_flags |
4207                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
4208                         auth_length=0)
4209         self.assertNotEquals(rep.u.alloc_hint, 0)
4210         self.assertEquals(rep.u.context_id, 0)
4211         self.assertEquals(rep.u.cancel_count, 0)
4212         self.assertEquals(rep.u.flags, 0)
4213         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
4214         self.assertEquals(rep.u.reserved, 0)
4215         self.assertEquals(len(rep.u.error_and_verifier), 0)
4216
4217         # wait for a disconnect
4218         rep = self.recv_pdu()
4219         self.assertIsNone(rep)
4220         self.assertNotConnected()
4221
4222     def test_ntlmssp_auth_pad_ok(self):
4223         ndr32 = base.transfer_syntax_ndr()
4224
4225         tsf1_list = [ndr32]
4226         ctx1 = dcerpc.ctx_list()
4227         ctx1.context_id = 1
4228         ctx1.num_transfer_syntaxes = len(tsf1_list)
4229         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
4230         ctx1.transfer_syntaxes = tsf1_list
4231         ctx_list = [ctx1]
4232
4233         c = self.get_anon_creds()
4234         g = gensec.Security.start_client(self.settings)
4235         g.set_credentials(c)
4236         g.want_feature(gensec.FEATURE_DCE_STYLE)
4237         auth_type = dcerpc.DCERPC_AUTH_TYPE_NTLMSSP
4238         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
4239         auth_context_id = 2
4240         g.start_mech_by_authtype(auth_type, auth_level)
4241         from_server = b""
4242         (finished, to_server) = g.update(from_server)
4243         self.assertFalse(finished)
4244
4245         auth_info = self.generate_auth(auth_type=auth_type,
4246                                        auth_level=auth_level,
4247                                        auth_context_id=auth_context_id,
4248                                        auth_blob=to_server)
4249
4250         req = self.generate_bind(call_id=0,
4251                                  ctx_list=ctx_list,
4252                                  auth_info=auth_info)
4253         req_pdu = samba.ndr.ndr_pack(req)
4254
4255         auth_pad_ok = len(req_pdu)
4256         auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
4257         auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4258         auth_pad_ok -= len(to_server)
4259
4260         auth_info = self.generate_auth(auth_type=auth_type,
4261                                        auth_level=auth_level,
4262                                        auth_context_id=auth_context_id,
4263                                        auth_pad_length=auth_pad_ok,
4264                                        auth_blob=to_server)
4265
4266         req = self.generate_bind(call_id=0,
4267                                  ctx_list=ctx_list,
4268                                  auth_info=auth_info)
4269         self.send_pdu(req)
4270         rep = self.recv_pdu()
4271         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
4272         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
4273         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
4274         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
4275         self.assertEquals(rep.u.secondary_address_size, 4)
4276         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
4277         self.assertEquals(len(rep.u._pad1), 2)
4278         #self.assertEquals(rep.u._pad1, '\0' * 2)
4279         self.assertEquals(rep.u.num_results, 1)
4280         self.assertEquals(rep.u.ctx_list[0].result,
4281                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
4282         self.assertEquals(rep.u.ctx_list[0].reason,
4283                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
4284         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
4285         self.assertNotEquals(len(rep.u.auth_info), 0)
4286         a = self.parse_auth(rep.u.auth_info)
4287
4288         from_server = a.credentials
4289         (finished, to_server) = g.update(from_server)
4290         self.assertTrue(finished)
4291
4292         auth_pad_ok = 0
4293         auth_info = self.generate_auth(auth_type=auth_type,
4294                                        auth_level=auth_level,
4295                                        auth_context_id=auth_context_id,
4296                                        auth_pad_length=auth_pad_ok,
4297                                        auth_blob=to_server)
4298         req = self.generate_auth3(call_id=0,
4299                                   auth_info=auth_info)
4300         self.send_pdu(req)
4301         self.assertIsConnected()
4302
4303         # And now try a request without auth_info
4304         req = self.generate_request(call_id=2,
4305                                     context_id=ctx1.context_id,
4306                                     opnum=0,
4307                                     stub=b"")
4308         self.send_pdu(req)
4309         rep = self.recv_pdu()
4310         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
4311                         auth_length=0)
4312         self.assertNotEquals(rep.u.alloc_hint, 0)
4313         self.assertEquals(rep.u.context_id, req.u.context_id)
4314         self.assertEquals(rep.u.cancel_count, 0)
4315         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
4316
4317         # Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
4318         auth_info = self.generate_auth(auth_type=auth_type,
4319                                        auth_level=auth_level,
4320                                        auth_context_id=auth_context_id,
4321                                        auth_blob=b"\x01" + b"\x00" * 15)
4322         req = self.generate_request(call_id=3,
4323                                     context_id=ctx1.context_id,
4324                                     opnum=0,
4325                                     stub=b"",
4326                                     auth_info=auth_info)
4327         self.send_pdu(req)
4328         rep = self.recv_pdu()
4329         # We don't get an auth_info back
4330         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
4331                         auth_length=0)
4332         self.assertNotEquals(rep.u.alloc_hint, 0)
4333         self.assertEquals(rep.u.context_id, req.u.context_id)
4334         self.assertEquals(rep.u.cancel_count, 0)
4335         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
4336
4337         self._disconnect("disconnect")
4338         self.assertNotConnected()
4339
4340     def test_ntlmssp_auth_pad_fail_auth3(self):
4341         ndr32 = base.transfer_syntax_ndr()
4342
4343         tsf1_list = [ndr32]
4344         ctx1 = dcerpc.ctx_list()
4345         ctx1.context_id = 1
4346         ctx1.num_transfer_syntaxes = len(tsf1_list)
4347         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
4348         ctx1.transfer_syntaxes = tsf1_list
4349         ctx_list = [ctx1]
4350
4351         c = self.get_anon_creds()
4352         g = gensec.Security.start_client(self.settings)
4353         g.set_credentials(c)
4354         g.want_feature(gensec.FEATURE_DCE_STYLE)
4355         auth_type = dcerpc.DCERPC_AUTH_TYPE_NTLMSSP
4356         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
4357         auth_context_id = 2
4358         g.start_mech_by_authtype(auth_type, auth_level)
4359         from_server = b""
4360         (finished, to_server) = g.update(from_server)
4361         self.assertFalse(finished)
4362
4363         auth_info = self.generate_auth(auth_type=auth_type,
4364                                        auth_level=auth_level,
4365                                        auth_context_id=auth_context_id,
4366                                        auth_blob=to_server)
4367
4368         req = self.generate_bind(call_id=0,
4369                                  ctx_list=ctx_list,
4370                                  auth_info=auth_info)
4371         req_pdu = samba.ndr.ndr_pack(req)
4372
4373         auth_pad_ok = len(req_pdu)
4374         auth_pad_ok -= dcerpc.DCERPC_REQUEST_LENGTH
4375         auth_pad_ok -= dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4376         auth_pad_ok -= len(to_server)
4377
4378         auth_info = self.generate_auth(auth_type=auth_type,
4379                                        auth_level=auth_level,
4380                                        auth_context_id=auth_context_id,
4381                                        auth_pad_length=auth_pad_ok,
4382                                        auth_blob=to_server)
4383
4384         req = self.generate_bind(call_id=0,
4385                                  ctx_list=ctx_list,
4386                                  auth_info=auth_info)
4387         self.send_pdu(req)
4388         rep = self.recv_pdu()
4389         self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
4390         self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
4391         self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
4392         self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
4393         self.assertEquals(rep.u.secondary_address_size, 4)
4394         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
4395         self.assertEquals(len(rep.u._pad1), 2)
4396         #self.assertEquals(rep.u._pad1, '\0' * 2)
4397         self.assertEquals(rep.u.num_results, 1)
4398         self.assertEquals(rep.u.ctx_list[0].result,
4399                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
4400         self.assertEquals(rep.u.ctx_list[0].reason,
4401                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
4402         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
4403         self.assertNotEquals(len(rep.u.auth_info), 0)
4404         a = self.parse_auth(rep.u.auth_info)
4405
4406         from_server = a.credentials
4407         (finished, to_server) = g.update(from_server)
4408         self.assertTrue(finished)
4409
4410         auth_pad_bad = 1
4411         auth_info = self.generate_auth(auth_type=auth_type,
4412                                        auth_level=auth_level,
4413                                        auth_context_id=auth_context_id,
4414                                        auth_pad_length=auth_pad_bad,
4415                                        auth_blob=to_server)
4416         req = self.generate_auth3(call_id=0,
4417                                   auth_info=auth_info)
4418         self.send_pdu(req)
4419         rep = self.recv_pdu()
4420         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
4421                         pfc_flags=req.pfc_flags |
4422                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
4423                         auth_length=0)
4424         self.assertNotEquals(rep.u.alloc_hint, 0)
4425         self.assertEquals(rep.u.context_id, 0)
4426         self.assertEquals(rep.u.cancel_count, 0)
4427         self.assertEquals(rep.u.flags, 0)
4428         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY)
4429         self.assertEquals(rep.u.reserved, 0)
4430         self.assertEquals(len(rep.u.error_and_verifier), 0)
4431
4432         # wait for a disconnect
4433         rep = self.recv_pdu()
4434         self.assertIsNone(rep)
4435         self.assertNotConnected()
4436
4437     def _test_spnego_bind_auth_level(self, auth_level, auth_context_id, ctx,
4438                                      g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
4439                                      alter_fault=None):
4440         creds = self.get_user_creds()
4441         auth_context = self.get_auth_context_creds(creds=creds,
4442                                                    auth_type=dcerpc.DCERPC_AUTH_TYPE_SPNEGO,
4443                                                    auth_level=auth_level,
4444                                                    auth_context_id=auth_context_id,
4445                                                    g_auth_level=g_auth_level)
4446         if auth_context is None:
4447             return None
4448         ack = self.do_generic_bind(ctx=ctx,
4449                                    auth_context=auth_context,
4450                                    alter_fault=alter_fault)
4451         if ack is None:
4452             return None
4453         return auth_context["gensec"]
4454
4455     def _test_spnego_level_bind_nak(self, auth_level,
4456                                     reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_CHECKSUM):
4457         c = self.get_user_creds()
4458         return self._test_auth_type_level_bind_nak(auth_type=dcerpc.DCERPC_AUTH_TYPE_SPNEGO,
4459                                                    auth_level=auth_level, creds=c, reason=reason)
4460
4461     def _test_spnego_level_bind(self, auth_level,
4462                                 g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
4463                                 alter_fault=None,
4464                                 request_fault=None,
4465                                 response_fault_flags=0):
4466         ndr32 = base.transfer_syntax_ndr()
4467
4468         tsf1_list = [ndr32]
4469         ctx1 = dcerpc.ctx_list()
4470         ctx1.context_id = 0x1001
4471         ctx1.num_transfer_syntaxes = len(tsf1_list)
4472         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
4473         ctx1.transfer_syntaxes = tsf1_list
4474
4475         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
4476         auth_context_id = 2
4477
4478         g = self._test_spnego_bind_auth_level(auth_level=auth_level,
4479                                               auth_context_id=auth_context_id,
4480                                               ctx=ctx1,
4481                                               g_auth_level=g_auth_level,
4482                                               alter_fault=alter_fault)
4483
4484         if request_fault is None:
4485             return
4486
4487         self.assertIsNotNone(g)
4488
4489         stub_bin = b'\x00' * 17
4490         mod_len = len(stub_bin) % dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
4491         auth_pad_length = 0
4492         if mod_len > 0:
4493             auth_pad_length = dcerpc.DCERPC_AUTH_PAD_ALIGNMENT - mod_len
4494         stub_bin += b'\x00' * auth_pad_length
4495
4496         if g_auth_level >= dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY:
4497             sig_size = g.sig_size(len(stub_bin))
4498         else:
4499             sig_size = 16
4500         zero_sig = b"\x00" * sig_size
4501
4502         auth_info = self.generate_auth(auth_type=auth_type,
4503                                        auth_level=auth_level,
4504                                        auth_pad_length=auth_pad_length,
4505                                        auth_context_id=auth_context_id,
4506                                        auth_blob=zero_sig)
4507         req = self.generate_request(call_id=4,
4508                                     context_id=ctx1.context_id,
4509                                     opnum=0xffff,
4510                                     stub=stub_bin,
4511                                     auth_info=auth_info)
4512         if g_auth_level >= dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY:
4513             req_blob = samba.ndr.ndr_pack(req)
4514             ofs_stub = dcerpc.DCERPC_REQUEST_LENGTH
4515             ofs_sig = len(req_blob) - req.auth_length
4516             ofs_trailer = ofs_sig - dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4517             req_data = req_blob[ofs_stub:ofs_trailer]
4518             req_whole = req_blob[0:ofs_sig]
4519             sig = g.sign_packet(req_data, req_whole)
4520             auth_info = self.generate_auth(auth_type=auth_type,
4521                                            auth_level=auth_level,
4522                                            auth_pad_length=auth_pad_length,
4523                                            auth_context_id=auth_context_id,
4524                                            auth_blob=sig)
4525             req = self.generate_request(call_id=4,
4526                                         context_id=ctx1.context_id,
4527                                         opnum=0xffff,
4528                                         stub=stub_bin,
4529                                         auth_info=auth_info)
4530         self.send_pdu(req)
4531         rep = self.recv_pdu()
4532         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
4533                         pfc_flags=req.pfc_flags | response_fault_flags,
4534                         auth_length=0)
4535         self.assertNotEquals(rep.u.alloc_hint, 0)
4536         self.assertEquals(rep.u.context_id, ctx1.context_id)
4537         self.assertEquals(rep.u.cancel_count, 0)
4538         self.assertEquals(rep.u.flags, 0)
4539         self.assertEquals(rep.u.status, request_fault)
4540         self.assertEquals(rep.u.reserved, 0)
4541         self.assertEquals(len(rep.u.error_and_verifier), 0)
4542
4543         if response_fault_flags & dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE:
4544             return
4545
4546         # wait for a disconnect
4547         rep = self.recv_pdu()
4548         self.assertIsNone(rep)
4549         self.assertNotConnected()
4550
4551     def test_spnego_none_bind(self):
4552         return self._test_spnego_level_bind_nak(dcerpc.DCERPC_AUTH_LEVEL_NONE,
4553                                                 reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
4554
4555     def test_spnego_call_bind(self):
4556         return self._test_spnego_level_bind_nak(dcerpc.DCERPC_AUTH_LEVEL_CALL,
4557                                                 reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_CHECKSUM)
4558
4559     def test_spnego_0_bind(self):
4560         return self._test_spnego_level_bind_nak(0,
4561                                                 reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
4562
4563     def test_spnego_7_bind(self):
4564         return self._test_spnego_level_bind_nak(7,
4565                                                 reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
4566
4567     def test_spnego_255_bind(self):
4568         return self._test_spnego_level_bind_nak(255,
4569                                                 reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
4570
4571     def test_spnego_connect_bind_none(self):
4572         return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
4573                                             g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT)
4574
4575     def test_spnego_connect_bind_sign(self):
4576         return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
4577                                             g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY)
4578
4579     def test_spnego_connect_bind_seal(self):
4580         return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
4581                                             g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY)
4582
4583     def test_spnego_packet_bind_none(self):
4584         # DCERPC_AUTH_LEVEL_PACKET is handled as alias of
4585         # DCERPC_AUTH_LEVEL_INTEGRITY
4586         return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_PACKET,
4587                                             g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
4588                                             request_fault=dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
4589
4590     def test_spnego_packet_bind_sign(self):
4591         # DCERPC_AUTH_LEVEL_PACKET is handled as alias of
4592         # DCERPC_AUTH_LEVEL_INTEGRITY
4593         return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_PACKET,
4594                                             g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
4595                                             request_fault=dcerpc.DCERPC_NCA_S_OP_RNG_ERROR,
4596                                             response_fault_flags=dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE)
4597
4598     def test_spnego_packet_bind_sign_privacy(self):
4599         # DCERPC_AUTH_LEVEL_PACKET is handled as alias of
4600         # DCERPC_AUTH_LEVEL_INTEGRITY
4601         return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_PACKET,
4602                                             g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
4603                                             request_fault=dcerpc.DCERPC_NCA_S_OP_RNG_ERROR,
4604                                             response_fault_flags=dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE)
4605
4606     def test_spnego_integrity_bind_none(self):
4607         return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
4608                                             g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
4609                                             request_fault=dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
4610
4611     def test_spnego_integrity_bind_sign(self):
4612         return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
4613                                             g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
4614                                             request_fault=dcerpc.DCERPC_NCA_S_OP_RNG_ERROR,
4615                                             response_fault_flags=dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE)
4616
4617     def test_spnego_integrity_bind_seal(self):
4618         return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
4619                                             g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
4620                                             request_fault=dcerpc.DCERPC_NCA_S_OP_RNG_ERROR,
4621                                             response_fault_flags=dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE)
4622
4623     def test_spnego_privacy_bind_none(self):
4624         # This fails...
4625         return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
4626                                             g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
4627                                             alter_fault=dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
4628
4629     def test_spnego_privacy_bind_sign(self):
4630         # This fails...
4631         return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
4632                                             g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
4633                                             alter_fault=dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
4634
4635     def test_spnego_privacy_bind_seal(self):
4636         return self._test_spnego_level_bind(auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY,
4637                                             g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_PRIVACY)
4638
4639     def _test_spnego_signing_auth_level_request(self, auth_level):
4640         ndr32 = base.transfer_syntax_ndr()
4641
4642         tsf1_list = [ndr32]
4643         ctx1 = dcerpc.ctx_list()
4644         ctx1.context_id = 0x1001
4645         ctx1.num_transfer_syntaxes = len(tsf1_list)
4646         ctx1.abstract_syntax = samba.dcerpc.mgmt.abstract_syntax()
4647         ctx1.transfer_syntaxes = tsf1_list
4648         ctx_list = [ctx1]
4649
4650         auth_type = dcerpc.DCERPC_AUTH_TYPE_SPNEGO
4651         auth_context_id = 2
4652
4653         g = self._test_spnego_bind_auth_level(auth_level=auth_level,
4654                                               auth_context_id=auth_context_id,
4655                                               ctx=ctx1)
4656
4657         stub_bin = b'\x00' * 0
4658         mod_len = len(stub_bin) % dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
4659         auth_pad_length = 0
4660         if mod_len > 0:
4661             auth_pad_length = dcerpc.DCERPC_AUTH_PAD_ALIGNMENT - mod_len
4662         stub_bin += b'\x00' * auth_pad_length
4663
4664         sig_size = g.sig_size(len(stub_bin))
4665         zero_sig = b"\x00" * sig_size
4666
4667         auth_info = self.generate_auth(auth_type=auth_type,
4668                                        auth_level=auth_level,
4669                                        auth_pad_length=auth_pad_length,
4670                                        auth_context_id=auth_context_id,
4671                                        auth_blob=zero_sig)
4672         req = self.generate_request(call_id=3,
4673                                     context_id=ctx1.context_id,
4674                                     opnum=0,
4675                                     stub=stub_bin,
4676                                     auth_info=auth_info)
4677         req_blob = samba.ndr.ndr_pack(req)
4678         ofs_stub = dcerpc.DCERPC_REQUEST_LENGTH
4679         ofs_sig = len(req_blob) - req.auth_length
4680         ofs_trailer = ofs_sig - dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4681         req_data = req_blob[ofs_stub:ofs_trailer]
4682         req_whole = req_blob[0:ofs_sig]
4683         sig = g.sign_packet(req_data, req_whole)
4684         auth_info = self.generate_auth(auth_type=auth_type,
4685                                        auth_level=auth_level,
4686                                        auth_pad_length=auth_pad_length,
4687                                        auth_context_id=auth_context_id,
4688                                        auth_blob=sig)
4689         req = self.generate_request(call_id=3,
4690                                     context_id=ctx1.context_id,
4691                                     opnum=0,
4692                                     stub=stub_bin,
4693                                     auth_info=auth_info)
4694         self.send_pdu(req)
4695         (rep, rep_blob) = self.recv_pdu_raw()
4696         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
4697                         auth_length=sig_size)
4698         self.assertNotEquals(rep.u.alloc_hint, 0)
4699         self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
4700         self.assertEquals(rep.u.cancel_count, 0)
4701         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
4702         self.assertEquals(rep.auth_length, sig_size)
4703
4704         ofs_stub = dcerpc.DCERPC_REQUEST_LENGTH
4705         ofs_sig = rep.frag_length - rep.auth_length
4706         ofs_trailer = ofs_sig - dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4707         rep_data = rep_blob[ofs_stub:ofs_trailer]
4708         rep_whole = rep_blob[0:ofs_sig]
4709         rep_sig = rep_blob[ofs_sig:]
4710         rep_auth_info_blob = rep_blob[ofs_trailer:]
4711
4712         rep_auth_info = self.parse_auth(rep_auth_info_blob)
4713         self.assertEquals(rep_auth_info.auth_type, auth_type)
4714         self.assertEquals(rep_auth_info.auth_level, auth_level)
4715         # mgmt_inq_if_ids() returns no fixed size results
4716         #self.assertEquals(rep_auth_info.auth_pad_length, 0)
4717         self.assertEquals(rep_auth_info.auth_reserved, 0)
4718         self.assertEquals(rep_auth_info.auth_context_id, auth_context_id)
4719         self.assertEquals(rep_auth_info.credentials, rep_sig)
4720
4721         g.check_packet(rep_data, rep_whole, rep_sig)
4722
4723         stub_bin = b'\x00' * 17
4724         mod_len = len(stub_bin) % dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
4725         auth_pad_length = 0
4726         if mod_len > 0:
4727             auth_pad_length = dcerpc.DCERPC_AUTH_PAD_ALIGNMENT - mod_len
4728         stub_bin += b'\x00' * auth_pad_length
4729
4730         sig_size = g.sig_size(len(stub_bin))
4731         zero_sig = b"\x00" * sig_size
4732
4733         auth_info = self.generate_auth(auth_type=auth_type,
4734                                        auth_level=auth_level,
4735                                        auth_pad_length=auth_pad_length,
4736                                        auth_context_id=auth_context_id,
4737                                        auth_blob=zero_sig)
4738         req = self.generate_request(call_id=4,
4739                                     context_id=ctx1.context_id,
4740                                     opnum=0xffff,
4741                                     stub=stub_bin,
4742                                     auth_info=auth_info)
4743         req_blob = samba.ndr.ndr_pack(req)
4744         ofs_stub = dcerpc.DCERPC_REQUEST_LENGTH
4745         ofs_sig = len(req_blob) - req.auth_length
4746         ofs_trailer = ofs_sig - dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4747         req_data = req_blob[ofs_stub:ofs_trailer]
4748         req_whole = req_blob[0:ofs_sig]
4749         sig = g.sign_packet(req_data, req_whole)
4750         auth_info = self.generate_auth(auth_type=auth_type,
4751                                        auth_level=auth_level,
4752                                        auth_pad_length=auth_pad_length,
4753                                        auth_context_id=auth_context_id,
4754                                        auth_blob=sig)
4755         req = self.generate_request(call_id=4,
4756                                     context_id=ctx1.context_id,
4757                                     opnum=0xffff,
4758                                     stub=stub_bin,
4759                                     auth_info=auth_info)
4760         self.send_pdu(req)
4761         rep = self.recv_pdu()
4762         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
4763                         pfc_flags=req.pfc_flags |
4764                         dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
4765                         auth_length=0)
4766         self.assertNotEquals(rep.u.alloc_hint, 0)
4767         self.assertEquals(rep.u.context_id, ctx1.context_id)
4768         self.assertEquals(rep.u.cancel_count, 0)
4769         self.assertEquals(rep.u.flags, 0)
4770         self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_OP_RNG_ERROR)
4771         self.assertEquals(rep.u.reserved, 0)
4772         self.assertEquals(len(rep.u.error_and_verifier), 0)
4773
4774         stub_bin = b'\x00' * 8
4775         mod_len = len(stub_bin) % dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
4776         auth_pad_length = 0
4777         if mod_len > 0:
4778             auth_pad_length = dcerpc.DCERPC_AUTH_PAD_ALIGNMENT - mod_len
4779         stub_bin += b'\x00' * auth_pad_length
4780
4781         sig_size = g.sig_size(len(stub_bin))
4782         zero_sig = b"\x00" * sig_size
4783
4784         auth_info = self.generate_auth(auth_type=auth_type,
4785                                        auth_level=auth_level,
4786                                        auth_pad_length=auth_pad_length,
4787                                        auth_context_id=auth_context_id,
4788                                        auth_blob=zero_sig)
4789         req = self.generate_request(call_id=5,
4790                                     context_id=ctx1.context_id,
4791                                     opnum=1,
4792                                     stub=stub_bin,
4793                                     auth_info=auth_info)
4794         req_blob = samba.ndr.ndr_pack(req)
4795         ofs_stub = dcerpc.DCERPC_REQUEST_LENGTH
4796         ofs_sig = len(req_blob) - req.auth_length
4797         ofs_trailer = ofs_sig - dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4798         req_data = req_blob[ofs_stub:ofs_trailer]
4799         req_whole = req_blob[0:ofs_sig]
4800         sig = g.sign_packet(req_data, req_whole)
4801         auth_info = self.generate_auth(auth_type=auth_type,
4802                                        auth_level=auth_level,
4803                                        auth_pad_length=auth_pad_length,
4804                                        auth_context_id=auth_context_id,
4805                                        auth_blob=sig)
4806         req = self.generate_request(call_id=5,
4807                                     context_id=ctx1.context_id,
4808                                     opnum=1,
4809                                     stub=stub_bin,
4810                                     auth_info=auth_info)
4811         self.send_pdu(req)
4812         (rep, rep_blob) = self.recv_pdu_raw()
4813         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
4814                         auth_length=sig_size)
4815         self.assertNotEquals(rep.u.alloc_hint, 0)
4816         self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
4817         self.assertEquals(rep.u.cancel_count, 0)
4818         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
4819         self.assertEquals(rep.auth_length, sig_size)
4820
4821         ofs_stub = dcerpc.DCERPC_REQUEST_LENGTH
4822         ofs_sig = rep.frag_length - rep.auth_length
4823         ofs_trailer = ofs_sig - dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4824         rep_data = rep_blob[ofs_stub:ofs_trailer]
4825         rep_whole = rep_blob[0:ofs_sig]
4826         rep_sig = rep_blob[ofs_sig:]
4827         rep_auth_info_blob = rep_blob[ofs_trailer:]
4828
4829         rep_auth_info = self.parse_auth(rep_auth_info_blob)
4830         self.assertEquals(rep_auth_info.auth_type, auth_type)
4831         self.assertEquals(rep_auth_info.auth_level, auth_level)
4832         self.assertEquals(rep_auth_info.auth_pad_length, 4)
4833         self.assertEquals(rep_auth_info.auth_reserved, 0)
4834         self.assertEquals(rep_auth_info.auth_context_id, auth_context_id)
4835         self.assertEquals(rep_auth_info.credentials, rep_sig)
4836
4837         g.check_packet(rep_data, rep_whole, rep_sig)
4838
4839         stub_bin = b'\x00' * 8
4840         mod_len = len(stub_bin) % dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
4841         auth_pad_length = 0
4842         if mod_len > 0:
4843             auth_pad_length = dcerpc.DCERPC_AUTH_PAD_ALIGNMENT - mod_len
4844         stub_bin += b'\x00' * auth_pad_length
4845
4846         sig_size = g.sig_size(len(stub_bin))
4847         zero_sig = b"\x00" * sig_size
4848
4849         auth_info = self.generate_auth(auth_type=auth_type,
4850                                        auth_level=auth_level,
4851                                        auth_pad_length=auth_pad_length,
4852                                        auth_context_id=auth_context_id,
4853                                        auth_blob=zero_sig)
4854         req = self.generate_request(call_id=6,
4855                                     context_id=ctx1.context_id,
4856                                     opnum=3,
4857                                     stub=stub_bin,
4858                                     auth_info=auth_info)
4859         req_blob = samba.ndr.ndr_pack(req)
4860         ofs_stub = dcerpc.DCERPC_REQUEST_LENGTH
4861         ofs_sig = len(req_blob) - req.auth_length
4862         ofs_trailer = ofs_sig - dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4863         req_data = req_blob[ofs_stub:ofs_trailer]
4864         req_whole = req_blob[0:ofs_sig]
4865         sig = g.sign_packet(req_data, req_whole)
4866         auth_info = self.generate_auth(auth_type=auth_type,
4867                                        auth_level=auth_level,
4868                                        auth_pad_length=auth_pad_length,
4869                                        auth_context_id=auth_context_id,
4870                                        auth_blob=sig)
4871         req = self.generate_request(call_id=6,
4872                                     context_id=ctx1.context_id,
4873                                     opnum=3,
4874                                     stub=stub_bin,
4875                                     auth_info=auth_info)
4876         self.send_pdu(req)
4877         (rep, rep_blob) = self.recv_pdu_raw()
4878         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
4879                         auth_length=sig_size)
4880         self.assertNotEquals(rep.u.alloc_hint, 0)
4881         self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
4882         self.assertEquals(rep.u.cancel_count, 0)
4883         self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
4884         self.assertEquals(rep.auth_length, sig_size)
4885
4886         ofs_stub = dcerpc.DCERPC_REQUEST_LENGTH
4887         ofs_sig = rep.frag_length - rep.auth_length
4888         ofs_trailer = ofs_sig - dcerpc.DCERPC_AUTH_TRAILER_LENGTH
4889         rep_data = rep_blob[ofs_stub:ofs_trailer]
4890         rep_whole = rep_blob[0:ofs_sig]
4891         rep_sig = rep_blob[ofs_sig:]
4892         rep_auth_info_blob = rep_blob[ofs_trailer:]
4893
4894         rep_auth_info = self.parse_auth(rep_auth_info_blob)
4895         self.assertEquals(rep_auth_info.auth_type, auth_type)
4896         self.assertEquals(rep_auth_info.auth_level, auth_level)
4897         self.assertEquals(rep_auth_info.auth_pad_length, 12)
4898         self.assertEquals(rep_auth_info.auth_reserved, 0)
4899         self.assertEquals(rep_auth_info.auth_context_id, auth_context_id)
4900         self.assertEquals(rep_auth_info.credentials, rep_sig)
4901
4902         g.check_packet(rep_data, rep_whole, rep_sig)
4903
4904     def test_spnego_signing_packet(self):
4905         # DCERPC_AUTH_LEVEL_PACKET is handled as alias of
4906         # DCERPC_AUTH_LEVEL_INTEGRITY
4907         return self._test_spnego_signing_auth_level_request(dcerpc.DCERPC_AUTH_LEVEL_PACKET)
4908
4909     def test_spnego_signing_integrity(self):
4910         return self._test_spnego_signing_auth_level_request(dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY)
4911
4912     def test_assoc_group_fail1(self):
4913         abstract = samba.dcerpc.mgmt.abstract_syntax()
4914         transfer = base.transfer_syntax_ndr()
4915
4916         tsf1_list = [transfer]
4917         ctx = samba.dcerpc.dcerpc.ctx_list()
4918         ctx.context_id = 1
4919         ctx.num_transfer_syntaxes = len(tsf1_list)
4920         ctx.abstract_syntax = abstract
4921         ctx.transfer_syntaxes = tsf1_list
4922
4923         ack = self.do_generic_bind(ctx=ctx, assoc_group_id=1,
4924                                    nak_reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
4925         return
4926
4927     def test_assoc_group_fail2(self):
4928         abstract = samba.dcerpc.mgmt.abstract_syntax()
4929         transfer = base.transfer_syntax_ndr()
4930
4931         tsf1_list = [transfer]
4932         ctx = samba.dcerpc.dcerpc.ctx_list()
4933         ctx.context_id = 1
4934         ctx.num_transfer_syntaxes = len(tsf1_list)
4935         ctx.abstract_syntax = abstract
4936         ctx.transfer_syntaxes = tsf1_list
4937
4938         ack = self.do_generic_bind(ctx=ctx)
4939
4940         self._disconnect("test_assoc_group_fail2")
4941         self.assertNotConnected()
4942         time.sleep(0.5)
4943         self.connect()
4944
4945         ack2 = self.do_generic_bind(ctx=ctx, assoc_group_id=ack.u.assoc_group_id,
4946                                     nak_reason=dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
4947         return
4948
4949     def test_assoc_group_diff1(self):
4950         abstract = samba.dcerpc.mgmt.abstract_syntax()
4951         transfer = base.transfer_syntax_ndr()
4952
4953         (ctx1, ack1) = self.prepare_presentation(abstract, transfer,
4954                                                  context_id=1, return_ack=True)
4955
4956         conn2 = self.second_connection()
4957         (ctx2, ack2) = conn2.prepare_presentation(abstract, transfer,
4958                                                   context_id=2, return_ack=True)
4959         self.assertNotEqual(ack2.u.assoc_group_id, ack1.u.assoc_group_id)
4960
4961         return
4962
4963     def test_assoc_group_ok1(self):
4964         abstract = samba.dcerpc.mgmt.abstract_syntax()
4965         transfer = base.transfer_syntax_ndr()
4966
4967         (ctx1, ack1) = self.prepare_presentation(abstract, transfer,
4968                                                  context_id=1, return_ack=True)
4969
4970         conn2 = self.second_connection()
4971         (ctx2, ack2) = conn2.prepare_presentation(abstract, transfer,
4972                                                   assoc_group_id=ack1.u.assoc_group_id,
4973                                                   context_id=2, return_ack=True)
4974
4975         inq_if_ids = samba.dcerpc.mgmt.inq_if_ids()
4976         self.do_single_request(call_id=1, ctx=ctx1, io=inq_if_ids)
4977         conn2.do_single_request(call_id=1, ctx=ctx2, io=inq_if_ids)
4978
4979         conn2.do_single_request(call_id=1, ctx=ctx1, io=inq_if_ids,
4980                                 fault_pfc_flags=(
4981                                     samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_FIRST |
4982                                     samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_LAST |
4983                                     samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE),
4984                                 fault_status=dcerpc.DCERPC_NCA_S_UNKNOWN_IF,
4985                                 fault_context_id=0)
4986
4987         self.do_single_request(call_id=1, ctx=ctx1, io=inq_if_ids)
4988         conn2.do_single_request(call_id=1, ctx=ctx2, io=inq_if_ids)
4989         return
4990
4991
4992 if __name__ == "__main__":
4993     global_ndr_print = True
4994     global_hexdump = True
4995     import unittest
4996     unittest.main()