dementor 1.0.0.dev1__tar.gz → 1.0.0.dev2__tar.gz
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of dementor might be problematic. Click here for more details.
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/PKG-INFO +1 -1
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/__init__.py +1 -1
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/config.py +1 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/loader.py +15 -6
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/http.py +6 -1
- dementor-1.0.0.dev2/dementor/protocols/msrpc/__init__.py +0 -0
- dementor-1.0.0.dev2/dementor/protocols/msrpc/dcom.py +65 -0
- dementor-1.0.0.dev2/dementor/protocols/msrpc/epm.py +72 -0
- dementor-1.0.0.dev2/dementor/protocols/msrpc/rpc.py +374 -0
- dementor-1.0.0.dev2/dementor/protocols/msrpc.py +34 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/netbios.py +4 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor.egg-info/PKG-INFO +1 -1
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor.egg-info/SOURCES.txt +9 -1
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/pyproject.toml +1 -1
- dementor-1.0.0.dev2/test/test_dcerpc.py +15 -0
- dementor-1.0.0.dev2/test/test_dcom.py +51 -0
- dementor-1.0.0.dev2/test/test_epm.py +40 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/LICENSE +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/README.md +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/__main__.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/database.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/filters.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/logger.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/paths.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/__init__.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/ftp.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/kerberos.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/ldap.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/llmnr.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/mdns.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/ntlm.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/quic.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/smb.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/smtp.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/spnego.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/servers.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/standalone.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor.egg-info/dependency_links.txt +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor.egg-info/entry_points.txt +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor.egg-info/top_level.txt +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/docs/README.pypi.md +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/setup.cfg +0 -0
|
@@ -151,6 +151,7 @@ class SessionConfig(TomlConfig):
|
|
|
151
151
|
Attribute("quic_enabled", "QUIC", True, factory=is_true),
|
|
152
152
|
Attribute("mdns_enabled", "mDNS", True, factory=is_true),
|
|
153
153
|
Attribute("http_enabled", "HTTP", True, factory=is_true),
|
|
154
|
+
Attribute("msrpc_enabled", "RPC", True, factory=is_true),
|
|
154
155
|
Attribute("extra_modules", "ExtraModules", list),
|
|
155
156
|
Attribute("workspace_path", "Workspace", DEMENTOR_PATH),
|
|
156
157
|
]
|
|
@@ -18,6 +18,7 @@
|
|
|
18
18
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
19
19
|
# SOFTWARE.
|
|
20
20
|
import argparse
|
|
21
|
+
from ntpath import isfile
|
|
21
22
|
import types
|
|
22
23
|
import os
|
|
23
24
|
import dementor
|
|
@@ -30,6 +31,10 @@ from dementor.paths import DEMENTOR_PATH
|
|
|
30
31
|
class ProtocolLoader:
|
|
31
32
|
def __init__(self) -> None:
|
|
32
33
|
self.rs_path = os.path.join(DEMENTOR_PATH, "protocols")
|
|
34
|
+
self.search_path = [
|
|
35
|
+
os.path.join(os.path.dirname(dementor.__file__), "protocols"),
|
|
36
|
+
self.rs_path,
|
|
37
|
+
]
|
|
33
38
|
|
|
34
39
|
def load_protocol(self, protocol_path: str) -> types.ModuleType:
|
|
35
40
|
loader = SourceFileLoader("protocol", protocol_path)
|
|
@@ -39,10 +44,7 @@ class ProtocolLoader:
|
|
|
39
44
|
|
|
40
45
|
def get_protocols(self, session=None):
|
|
41
46
|
protocols = {}
|
|
42
|
-
protocol_paths =
|
|
43
|
-
os.path.join(os.path.dirname(dementor.__file__), "protocols"),
|
|
44
|
-
self.rs_path,
|
|
45
|
-
]
|
|
47
|
+
protocol_paths = list(self.search_path)
|
|
46
48
|
|
|
47
49
|
if session is not None:
|
|
48
50
|
protocol_paths.extend(session.extra_modules)
|
|
@@ -51,8 +53,16 @@ class ProtocolLoader:
|
|
|
51
53
|
if not os.path.exists(path):
|
|
52
54
|
continue
|
|
53
55
|
|
|
54
|
-
|
|
56
|
+
if os.path.isfile(path):
|
|
57
|
+
if not path.endswith(".py"):
|
|
58
|
+
continue
|
|
59
|
+
|
|
60
|
+
protocol_path = path
|
|
61
|
+
name = os.path.basename(path)[:-3]
|
|
62
|
+
protocols[name] = protocol_path
|
|
63
|
+
continue
|
|
55
64
|
|
|
65
|
+
# TODO: check for directory
|
|
56
66
|
for filename in os.listdir(path):
|
|
57
67
|
if not filename.endswith(".py") or filename == "__init__.py":
|
|
58
68
|
continue
|
|
@@ -87,4 +97,3 @@ class ProtocolLoader:
|
|
|
87
97
|
return protocol.create_server_threads(session)
|
|
88
98
|
|
|
89
99
|
return []
|
|
90
|
-
|
|
@@ -208,7 +208,12 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
208
208
|
def do_OPTIONS(self):
|
|
209
209
|
# always support everything
|
|
210
210
|
self.send_response(HTTPStatus.OK)
|
|
211
|
-
self.send_header("Allow", "OPTIONS,GET,HEAD,POST,TRACE")
|
|
211
|
+
self.send_header("Allow", "OPTIONS,GET,HEAD,POST,TRACE,PROPFIND")
|
|
212
|
+
self.end_headers()
|
|
213
|
+
|
|
214
|
+
def do_HEAD(self):
|
|
215
|
+
self.send_response(HTTPStatus.OK)
|
|
216
|
+
self.send_header("Content-Length", "0")
|
|
212
217
|
self.end_headers()
|
|
213
218
|
|
|
214
219
|
def version_string(self) -> str:
|
|
File without changes
|
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
from array import array
|
|
2
|
+
from impacket.dcerpc.v5 import dcomrt, rpcrt
|
|
3
|
+
from dementor.protocols.msrpc.rpc import rev_rpc_status_codes
|
|
4
|
+
|
|
5
|
+
|
|
6
|
+
__uuid__ = [
|
|
7
|
+
"00000000-0000-0000-C000-000000000046",
|
|
8
|
+
"00000131-0000-0000-C000-000000000046",
|
|
9
|
+
"00000134-0000-0000-C000-000000000046",
|
|
10
|
+
"00000143-0000-0000-C000-000000000046",
|
|
11
|
+
"000001A0-0000-0000-C000-000000000046",
|
|
12
|
+
"18F70770-8E64-11CF-9AF1-0020AF6E72F4",
|
|
13
|
+
"4D9F4AB8-7D1C-11CF-861E-0020AF6E7C57",
|
|
14
|
+
"6050B110-CE87-4126-A114-50AEFCFC95F8",
|
|
15
|
+
"99FCFEC4-5260-101B-BBCB-00AA0021347A",
|
|
16
|
+
]
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
def handle_request(rpc, request: rpcrt.MSRPCRequestHeader, _data) -> int | str:
|
|
20
|
+
op_num = request["op_num"]
|
|
21
|
+
|
|
22
|
+
if op_num == dcomrt.ServerAlive2.opnum:
|
|
23
|
+
# build response packet with our IP in answer RR
|
|
24
|
+
alive_resp = dcomrt.ServerAlive2Response()
|
|
25
|
+
alive_resp["pComVersion"] = dcomrt.COMVERSION()
|
|
26
|
+
alive_resp["ErrorCode"] = 0
|
|
27
|
+
|
|
28
|
+
bindings = dcomrt.DUALSTRINGARRAY()
|
|
29
|
+
data_buf = array("H")
|
|
30
|
+
|
|
31
|
+
# StringBinding: current IPv4 (we could also use hostname here)
|
|
32
|
+
binding = dcomrt.STRINGBINDING()
|
|
33
|
+
binding["wTowerId"] = 0x07 # ncacn_ip_tcp
|
|
34
|
+
binding["aNetworkAddr"] = f"{rpc.config.ipv4}\x00"
|
|
35
|
+
data_buf.extend(array("H", binding.getData()))
|
|
36
|
+
|
|
37
|
+
data_buf.append(0x00) # end of string bindings
|
|
38
|
+
sec_offset = len(data_buf)
|
|
39
|
+
|
|
40
|
+
# We only support NTLM Authentication
|
|
41
|
+
binding = dcomrt.SECURITYBINDING()
|
|
42
|
+
binding["wAuthnSvc"] = rpcrt.RPC_C_AUTHN_WINNT
|
|
43
|
+
binding["aPrincName"] = "\x00"
|
|
44
|
+
binding["Reserved"] = 0xFFFF
|
|
45
|
+
data_buf.extend(array("H", binding.getData()))
|
|
46
|
+
data_buf.append(0x00) # end of security bindings
|
|
47
|
+
|
|
48
|
+
bindings["wNumEntries"] = len(data_buf)
|
|
49
|
+
bindings["wSecurityOffset"] = sec_offset
|
|
50
|
+
bindings["aStringArray"] = data_buf
|
|
51
|
+
alive_resp["ppdsaOrBindings"] = bindings
|
|
52
|
+
|
|
53
|
+
resp = rpcrt.MSRPCRespHeader()
|
|
54
|
+
resp["type"] = rpcrt.MSRPC_RESPONSE
|
|
55
|
+
resp["call_id"] = request["call_id"]
|
|
56
|
+
resp["ctx_id"] = request["ctx_id"]
|
|
57
|
+
resp["auth_data"] = b""
|
|
58
|
+
resp["flags"] = rpcrt.PFC_FIRST_FRAG | rpcrt.PFC_LAST_FRAG
|
|
59
|
+
resp["pduData"] = alive_resp.getData()
|
|
60
|
+
resp["frag_len"] = len(resp.get_packet())
|
|
61
|
+
resp["alloc_hint"] = len(resp.get_packet())
|
|
62
|
+
rpc.send(resp.getData())
|
|
63
|
+
return 0
|
|
64
|
+
|
|
65
|
+
return rev_rpc_status_codes["nca_s_unk_op"]
|
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
import socket
|
|
2
|
+
import struct
|
|
3
|
+
|
|
4
|
+
from impacket.dcerpc.v5 import epm, rpcrt
|
|
5
|
+
from dementor.protocols.msrpc.rpc import uuid_name, rev_rpc_status_codes
|
|
6
|
+
|
|
7
|
+
__uuid__ = epm.MSRPC_UUID_PORTMAP
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
def handle_request(rpc, request: rpcrt.MSRPCRequestHeader, _data) -> int | str:
|
|
11
|
+
op_num = request["op_num"]
|
|
12
|
+
if op_num == 0x03:
|
|
13
|
+
# Operation: Map (3)
|
|
14
|
+
map_req = epm.ept_map(request["pduData"])
|
|
15
|
+
map_resp = epm.ept_mapResponse()
|
|
16
|
+
map_resp["status"] = 0 # success
|
|
17
|
+
map_resp["num_towers"] = 1
|
|
18
|
+
map_resp["entry_handle"] = map_req["entry_handle"]
|
|
19
|
+
|
|
20
|
+
req_tower = epm.EPMTower(b"".join(map_req["map_tower"]["tower_octet_string"]))
|
|
21
|
+
req_floors = req_tower["Floors"]
|
|
22
|
+
resp_tower = epm.EPMTower()
|
|
23
|
+
resp_floors = []
|
|
24
|
+
|
|
25
|
+
# First floor will be the interface
|
|
26
|
+
interface = req_floors[0]["InterfaceUUID"]
|
|
27
|
+
interface += struct.pack(
|
|
28
|
+
"<HH", req_floors[0]["MajorVersion"], req_floors[0]["MinorVersion"]
|
|
29
|
+
)
|
|
30
|
+
# Second floor must map to the same syntax -> TODO
|
|
31
|
+
# Third floor MUST be TCP
|
|
32
|
+
resp_floors.extend(req_floors[:3])
|
|
33
|
+
|
|
34
|
+
epm_port = epm.EPMPortAddr()
|
|
35
|
+
epm_port["IpPort"] = rpc.rpc_config.epm_port
|
|
36
|
+
resp_floors.append(epm_port)
|
|
37
|
+
|
|
38
|
+
epm_host = epm.EPMHostAddr()
|
|
39
|
+
epm_host["Ip4addr"] = socket.inet_aton(rpc.config.ipv4)
|
|
40
|
+
resp_floors.append(epm_host)
|
|
41
|
+
|
|
42
|
+
resp_tower["NumberOfFloors"] = len(resp_floors)
|
|
43
|
+
resp_tower["Floors"] = b"".join([i.getData() for i in resp_floors])
|
|
44
|
+
|
|
45
|
+
resp_tower_data = epm.twr_p_t()
|
|
46
|
+
resp_tower_data["tower_octet_string"] = resp_tower.getData()
|
|
47
|
+
resp_tower_data["tower_length"] = len(resp_tower_data["tower_octet_string"])
|
|
48
|
+
resp_tower_data["ReferentID"] = 3
|
|
49
|
+
|
|
50
|
+
# NOTE: impacket automatically sets "MaximumCount" to 1, which causes connections
|
|
51
|
+
# to fail with Windows systems. We should use 4 (default) or the number mentioned
|
|
52
|
+
# in the request.
|
|
53
|
+
resp_towers = epm.twr_p_t_array()
|
|
54
|
+
resp_towers["Data"] = [resp_tower_data]
|
|
55
|
+
resp_towers["ActualCount"] = 1
|
|
56
|
+
resp_towers["MaximumCount"] = 4
|
|
57
|
+
map_resp["ITowers"] = resp_towers
|
|
58
|
+
rpc.logger.display(f"Map request for [b]{uuid_name(interface)}[/]")
|
|
59
|
+
|
|
60
|
+
resp = rpcrt.MSRPCRespHeader()
|
|
61
|
+
resp["type"] = rpcrt.MSRPC_RESPONSE
|
|
62
|
+
resp["call_id"] = request["call_id"]
|
|
63
|
+
resp["ctx_id"] = request["ctx_id"]
|
|
64
|
+
resp["auth_data"] = b""
|
|
65
|
+
resp["flags"] = rpcrt.PFC_FIRST_FRAG | rpcrt.PFC_LAST_FRAG
|
|
66
|
+
resp["pduData"] = map_resp.getData()
|
|
67
|
+
resp["frag_len"] = len(resp.get_packet())
|
|
68
|
+
resp["alloc_hint"] = len(resp.get_packet())
|
|
69
|
+
rpc.send(resp.get_packet())
|
|
70
|
+
return 0
|
|
71
|
+
|
|
72
|
+
return rev_rpc_status_codes["nca_s_unk_op"]
|
|
@@ -0,0 +1,374 @@
|
|
|
1
|
+
import os
|
|
2
|
+
import struct
|
|
3
|
+
import random
|
|
4
|
+
import threading
|
|
5
|
+
|
|
6
|
+
from collections import defaultdict
|
|
7
|
+
from typing import Any, Callable
|
|
8
|
+
from dataclasses import dataclass
|
|
9
|
+
|
|
10
|
+
from impacket.dcerpc.v5 import rpcrt, epm
|
|
11
|
+
from impacket import ntlm
|
|
12
|
+
|
|
13
|
+
from dementor.config import Attribute as A, TomlConfig, is_true
|
|
14
|
+
from dementor.logger import ProtocolLogger, dm_logger
|
|
15
|
+
from dementor.protocols.ntlm import (
|
|
16
|
+
NTLM_AUTH_CreateChallenge,
|
|
17
|
+
NTLM_AUTH_decode_string,
|
|
18
|
+
NTLM_AUTH_to_hashcat_format,
|
|
19
|
+
NTLM_split_fqdn,
|
|
20
|
+
)
|
|
21
|
+
from dementor.servers import ThreadingTCPServer, BaseProtoHandler
|
|
22
|
+
from dementor.loader import ProtocolLoader
|
|
23
|
+
|
|
24
|
+
rev_rpc_status_codes = {name: value for value, name in rpcrt.rpc_status_codes.items()}
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
def uuid_name(uuid_bin: bytes) -> str:
|
|
28
|
+
uuid_str, version = rpcrt.bin_to_uuidtup(uuid_bin)
|
|
29
|
+
if uuid_bin == epm.MSRPC_UUID_PORTMAP:
|
|
30
|
+
return f"EPMv4 v{version}"
|
|
31
|
+
elif uuid_str in epm.KNOWN_PROTOCOLS:
|
|
32
|
+
return f"{epm.KNOWN_PROTOCOLS[uuid_str]} v{version}"
|
|
33
|
+
elif uuid_bin in epm.KNOWN_UUIDS:
|
|
34
|
+
return f"{epm.KNOWN_UUIDS[uuid_bin]} v{version}"
|
|
35
|
+
else:
|
|
36
|
+
return f"UUID {uuid_str} v{version}"
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
class RPCConfig(TomlConfig):
|
|
40
|
+
_section_ = "RPC"
|
|
41
|
+
_fields_ = [
|
|
42
|
+
A("rpc_ntlm_challenge", "NTLM.Challenge", b"A" * 8),
|
|
43
|
+
A("rpc_fqdn", "FQDN", "DEMENTOR", section_local=False),
|
|
44
|
+
A("rpc_ntlm_ess", "NTLM.ExtendedSessionSecurity", True, factory=is_true),
|
|
45
|
+
A("epm_port", "EPM.TargetPort", 49000),
|
|
46
|
+
A("epm_port_range", "EPM.TargetPortRange", None),
|
|
47
|
+
A("rpc_modules", "Interfaces", list),
|
|
48
|
+
A("rpc_error_code", "ErrorCode", "rpc_s_access_denied"),
|
|
49
|
+
]
|
|
50
|
+
|
|
51
|
+
def set_rcp_error_code(self, value: str | int):
|
|
52
|
+
if isinstance(value, str):
|
|
53
|
+
value = rev_rpc_status_codes[value]
|
|
54
|
+
|
|
55
|
+
if not isinstance(value, int):
|
|
56
|
+
dm_logger.error(
|
|
57
|
+
f"Invalid RPC error code: {value} - using default: rpc_s_access_denied"
|
|
58
|
+
)
|
|
59
|
+
value = rev_rpc_status_codes["rpc_s_access_denied"]
|
|
60
|
+
|
|
61
|
+
self.rpc_error_code = value
|
|
62
|
+
|
|
63
|
+
def set_epm_port_range(self, value: str | dict):
|
|
64
|
+
start = end = None
|
|
65
|
+
match value:
|
|
66
|
+
case dict():
|
|
67
|
+
# must store START and END
|
|
68
|
+
start = value.get("start", 45000)
|
|
69
|
+
end = value.get("end", 49999)
|
|
70
|
+
|
|
71
|
+
case str():
|
|
72
|
+
# format [START]-END or START-[END]
|
|
73
|
+
values = value.split("-")
|
|
74
|
+
if len(values) == 2:
|
|
75
|
+
start = values[0] or 45000
|
|
76
|
+
end = values[1] or 49999
|
|
77
|
+
|
|
78
|
+
self.epm_port_range = None
|
|
79
|
+
if start is not None and end is not None:
|
|
80
|
+
if isinstance(start, str):
|
|
81
|
+
start = int(start)
|
|
82
|
+
|
|
83
|
+
if isinstance(end, str):
|
|
84
|
+
end = int(end)
|
|
85
|
+
|
|
86
|
+
self.epm_port_range = (start, end)
|
|
87
|
+
self.epm_port = random.randrange(start, end)
|
|
88
|
+
|
|
89
|
+
def set_rpc_modules(self, extra_paths: list):
|
|
90
|
+
loader = ProtocolLoader()
|
|
91
|
+
loader.search_path = [os.path.dirname(__file__)]
|
|
92
|
+
loader.search_path.extend(extra_paths)
|
|
93
|
+
self.rpc_modules = [
|
|
94
|
+
loader.load_protocol(path) for path in loader.get_protocols().values()
|
|
95
|
+
]
|
|
96
|
+
|
|
97
|
+
|
|
98
|
+
@dataclass(slots=True)
|
|
99
|
+
class RPCConnection:
|
|
100
|
+
call_id: int = -1
|
|
101
|
+
ctx_id: int = -1
|
|
102
|
+
auth_ctx_id: int = -1
|
|
103
|
+
challenge: ntlm.NTLMAuthChallenge | None = None
|
|
104
|
+
target: Any | None = None
|
|
105
|
+
|
|
106
|
+
|
|
107
|
+
class RPCHandler(BaseProtoHandler):
|
|
108
|
+
def __init__(self, config, request, client_address, server) -> None:
|
|
109
|
+
self.rpc_config = config.rpc_config
|
|
110
|
+
super().__init__(config, request, client_address, server)
|
|
111
|
+
|
|
112
|
+
def proto_logger(self) -> ProtocolLogger:
|
|
113
|
+
return ProtocolLogger(
|
|
114
|
+
extra={
|
|
115
|
+
"protocol": "DCE/RPC",
|
|
116
|
+
"protocol_color": "dark_violet",
|
|
117
|
+
"host": self.client_host,
|
|
118
|
+
"port": self.server.server_address[1],
|
|
119
|
+
}
|
|
120
|
+
)
|
|
121
|
+
|
|
122
|
+
def _send_fault(self, header, code):
|
|
123
|
+
packet = rpcrt.MSRPCRespHeader()
|
|
124
|
+
packet["flags"] = rpcrt.PFC_FIRST_FRAG | rpcrt.PFC_LAST_FRAG
|
|
125
|
+
packet["frag_len"] = 0
|
|
126
|
+
packet["auth_len"] = 0
|
|
127
|
+
packet["auth_data"] = b""
|
|
128
|
+
packet["call_id"] = header["call_id"]
|
|
129
|
+
packet["type"] = rpcrt.MSRPC_FAULT
|
|
130
|
+
if code:
|
|
131
|
+
packet["pduData"] = struct.pack("<LL", code, 0x00)
|
|
132
|
+
packet["frag_len"] = len(packet)
|
|
133
|
+
|
|
134
|
+
self.send(packet.get_packet())
|
|
135
|
+
|
|
136
|
+
def handle_data(self, data, transport) -> None:
|
|
137
|
+
transport.settimeout(0.3)
|
|
138
|
+
while True:
|
|
139
|
+
try:
|
|
140
|
+
data = self.recv(8192)
|
|
141
|
+
except OSError:
|
|
142
|
+
break
|
|
143
|
+
|
|
144
|
+
if not data:
|
|
145
|
+
return
|
|
146
|
+
|
|
147
|
+
header = rpcrt.MSRPCHeader(data)
|
|
148
|
+
match header["type"]:
|
|
149
|
+
case 0x00: # Request
|
|
150
|
+
code = self.handle_request(data)
|
|
151
|
+
case 0x0B: # BIND
|
|
152
|
+
bind_req = rpcrt.MSRPCBind(header["pduData"])
|
|
153
|
+
code = self.handle_bind(header, bind_req)
|
|
154
|
+
case 0x10: # AUTH3
|
|
155
|
+
code = self.handle_auth3(header)
|
|
156
|
+
case _:
|
|
157
|
+
code = rev_rpc_status_codes["rpc_fault_cant_perform"]
|
|
158
|
+
|
|
159
|
+
if isinstance(code, str):
|
|
160
|
+
code = rev_rpc_status_codes[code]
|
|
161
|
+
|
|
162
|
+
if code != 0:
|
|
163
|
+
self.server.rem_conn_by_call_id(header["call_id"])
|
|
164
|
+
self._send_fault(header, code)
|
|
165
|
+
break
|
|
166
|
+
|
|
167
|
+
def handle_bind(
|
|
168
|
+
self, header: rpcrt.MSRPCHeader, bind_req: rpcrt.MSRPCBind
|
|
169
|
+
) -> str | int:
|
|
170
|
+
syntax = ("8a885d04-1ceb-11c9-9fe8-08002b104860", "2.0")
|
|
171
|
+
bind_ack = rpcrt.MSRPCBindAck()
|
|
172
|
+
|
|
173
|
+
bind_ack["type"] = rpcrt.MSRPC_BINDACK
|
|
174
|
+
bind_ack["flags"] = rpcrt.PFC_FIRST_FRAG | rpcrt.PFC_LAST_FRAG
|
|
175
|
+
bind_ack["frag_len"] = 0
|
|
176
|
+
bind_ack["auth_len"] = 0
|
|
177
|
+
bind_ack["auth_data"] = b""
|
|
178
|
+
bind_ack["call_id"] = header["call_id"]
|
|
179
|
+
bind_ack["max_tfrag"] = bind_req["max_tfrag"]
|
|
180
|
+
bind_ack["max_rfrag"] = bind_req["max_rfrag"]
|
|
181
|
+
bind_ack["assoc_group"] = 0x0CC5
|
|
182
|
+
bind_ack["ctx_num"] = 0
|
|
183
|
+
bind_ack["SecondaryAddrLen"] = 0
|
|
184
|
+
|
|
185
|
+
ctx_items = []
|
|
186
|
+
data = bind_req["ctx_items"]
|
|
187
|
+
conn = self.server.get_conn_by_call_id(header["call_id"])
|
|
188
|
+
endpoints = set()
|
|
189
|
+
for _ in range(bind_req["ctx_num"]):
|
|
190
|
+
result = rpcrt.MSRPC_CONT_RESULT_PROV_REJECT
|
|
191
|
+
ctx_item = rpcrt.CtxItem(data)
|
|
192
|
+
item_result = rpcrt.CtxItemResult()
|
|
193
|
+
data = data[len(ctx_item) :]
|
|
194
|
+
|
|
195
|
+
# The syntax must be checked. It will be one of the first entries
|
|
196
|
+
# -> We have to select the right one
|
|
197
|
+
if ctx_item["TransferSyntax"] == rpcrt.uuidtup_to_bin(syntax):
|
|
198
|
+
# accepted, regardless of the abstract syntax (WE WANT TO CATCH 'EM ALL)
|
|
199
|
+
reason = 0
|
|
200
|
+
result = rpcrt.MSRPC_CONT_RESULT_ACCEPT
|
|
201
|
+
bind_ack["SecondaryAddr"] = "135" # send to the same port
|
|
202
|
+
bind_ack["SecondaryAddrLen"] = 4
|
|
203
|
+
item_result["TransferSyntax"] = rpcrt.uuidtup_to_bin(syntax)
|
|
204
|
+
else:
|
|
205
|
+
reason = 2 # transfer syntax not supported
|
|
206
|
+
item_result["TransferSyntax"] = bytes(16)
|
|
207
|
+
|
|
208
|
+
abstract_syntax = ctx_item["AbstractSyntax"]
|
|
209
|
+
endpoints.add(uuid_name(abstract_syntax))
|
|
210
|
+
conn.target = self.server.get_handler_by_uuid(abstract_syntax)
|
|
211
|
+
|
|
212
|
+
bind_ack["ctx_num"] += 1
|
|
213
|
+
item_result["Result"] = result
|
|
214
|
+
item_result["Reason"] = reason
|
|
215
|
+
ctx_items.append(item_result)
|
|
216
|
+
|
|
217
|
+
bind_ack["Pad"] = "A" * (
|
|
218
|
+
4 - ((bind_ack["SecondaryAddrLen"] + bind_ack._SIZE) % 4)
|
|
219
|
+
)
|
|
220
|
+
bind_ack["ctx_items"] = b"".join([i.getData() for i in ctx_items])
|
|
221
|
+
|
|
222
|
+
endpoints_fmt = ", ".join({f"[b]{e}[/b]" for e in endpoints})
|
|
223
|
+
# handle AUTH data if present
|
|
224
|
+
if header["sec_trailer"]:
|
|
225
|
+
sec_trailer = rpcrt.SEC_TRAILER(header["sec_trailer"])
|
|
226
|
+
auth_type = sec_trailer["auth_type"]
|
|
227
|
+
if auth_type != rpcrt.RPC_C_AUTHN_WINNT:
|
|
228
|
+
# reject everything else
|
|
229
|
+
self.logger.display(
|
|
230
|
+
f"Rejecting Bind request for {endpoints_fmt} using AuthType: {auth_type:#x}"
|
|
231
|
+
)
|
|
232
|
+
return rev_rpc_status_codes["nca_s_unsupported_authn_level"]
|
|
233
|
+
|
|
234
|
+
token = header["auth_data"]
|
|
235
|
+
auth_ctx_id = sec_trailer["auth_ctx_id"]
|
|
236
|
+
conn.auth_ctx_id = auth_ctx_id
|
|
237
|
+
(msg_type,) = struct.unpack("<L", token[8:12])
|
|
238
|
+
if msg_type == 0x01: # NEGOTIATE
|
|
239
|
+
# generate challenge
|
|
240
|
+
negotiate = ntlm.NTLMAuthNegotiate()
|
|
241
|
+
negotiate.fromString(token)
|
|
242
|
+
challenge = NTLM_AUTH_CreateChallenge(
|
|
243
|
+
negotiate,
|
|
244
|
+
*NTLM_split_fqdn(self.rpc_config.rpc_fqdn),
|
|
245
|
+
challenge=self.rpc_config.rpc_ntlm_challenge,
|
|
246
|
+
disable_ess=not self.rpc_config.rpc_ntlm_ess,
|
|
247
|
+
)
|
|
248
|
+
bind_ack["auth_data"] = challenge.getData()
|
|
249
|
+
bind_ack["auth_len"] = len(bind_ack["auth_data"])
|
|
250
|
+
bind_ack["sec_trailer"] = sec_trailer.getData()
|
|
251
|
+
if endpoints_fmt:
|
|
252
|
+
self.logger.display(
|
|
253
|
+
f"Bind request for {endpoints_fmt} (NTLMSSP_NEGOTIATE)"
|
|
254
|
+
)
|
|
255
|
+
conn.challenge = challenge
|
|
256
|
+
else:
|
|
257
|
+
self.logger.debug(f"(NTLM) Unhandled message type: {msg_type:#x}")
|
|
258
|
+
else:
|
|
259
|
+
if endpoints_fmt:
|
|
260
|
+
self.logger.display(
|
|
261
|
+
f"Bind request for {endpoints_fmt} (TransferSyntax Negotiation)"
|
|
262
|
+
)
|
|
263
|
+
|
|
264
|
+
bind_ack["frag_len"] = len(bind_ack.getData())
|
|
265
|
+
self.send(bind_ack.getData())
|
|
266
|
+
return 0x00
|
|
267
|
+
|
|
268
|
+
def handle_auth3(self, header: rpcrt.MSRPCHeader):
|
|
269
|
+
if not header["sec_trailer"]:
|
|
270
|
+
return rev_rpc_status_codes["nca_s_unsupported_authn_level"]
|
|
271
|
+
|
|
272
|
+
sec_trailer = rpcrt.SEC_TRAILER(header["sec_trailer"])
|
|
273
|
+
auth_type = sec_trailer["auth_type"]
|
|
274
|
+
if auth_type != rpcrt.RPC_C_AUTHN_WINNT:
|
|
275
|
+
# reject everything else
|
|
276
|
+
self.logger.display(
|
|
277
|
+
f"Rejecting AUTH3 request using AuthType: {auth_type:#x}"
|
|
278
|
+
)
|
|
279
|
+
return rev_rpc_status_codes["nca_s_unsupported_authn_level"]
|
|
280
|
+
|
|
281
|
+
conn = self.server.get_conn_by_call_id(header["call_id"])
|
|
282
|
+
token = header["auth_data"]
|
|
283
|
+
if not conn.challenge:
|
|
284
|
+
# challenge not set, invalid request
|
|
285
|
+
return rev_rpc_status_codes["rpc_fault_cant_perform"] # REVISIT
|
|
286
|
+
|
|
287
|
+
auth_resp = ntlm.NTLMAuthChallengeResponse()
|
|
288
|
+
auth_resp.fromString(token)
|
|
289
|
+
flags = auth_resp["flags"]
|
|
290
|
+
hversion, hstring = NTLM_AUTH_to_hashcat_format(
|
|
291
|
+
conn.challenge["challenge"].encode(),
|
|
292
|
+
auth_resp["user_name"],
|
|
293
|
+
auth_resp["domain_name"],
|
|
294
|
+
auth_resp["lanman"],
|
|
295
|
+
auth_resp["ntlm"],
|
|
296
|
+
flags,
|
|
297
|
+
)
|
|
298
|
+
self.config.db.add_auth(
|
|
299
|
+
client=self.client_address,
|
|
300
|
+
credtype=hversion,
|
|
301
|
+
username=NTLM_AUTH_decode_string(auth_resp["user_name"], flags),
|
|
302
|
+
domain=NTLM_AUTH_decode_string(auth_resp["domain_name"], flags),
|
|
303
|
+
logger=self.logger,
|
|
304
|
+
password=hstring,
|
|
305
|
+
)
|
|
306
|
+
return self.rpc_config.rpc_error_code
|
|
307
|
+
|
|
308
|
+
def handle_request(self, data):
|
|
309
|
+
request = rpcrt.MSRPCRequestHeader(data)
|
|
310
|
+
conn = self.server.get_conn_by_call_id(request["call_id"])
|
|
311
|
+
conn.ctx_id = request["ctx_id"]
|
|
312
|
+
if not conn.target:
|
|
313
|
+
# Interface not set, we can't handle this
|
|
314
|
+
return rev_rpc_status_codes["nca_s_unk_if"]
|
|
315
|
+
|
|
316
|
+
return conn.target(self, request, data)
|
|
317
|
+
|
|
318
|
+
|
|
319
|
+
RPCEndpointHandler = Callable[[RPCHandler, rpcrt.MSRPCHeader, bytes], int]
|
|
320
|
+
|
|
321
|
+
|
|
322
|
+
class MSRPCServer(ThreadingTCPServer):
|
|
323
|
+
default_port = 135
|
|
324
|
+
default_handler_class = RPCHandler
|
|
325
|
+
service_name = "DCE/RPC"
|
|
326
|
+
|
|
327
|
+
def __init__(
|
|
328
|
+
self, config, handles=None, server_address=None, RequestHandlerClass=None
|
|
329
|
+
) -> None:
|
|
330
|
+
self.conn_data = handles or defaultdict(RPCConnection)
|
|
331
|
+
super().__init__(config, server_address, RequestHandlerClass)
|
|
332
|
+
|
|
333
|
+
def get_conn_by_call_id(self, call_id: int) -> RPCConnection:
|
|
334
|
+
with threading.Lock():
|
|
335
|
+
conn = self.conn_data[call_id]
|
|
336
|
+
if conn.call_id == -1:
|
|
337
|
+
conn.call_id = call_id
|
|
338
|
+
return conn
|
|
339
|
+
|
|
340
|
+
def get_conn_by_auth_ctx_id(self, auth_ctx_id: int) -> RPCConnection:
|
|
341
|
+
conn = next(
|
|
342
|
+
filter(lambda x: x.auth_ctx_id == auth_ctx_id, self.conn_data.values()),
|
|
343
|
+
None,
|
|
344
|
+
)
|
|
345
|
+
if conn is None:
|
|
346
|
+
conn = RPCConnection()
|
|
347
|
+
conn.auth_ctx_id = auth_ctx_id
|
|
348
|
+
self.conn_data[auth_ctx_id] = conn
|
|
349
|
+
return conn
|
|
350
|
+
|
|
351
|
+
def rem_conn_by_call_id(self, call_id: int):
|
|
352
|
+
self.conn_data.pop(call_id, None)
|
|
353
|
+
|
|
354
|
+
def _module_handler(self, module) -> RPCEndpointHandler | None:
|
|
355
|
+
func = getattr(module, "handle_request", None)
|
|
356
|
+
if func:
|
|
357
|
+
return func
|
|
358
|
+
|
|
359
|
+
handler_cls = getattr(module, "RPCEndpointHandlerClass", None)
|
|
360
|
+
if handler_cls:
|
|
361
|
+
return handler_cls()
|
|
362
|
+
|
|
363
|
+
def get_handler_by_uuid(self, uuid: bytes) -> RPCEndpointHandler | None:
|
|
364
|
+
uuid_str, _ = rpcrt.bin_to_uuidtup(uuid)
|
|
365
|
+
for module in self.config.rpc_config.rpc_modules:
|
|
366
|
+
mod_uuid = getattr(module, "__uuid__", None)
|
|
367
|
+
if mod_uuid == uuid or mod_uuid == uuid_str:
|
|
368
|
+
return self._module_handler(module)
|
|
369
|
+
|
|
370
|
+
if isinstance(mod_uuid, list):
|
|
371
|
+
if uuid in mod_uuid or uuid_str.upper() in mod_uuid:
|
|
372
|
+
return self._module_handler(module)
|
|
373
|
+
|
|
374
|
+
return None
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
from collections import defaultdict
|
|
2
|
+
from dementor.config import TomlConfig
|
|
3
|
+
from dementor.servers import ServerThread
|
|
4
|
+
from dementor.protocols.msrpc.rpc import MSRPCServer, RPCConfig, RPCConnection
|
|
5
|
+
|
|
6
|
+
|
|
7
|
+
def apply_config(session):
|
|
8
|
+
session.rpc_config = TomlConfig.build_config(RPCConfig)
|
|
9
|
+
|
|
10
|
+
for module in session.rpc_config.rpc_modules:
|
|
11
|
+
# load custom config
|
|
12
|
+
if hasattr(module, "apply_config"):
|
|
13
|
+
module.apply_config(session)
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
def create_server_threads(session):
|
|
17
|
+
addr = "::" if session.ipv6 else session.ipv4 # necessary
|
|
18
|
+
|
|
19
|
+
# connection data will be shared across both servers
|
|
20
|
+
conn_data = defaultdict(RPCConnection)
|
|
21
|
+
return [
|
|
22
|
+
ServerThread(
|
|
23
|
+
session,
|
|
24
|
+
MSRPCServer,
|
|
25
|
+
server_address=(addr, 135),
|
|
26
|
+
handles=conn_data,
|
|
27
|
+
),
|
|
28
|
+
ServerThread(
|
|
29
|
+
session,
|
|
30
|
+
MSRPCServer,
|
|
31
|
+
server_address=(addr, session.rpc_config.epm_port),
|
|
32
|
+
handles=conn_data,
|
|
33
|
+
),
|
|
34
|
+
]
|
|
@@ -97,6 +97,10 @@ class NetBiosNSPoisoner(BaseProtoHandler):
|
|
|
97
97
|
|
|
98
98
|
if header.OPCODE == 0x0:
|
|
99
99
|
# name query --> this is what we are looking for
|
|
100
|
+
if header.haslayer(netbios.NBNSNodeStatusRequest):
|
|
101
|
+
# we should handle those too
|
|
102
|
+
return
|
|
103
|
+
|
|
100
104
|
request = header[netbios.NBNSQueryRequest]
|
|
101
105
|
suffix = netbios._NETBIOS_SUFFIXES.get(
|
|
102
106
|
request.SUFFIX,
|
|
@@ -23,10 +23,18 @@ dementor/protocols/kerberos.py
|
|
|
23
23
|
dementor/protocols/ldap.py
|
|
24
24
|
dementor/protocols/llmnr.py
|
|
25
25
|
dementor/protocols/mdns.py
|
|
26
|
+
dementor/protocols/msrpc.py
|
|
26
27
|
dementor/protocols/netbios.py
|
|
27
28
|
dementor/protocols/ntlm.py
|
|
28
29
|
dementor/protocols/quic.py
|
|
29
30
|
dementor/protocols/smb.py
|
|
30
31
|
dementor/protocols/smtp.py
|
|
31
32
|
dementor/protocols/spnego.py
|
|
32
|
-
|
|
33
|
+
dementor/protocols/msrpc/__init__.py
|
|
34
|
+
dementor/protocols/msrpc/dcom.py
|
|
35
|
+
dementor/protocols/msrpc/epm.py
|
|
36
|
+
dementor/protocols/msrpc/rpc.py
|
|
37
|
+
docs/README.pypi.md
|
|
38
|
+
test/test_dcerpc.py
|
|
39
|
+
test/test_dcom.py
|
|
40
|
+
test/test_epm.py
|
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
from impacket.dcerpc.v5.rpcrt import MSRPCHeader
|
|
2
|
+
|
|
3
|
+
bind_data = bytes.fromhex(
|
|
4
|
+
"05000b0310000000a000000002000000d016d0160000000003000000000001000883afe11f5dc91191a408002b14a0fa03000000045d888aeb1cc9119fe808002b10486002000000010001000883afe11f5dc91191a408002b14a0fa0300000033057171babe37498319b5dbef9ccc3601000000020001000883afe11f5dc91191a408002b14a0fa030000002c1cb76c12984045030000000000000001000000"
|
|
5
|
+
)
|
|
6
|
+
|
|
7
|
+
local_bind_data = bytes.fromhex(
|
|
8
|
+
"05000b03100000004800000001000000b810b8100000000001000000000001000883afe11f5dc91191a408002b14a0fa03000000045d888aeb1cc9119fe808002b10486002000000"
|
|
9
|
+
)
|
|
10
|
+
|
|
11
|
+
bind_head = MSRPCHeader(bind_data)
|
|
12
|
+
print(bind_head.fields)
|
|
13
|
+
|
|
14
|
+
bind2_head = MSRPCHeader(local_bind_data)
|
|
15
|
+
print(bind2_head.fields)
|
|
@@ -0,0 +1,51 @@
|
|
|
1
|
+
import struct
|
|
2
|
+
import array
|
|
3
|
+
|
|
4
|
+
from impacket.dcerpc.v5 import dcom, rpcrt, dcomrt
|
|
5
|
+
|
|
6
|
+
# resp = dcomrt.ServerAlive2Response(bytes.fromhex("05000700000002002d0000002d00170007004400430030003100000007003100390032002e003100360038002e00350036002e00310031003500000000000900ffff00001e00ffff00001000ffff00000a00ffff00001600ffff00001f00ffff00000e00ffff0000000000000000000000000000"))
|
|
7
|
+
|
|
8
|
+
# bindings = resp["ppdsaOrBindings"]
|
|
9
|
+
# data = bindings["aStringArray"]
|
|
10
|
+
# data = array.array("H", data).tobytes()
|
|
11
|
+
# data_len = len(data)
|
|
12
|
+
# offset = 0
|
|
13
|
+
# sec_offset = bindings["wSecurityOffset"] * 2
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
# print(offset)
|
|
17
|
+
|
|
18
|
+
# for _ in range():
|
|
19
|
+
|
|
20
|
+
packet = dcomrt.ServerAlive2Response()
|
|
21
|
+
packet["pComVersion"] = dcomrt.COMVERSION()
|
|
22
|
+
packet["ErrorCode"] = 0
|
|
23
|
+
|
|
24
|
+
bindings = dcomrt.DUALSTRINGARRAY()
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
data = array.array('H')
|
|
28
|
+
# Only one stringbinding
|
|
29
|
+
binding = dcomrt.STRINGBINDING()
|
|
30
|
+
binding["wTowerId"] = 0x07 # ncacn_ip_tcp
|
|
31
|
+
binding["aNetworkAddr"] = "127.0.0.1"
|
|
32
|
+
data.extend(array.array('H', binding.getData()))
|
|
33
|
+
|
|
34
|
+
sec_offset = len(data)
|
|
35
|
+
if sec_offset % 2 != 0:
|
|
36
|
+
data.append(0x00)
|
|
37
|
+
sec_offset += 1
|
|
38
|
+
|
|
39
|
+
binding = dcomrt.SECURITYBINDING()
|
|
40
|
+
binding["wAuthnSvc"] = rpcrt.RPC_C_AUTHN_WINNT
|
|
41
|
+
binding["aPrincName"] = ""
|
|
42
|
+
binding["Reserved"] = 0xFFFF
|
|
43
|
+
data.extend(array.array('H', binding.getData()))
|
|
44
|
+
|
|
45
|
+
bindings["wNumEntries"] = len(data)
|
|
46
|
+
bindings["wSecurityOffset"] = sec_offset
|
|
47
|
+
bindings["aStringArray"] = data
|
|
48
|
+
|
|
49
|
+
packet["ppdsaOrBindings"] = bindings
|
|
50
|
+
|
|
51
|
+
print(packet.getData())
|
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
from impacket.dcerpc.v5 import epm
|
|
2
|
+
|
|
3
|
+
|
|
4
|
+
data = bytes.fromhex("0100000000000000000000000000000000000000020000004b0000004b000000050013000d81bb7a364498f135ad3298f03800100302000200000013000d045d888aeb1cc9119fe808002b10486002000200000001000b020000000100070200008701000904000000000000000000000000000000000000000000000000000004000000")
|
|
5
|
+
|
|
6
|
+
map_req = epm.ept_map(data)
|
|
7
|
+
map_resp = epm.ept_mapResponse()
|
|
8
|
+
map_resp["status"] = 0 # success
|
|
9
|
+
map_resp["num_towers"] = 1
|
|
10
|
+
map_resp["entry_handle"] = map_req["entry_handle"]
|
|
11
|
+
|
|
12
|
+
req_tower = epm.EPMTower(b"".join(map_req["map_tower"]["tower_octet_string"]))
|
|
13
|
+
req_floors = req_tower["Floors"]
|
|
14
|
+
resp_tower = epm.EPMTower()
|
|
15
|
+
resp_floors = []
|
|
16
|
+
|
|
17
|
+
# First floor will be the interface
|
|
18
|
+
interface = req_floors[0]["InterfaceUUID"]
|
|
19
|
+
# Second floor must map to the same syntax -> TODO
|
|
20
|
+
# THird floor MUST be TCP
|
|
21
|
+
resp_floors.extend(req_floors[:3])
|
|
22
|
+
|
|
23
|
+
epm_port = epm.EPMPortAddr()
|
|
24
|
+
epm_port["IpPort"] = 135# self.rpc_config.epm_port
|
|
25
|
+
resp_floors.append(epm_port)
|
|
26
|
+
|
|
27
|
+
epm_host = epm.EPMHostAddr()
|
|
28
|
+
epm_host["Ip4addr"] = "127.0.0.1" # self.config.ipv4
|
|
29
|
+
resp_floors.append(epm_host)
|
|
30
|
+
|
|
31
|
+
resp_tower["NumberOfFloors"] = len(resp_floors)
|
|
32
|
+
resp_tower["Floors"] = b"".join([i.getData() for i in resp_floors])
|
|
33
|
+
|
|
34
|
+
resp_tower_data = epm.twr_p_t()
|
|
35
|
+
resp_tower_data["tower_octet_string"] = resp_tower.getData()
|
|
36
|
+
resp_tower_data["tower_length"] = len(resp_tower_data["tower_octet_string"])
|
|
37
|
+
resp_tower_data["ReferentID"] = 2
|
|
38
|
+
|
|
39
|
+
map_resp["ITowers"] = [resp_tower_data]
|
|
40
|
+
print(map_resp.getData())
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|