atomicshop 3.3.8__py3-none-any.whl → 3.10.0__py3-none-any.whl

atomicshop/mitm/mitm_main.py

@@ -5,21 +5,31 @@ import datetime
 import os
 import sys
 import logging
+import signal
 
 import atomicshop   # Importing atomicshop package to get the version of the package.
 
 from .. import filesystem, on_exit, print_api, networks, dns
 from ..permissions import permissions
-from ..python_functions import get_current_python_version_string, check_python_version_compliance
-from ..wrappers.socketw import socket_wrapper, dns_server, base, statistics_csv
+from .. import python_functions
+from ..wrappers.socketw import socket_wrapper, dns_server, statistics_csv
 from ..wrappers.loggingw import loggingw
 from ..wrappers.ctyping import win_console
+from ..wrappers import netshw
 from ..basics import multiprocesses
 
 from .connection_thread_worker import thread_worker_main
 from . import config_static, recs_files
 
 
+# If you have 'pip-system-certs' package installed, this section overrides this behavior, since it injects
+# the ssl default behavior, which we don't need when using ssl and sockets.
+import ssl, importlib
+if getattr(ssl.SSLContext.wrap_socket, "__module__", "").startswith("pip._vendor.truststore"):
+    # Truststore injection is active; restore stdlib ssl
+    importlib.reload(ssl)
+
+
 class NetworkSettings:
     """
     Class to store network settings.
@@ -27,6 +37,7 @@ class NetworkSettings:
 
     def __init__(
             self,
+            name: str | None = None,
             description: str | None = None,
             interface_index: int | None = None,
             is_dynamic: bool = False,
@@ -37,7 +48,7 @@ class NetworkSettings:
             default_gateways: list[str] = None,
             dns_gateways: list[str] = None
     ):
-
+        self.name: str | None = name
         self.description: str | None = description
         self.interface_index: int | None = interface_index
         self.is_dynamic: bool = is_dynamic
@@ -51,8 +62,6 @@ class NetworkSettings:
 
 # Global variables for setting the network interface to external IPs (eg: 192.168.0.1)
 NETWORK_INTERFACE_SETTINGS: NetworkSettings = NetworkSettings()
-CURRENT_IPV4S: list[str] = list()
-CURRENT_IPV4_MASKS: list[str] = list()
 IPS_TO_ASSIGN: list[str] = list()
 MASKS_TO_ASSIGN: list[str] = list()
 
@@ -87,41 +96,37 @@ except win_console.NotWindowsConsoleError:
     pass
 
 
+# noinspection PyUnusedLocal
+def _graceful_shutdown(signum, frame):
+    exit_cleanup()
+
+
 def exit_cleanup():
-    if config_static.ENGINES_LIST[0].is_localhost:
-        if permissions.is_admin() and IS_SET_DNS_GATEWAY:
-            is_dns_dynamic, current_dns_gateway = dns.get_default_dns_gateway()
-            status_string = 'Dynamic' if is_dns_dynamic else 'Static'
-            print_api.print_api(f'Current DNS Gateway: {status_string}, {current_dns_gateway}')
-
-            if is_dns_dynamic != NETWORK_INTERFACE_IS_DYNAMIC or \
-                    (not is_dns_dynamic and current_dns_gateway != NETWORK_INTERFACE_IPV4_ADDRESS_LIST):
-                if NETWORK_INTERFACE_IS_DYNAMIC:
-                    dns.set_connection_dns_gateway_dynamic(use_default_connection=True)
-                else:
-                    dns.set_connection_dns_gateway_static(
-                        dns_servers=NETWORK_INTERFACE_IPV4_ADDRESS_LIST, use_default_connection=True)
-
-                print_api.print_api("Returned default DNS gateway...", color='blue')
-    else:
-        # Get current network interface state.
-        default_network_adapter_config, default_network_adapter, default_adapter_info = networks.get_wmi_network_adapter_configuration(
-            use_default_interface=True, get_info_from_network_config=True)
+    if not config_static.MainConfig.is_localhost:
+        # Remove all the virtual IPs from the interface.
+        current_virtual_ips: list[str] = networks.get_interface_ips_powershell(NETWORK_INTERFACE_SETTINGS.name, "virtual")
+        for ip in current_virtual_ips:
+            netshw.remove_virtual_ip(NETWORK_INTERFACE_SETTINGS.name, ip)
 
-        if NETWORK_INTERFACE_SETTINGS.is_dynamic:
-            # If the network interface was dynamic before the script started, we will return it to dynamic.
-            networks.set_dynamic_ip_for_adapter(default_network_adapter_config)
-        else:
-            networks.set_static_ip_for_adapter(
-                default_network_adapter,
-                ips=NETWORK_INTERFACE_SETTINGS.ipv4s,
-                masks=NETWORK_INTERFACE_SETTINGS.ipv4_subnet_masks,
-                gateways=NETWORK_INTERFACE_SETTINGS.default_gateways,
-                dns_gateways=NETWORK_INTERFACE_SETTINGS.dns_gateways
-            )
+        netshw.disable_dhcp_static_coexistence(interface_name=NETWORK_INTERFACE_SETTINGS.name)
 
         print_api.print_api("Returned network adapter settings...", color='blue')
 
+    if permissions.is_admin() and IS_SET_DNS_GATEWAY:
+        is_dns_dynamic, current_dns_gateway = dns.get_default_dns_gateway()
+        status_string = 'Dynamic' if is_dns_dynamic else 'Static'
+        print_api.print_api(f'Current DNS Gateway: {status_string}, {current_dns_gateway}')
+
+        if is_dns_dynamic != NETWORK_INTERFACE_IS_DYNAMIC or \
+                (not is_dns_dynamic and current_dns_gateway != NETWORK_INTERFACE_IPV4_ADDRESS_LIST):
+            if NETWORK_INTERFACE_IS_DYNAMIC:
+                dns.set_interface_dns_gateway_dynamic(interface_name=NETWORK_INTERFACE_SETTINGS.name)
+            else:
+                dns.set_interface_dns_gateway_static(
+                    dns_servers=NETWORK_INTERFACE_IPV4_ADDRESS_LIST, interface_name=NETWORK_INTERFACE_SETTINGS.name)
+
+            print_api.print_api("Returned default DNS gateway...", color='blue')
+
     # The process will not be executed if there was an exception in the beginning.
     if RECS_PROCESS_INSTANCE is not None:
         print_api.print_api(f'Recs archive process alive: {RECS_PROCESS_INSTANCE.is_alive()}')
@@ -148,7 +153,7 @@ def startup_output(system_logger, script_version: str):
     # Writing first log.
     system_logger.info("======================================")
     system_logger.info("Server Started.")
-    system_logger.info(f"Python Version: {get_current_python_version_string()}")
+    system_logger.info(f"Python Version: {python_functions.get_python_version_string()}")
     system_logger.info(f"Script Version: {script_version}")
     system_logger.info(f"Atomic Workshop Version: {atomicshop.__version__}")
     system_logger.info(f"Log folder: {config_static.LogRec.logs_path}")
@@ -162,7 +167,7 @@ def startup_output(system_logger, script_version: str):
             f"Default server certificate usage enabled, if no SNI available: "
             f"{config_static.MainConfig.default_server_certificate_filepath}")
 
-    if config_static.Certificates.sni_server_certificates_cache_directory:
+    if config_static.Certificates.sni_create_server_certificate_for_each_domain:
         system_logger.info(
             f"SNI function certificates creation enabled. Certificates cache: "
             f"{config_static.Certificates.sni_server_certificates_cache_directory}")
@@ -185,6 +190,7 @@ def startup_output(system_logger, script_version: str):
     # Printing the parsers using "start=1" for index to start counting from "1" and not "0"
     system_logger.info("Imported engine info.")
     print_api.print_api(f"[*] Found Engines:", logger=system_logger)
+    print_api.print_api( f"-------------------------", logger=system_logger)
 
     if not config_static.ENGINES_LIST:
         message = \
@@ -199,7 +205,6 @@ def startup_output(system_logger, script_version: str):
                    f"{engine.responder_class_object.__name__}, "
                    f"{engine.recorder_class_object.__name__}")
         print_api.print_api(message, logger=system_logger)
-        print_api.print_api(f"[*] Name: {engine.engine_name}", logger=system_logger)
         print_api.print_api(f"[*] Domains: {list(engine.domain_target_dict.keys())}", logger=system_logger)
         dns_targets: list = list()
         for domain, ip_port in engine.domain_target_dict.items():
@@ -210,9 +215,11 @@ def startup_output(system_logger, script_version: str):
             print_api.print_api(f"[*] Connect Ports to IPs: {list(engine.on_port_connect.values())}", logger=system_logger)
             print_api.print_api(f"[*] Connect Ports to IPs Targets: {list(engine.port_target_dict.values())}", logger=system_logger)
 
+        print_api.print_api("-------------------------", logger=system_logger)
+
         # print_api.print_api(f"[*] TCP Listening Interfaces: {engine.tcp_listening_address_list}", logger=system_logger)
 
-    if config_static.DNSServer.enable:
+    if config_static.DNSServer.is_enabled:
         print_api.print_api("DNS Server is enabled.", logger=system_logger)
 
         # If engines were found and dns is set to route by the engine domains.
@@ -236,13 +243,42 @@ def startup_output(system_logger, script_version: str):
     else:
         print_api.print_api("DNS Server is disabled.", logger=system_logger, color="yellow")
 
-    if config_static.TCPServer.enable:
+    if config_static.TCPServer.is_enabled:
         print_api.print_api("TCP Server is enabled.", logger=system_logger)
     else:
         print_api.print_api("TCP Server is disabled.", logger=system_logger, color="yellow")
 
+    if config_static.MainConfig.is_localhost:
+        selected_net_interface: str = config_static.MainConfig.network_interface
+    else:
+        selected_net_interface: str = NETWORK_INTERFACE_SETTINGS.name
+    print_api.print_api(f"Selected Network Interface: {selected_net_interface}", logger=system_logger)
+
+    print_api.print_api(f"Listening DNS address: {config_static.DNSServer.listening_address}", logger=system_logger)
 
-def get_ipv4s_for_tcp_server():
+
+def _get_interface_name() -> str | None:
+    if config_static.MainConfig.network_interface == '':
+        interface_name: str = networks.get_default_interface_name()
+        if interface_name == '':
+            print_api.print_api(
+                "Default network interface not found.",
+                error_type=True, color="red")
+            return None
+    else:
+        current_network_interface_names: list[str] = networks.list_network_interfaces()
+        if config_static.MainConfig.network_interface not in current_network_interface_names:
+            print_api.print_api(
+                f"Not found Network interface with the name: {config_static.MainConfig.network_interface}",
+                error_type=True, color="red")
+            return None
+        else:
+            interface_name = config_static.MainConfig.network_interface
+
+    return interface_name
+
+
+def get_ipv4s_for_tcp_server() -> int:
     """
     Function to get the IPv4 addresses for the default network adapter to set them to the adapter.
     """
@@ -255,48 +291,82 @@ def get_ipv4s_for_tcp_server():
         ports_to_create_ips_for += list(engine.on_port_connect.keys())
 
     engine_ips: list[str] = list()
-    # Check if we need the localhost ips (12.0.0.1) or external local ips (192.168.0.100).
-    if config_static.ENGINES_LIST[0].is_localhost:
-        create_ips: int = len(domains_to_create_ips_for) + len(ports_to_create_ips_for)
+    create_ips: int = len(domains_to_create_ips_for) + len(ports_to_create_ips_for)
 
-        # Generate the list of localhost ips.
-        for i in range(create_ips):
-            engine_ips.append(f"127.0.0.{i+1}")
-    else:
-        # Get current network interface state.
-        default_network_adapter_config, default_network_adapter, default_adapter_info = networks.get_wmi_network_adapter_configuration(
-            use_default_interface=True, get_info_from_network_config=True)
-
-        global NETWORK_INTERFACE_SETTINGS
-        NETWORK_INTERFACE_SETTINGS = NetworkSettings(
-            description=default_adapter_info['description'],
-            interface_index=default_adapter_info['interface_index'],
-            is_dynamic=default_adapter_info['is_dynamic'],
-            ipv4s=default_adapter_info['ipv4s'],
-            ipv6s=default_adapter_info['ipv6s'],
-            ipv4_subnet_masks=default_adapter_info['ipv4_subnet_masks'],
-            ipv6_prefixes=default_adapter_info['ipv6_prefixes'],
-            default_gateways=default_adapter_info['default_gateways'],
-            dns_gateways=default_adapter_info['dns_gateways']
-        )
+    # Get network interface name.
+    interface_name: str = _get_interface_name()
+    if interface_name is None:
+        return 1
 
-        # Adding IP addresses to the default network adapter.
-        current_ipv4s: list[str] = default_adapter_info['ipv4s']
-        current_ips_count: int = len(current_ipv4s)
+    # Get selected network interface virtual IPs from previous runs.
+    # We still need network interface settings for DNS gateway assignment for the network interface doesn't matter in localhost mode or not.
+    current_virtual_ips: list[str] = networks.get_interface_ips_powershell(interface_name, "virtual")
 
-        # If the number of currently assigned IPs is smaller than the number of IPs to create,
-        # subtract the current IPs count from the number of IPs to create, to create only what is missing.
-        create_ips: int = len(domains_to_create_ips_for)
-        if current_ips_count <= create_ips:
-            create_ips -= current_ips_count
+    if current_virtual_ips:
+        print_api.print_api(
+            f"Removing previous virtual IPs from interface [{interface_name}]: {current_virtual_ips}",
+            color="blue")
 
+        if not permissions.is_admin():
+            print_api.print_api(
+                f"Administrator permissions are required to remove virtual IPs from interface.",
+                error_type=True, color="red")
+            return 1
+    # Remove all the virtual IPs from the interface.
+    for ip in current_virtual_ips:
+        netshw.remove_virtual_ip(interface_name, ip)
+
+    network_adapter_config, network_adapter, adapter_info = networks.get_wmi_network_adapter_configuration(
+        interface_name=interface_name,
+        get_info_from_network_config=True)
+
+    global NETWORK_INTERFACE_SETTINGS
+    NETWORK_INTERFACE_SETTINGS = NetworkSettings(
+        name=adapter_info['name'],
+        description=adapter_info['description'],
+        interface_index=adapter_info['interface_index'],
+        is_dynamic=adapter_info['is_dynamic'],
+        ipv4s=adapter_info['ipv4s'],
+        ipv6s=adapter_info['ipv6s'],
+        ipv4_subnet_masks=adapter_info['ipv4_subnet_masks'],
+        ipv6_prefixes=adapter_info['ipv6_prefixes'],
+        default_gateways=adapter_info['default_gateways'],
+        dns_gateways=adapter_info['dns_gateways']
+    )
+
+    # Check if we need the localhost ips (12.0.0.1) or external local ips (192.168.0.100).
+    if config_static.MainConfig.is_localhost:
+        # Generate the list of localhost ips. We will start from 127.0.0.2 and end with 127.0.0.2(create_ips + 1)
+        for i in range(2, create_ips + 2):
+            engine_ips.append(f"127.0.0.{i}")
+
+        # If the current default DNS gateway ipv4 is inside the engine_ips, then we will remove it and add the next in line.
+        if config_static.MainConfig.default_localhost_dns_gateway_ipv4 in engine_ips:
+            engine_ips.remove(config_static.MainConfig.default_localhost_dns_gateway_ipv4)
+            engine_ips.append(f"127.0.0.{create_ips + 2}")
+
+        dns_listening_ipv4: str = config_static.MainConfig.default_localhost_dns_gateway_ipv4
+    else:
         # Generate the IPs for the domains.
-        global CURRENT_IPV4S, CURRENT_IPV4_MASKS, IPS_TO_ASSIGN, MASKS_TO_ASSIGN
-        CURRENT_IPV4S, CURRENT_IPV4_MASKS, IPS_TO_ASSIGN, MASKS_TO_ASSIGN = networks.add_virtual_ips_to_default_adapter_by_current_setting(
+        global IPS_TO_ASSIGN, MASKS_TO_ASSIGN
+        assignment_result: tuple | None = networks.add_virtual_ips_to_network_interface(
+            interface_name=interface_name,
             number_of_ips=create_ips,
             simulate_only=True)
 
-        engine_ips += CURRENT_IPV4S + IPS_TO_ASSIGN
+        if assignment_result is None:
+            return 1
+
+        IPS_TO_ASSIGN, MASKS_TO_ASSIGN = assignment_result
+
+        engine_ips += IPS_TO_ASSIGN
+        dns_listening_ipv4: str = NETWORK_INTERFACE_SETTINGS.ipv4s[0]
+
+    # Assign DNS listening address.
+    if config_static.DNSServer.listening_ipv4 != '':
+        config_static.DNSServer.listening_address = f"{config_static.DNSServer.listening_ipv4}:{str(config_static.DNSServer.listening_port)}"
+    else:
+        config_static.DNSServer.listening_address = f"{dns_listening_ipv4}:{str(config_static.DNSServer.listening_port)}"
 
     # Add the ips to engines.
     for engine in config_static.ENGINES_LIST:
@@ -309,23 +379,31 @@ def get_ipv4s_for_tcp_server():
             if port in ports_to_create_ips_for:
                 engine.port_target_dict[port]['ip'] = engine_ips.pop(0)
 
+    return 0
 
-def mitm_server(config_file_path: str, script_version: str):
+
+def mitm_server(config_file_path: str, script_version: str) -> int:
     on_exit.register_exit_handler(exit_cleanup, at_exit=False, kill_signal=False)
 
-    # Main function should return integer with error code, 0 is successful.
-    # Since listening server is infinite, this will not be reached.
-    # After modules import - we check for python version.
-    if not check_python_version_compliance(minor_version='3.12'):
+    python_version: str = python_functions.get_python_version_string()
+    print_api.print_api(f"[*] Python Version: {python_version}")
+
+    compliance_message: str | None = python_functions.check_python_version_compliance(min_ver=(3,13), max_ver=(3,13,99))
+    if compliance_message is not None:
+        print_api.print_api(f"[!] {compliance_message}", error_type=True, color="red")
         return 1
 
+    print_api.print_api("[*] Version Check PASSED.", color="green")
+
     # Import the configuration file.
-    result = config_static.load_config(config_file_path, print_kwargs=dict(stdout=False))
-    if result != 0:
-        return result
+    rc: int = config_static.load_config(config_file_path, print_kwargs=dict(stdout=False))
+    if rc != 0:
+        return rc
 
     # Get the IPs that will be set for the adapter and fill the engine configuration with the IPs.
-    get_ipv4s_for_tcp_server()
+    rc: int = get_ipv4s_for_tcp_server()
+    if rc != 0:
+        return rc
 
     global MITM_ERROR_LOGGER
     MITM_ERROR_LOGGER = loggingw.ExceptionCsvLogger(
@@ -397,7 +475,7 @@ def mitm_server(config_file_path: str, script_version: str):
     is_ready_multiprocessing_event_list: list[multiprocessing.Event] = list()
 
     # === Initialize TCP Server ====================================================================================
-    if config_static.TCPServer.enable:
+    if config_static.TCPServer.is_enabled:
         # Get the default network adapter configuration and set the one from config.
         # We set the virtual IPs in the network adapter here, so the server multiprocessing processes can listen on them.
         setting_result: int = _add_virtual_ips_set_default_dns_gateway(system_logger)
@@ -489,6 +567,8 @@ def mitm_server(config_file_path: str, script_version: str):
                 exceptions_logger_queue=EXCEPTIONS_CSV_LOGGER_QUEUE,
                 forwarding_dns_service_ipv4_list___only_for_localhost=[config_static.DNSServer.forwarding_dns_service_ipv4],
                 skip_extension_id_list=config_static.SkipExtensions.SKIP_EXTENSION_ID_LIST,
+                enable_sslkeylogfile_env_to_client_ssl_context=config_static.Certificates.enable_sslkeylogfile_env_to_client_ssl_context,
+                sslkeylog_file_path=config_static.Certificates.sslkeylog_file_path,
                 print_kwargs=dict(stdout=False)
             )
 
@@ -521,7 +601,7 @@ def mitm_server(config_file_path: str, script_version: str):
     # === EOF Initialize TCP Server ====================================================================================
 
     # === Initialize DNS module ========================================================================================
-    if config_static.DNSServer.enable:
+    if config_static.DNSServer.is_enabled:
         # noinspection PyTypeHints
         is_dns_process_ready: multiprocessing.Event = multiprocessing.Event()
 
@@ -536,7 +616,7 @@ def mitm_server(config_file_path: str, script_version: str):
             resolve_regular_pass_thru=config_static.DNSServer.resolve_regular_pass_thru,
             resolve_all_domains_to_ipv4=(
                 config_static.DNSServer.resolve_all_domains_to_ipv4_enable, config_static.DNSServer.target_ipv4),
-            offline_mode=config_static.MainConfig.offline,
+            offline_mode=config_static.MainConfig.is_offline,
             cache_timeout_minutes=config_static.DNSServer.cache_timeout_minutes,
             logging_queue=NETWORK_LOGGER_QUEUE,
             logger_name=network_logger_name,
@@ -558,7 +638,7 @@ def mitm_server(config_file_path: str, script_version: str):
             return 1
     # === EOF Initialize DNS module ====================================================================================
 
-    if config_static.DNSServer.enable or config_static.TCPServer.enable:
+    if config_static.DNSServer.is_enabled or config_static.TCPServer.is_enabled:
         print_api.print_api("The Server is Ready for Operation!", color="green", logger=system_logger)
         print_api.print_api("Press [Ctrl]+[C] to stop.", color='blue', logger=system_logger)
 
@@ -578,6 +658,8 @@ def mitm_server(config_file_path: str, script_version: str):
 
             time.sleep(1)
 
+    return 0
+
 
 # noinspection PyTypeHints
 def _create_tcp_server_process(
@@ -681,48 +763,59 @@ def _add_virtual_ips_set_default_dns_gateway(system_logger: logging.Logger) -> i
     # This setting is needed only for the dns gateways configurations from the main config on localhost.
     set_local_dns_gateway: bool = False
     # Set the default gateway if specified.
-    if config_static.DNSServer.set_default_dns_gateway:
-        dns_gateway_server_list = config_static.DNSServer.set_default_dns_gateway
+    if config_static.MainConfig.set_default_dns_gateway:
+        dns_gateway_server_list = config_static.MainConfig.set_default_dns_gateway
         set_local_dns_gateway = True
-    elif config_static.DNSServer.set_default_dns_gateway_to_localhost:
-        dns_gateway_server_list = [base.LOCALHOST_IPV4]
+    elif config_static.MainConfig.set_default_dns_gateway_to_localhost:
+        dns_gateway_server_list = [config_static.MainConfig.default_localhost_dns_gateway_ipv4]
         set_local_dns_gateway = True
-    elif config_static.DNSServer.set_default_dns_gateway_to_default_interface_ipv4:
-        dns_gateway_server_list = [base.DEFAULT_IPV4]
+    elif config_static.MainConfig.set_default_dns_gateway_to_network_interface_ipv4:
+        dns_gateway_server_list = [NETWORK_INTERFACE_SETTINGS.ipv4s[0]]
         set_local_dns_gateway = True
     else:
         dns_gateway_server_list = NETWORK_INTERFACE_SETTINGS.dns_gateways
 
-    if config_static.ENGINES_LIST[0].is_localhost:
-        if set_local_dns_gateway:
-            global IS_SET_DNS_GATEWAY
-            IS_SET_DNS_GATEWAY = True
-
-            # Get current network interface state.
-            global NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST
-            NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST = dns.get_default_dns_gateway()
-
-            # Set the DNS gateway to the specified one only if the DNS gateway is dynamic, or it is static but different
-            # from the one specified in the configuration file.
-            if (NETWORK_INTERFACE_IS_DYNAMIC or (not NETWORK_INTERFACE_IS_DYNAMIC and
-                                                 NETWORK_INTERFACE_IPV4_ADDRESS_LIST != dns_gateway_server_list)):
-                try:
-                    dns.set_connection_dns_gateway_static(
-                        dns_servers=dns_gateway_server_list,
-                        use_default_connection=True
-                    )
-                except PermissionError as e:
-                    print_api.print_api(e, error_type=True, color="red", logger=system_logger)
-                    # Wait for the message to be printed and saved to file.
-                    time.sleep(1)
-                    # network_logger_queue_listener.stop()
-                    return 1
-    else:
+    if set_local_dns_gateway:
+        global IS_SET_DNS_GATEWAY
+        IS_SET_DNS_GATEWAY = True
+
+        # Get current network interface state.
+        global NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST
+        NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST = dns.get_default_dns_gateway()
+
+        # Set the DNS gateway to the specified one only if the DNS gateway is dynamic, or it is static but different
+        # from the one specified in the configuration file.
+        if (NETWORK_INTERFACE_IS_DYNAMIC or (not NETWORK_INTERFACE_IS_DYNAMIC and
+                                             NETWORK_INTERFACE_IPV4_ADDRESS_LIST != dns_gateway_server_list)):
+            try:
+                dns.set_interface_dns_gateway_static(
+                    interface_name=NETWORK_INTERFACE_SETTINGS.name,
+                    dns_servers=dns_gateway_server_list
+                )
+            except PermissionError as e:
+                print_api.print_api(e, error_type=True, color="red", logger=system_logger)
+                # Wait for the message to be printed and saved to file.
+                time.sleep(1)
+                # network_logger_queue_listener.stop()
+                return 1
+
+    if not config_static.MainConfig.is_localhost:
         # Change the adapter settings and add the virtual IPs.
         try:
-            networks.add_virtual_ips_to_default_adapter_by_current_setting(
-                virtual_ipv4s_to_add=IPS_TO_ASSIGN, virtual_ipv4_masks_to_add=MASKS_TO_ASSIGN,
-                dns_gateways=dns_gateway_server_list)
+            networks.add_virtual_ips_to_network_interface(
+                interface_name=NETWORK_INTERFACE_SETTINGS.name,
+                virtual_ipv4s_to_add=IPS_TO_ASSIGN,
+                virtual_ipv4_masks_to_add=MASKS_TO_ASSIGN,
+                verbose=True,
+                logger=system_logger
+            )
+
+            for engine in config_static.ENGINES_LIST:
+                bindable_test_dict: dict = engine.domain_target_dict | engine.port_target_dict
+                for port_or_domain_name, ip_port_dict in bindable_test_dict.items():
+                    print_api.print_api(f"Checking that virtual IP is bindable: {ip_port_dict['ip']}:{ip_port_dict['port']}", logger=system_logger)
+                    networks.wait_for_ip_bindable_socket(ip_port_dict['ip'], port=int(ip_port_dict['port']), timeout=15)
+            print_api.print_api("BIND test successful for all virtual IPs.", logger=system_logger)
         except (PermissionError, TimeoutError) as e:
             print_api.print_api(e, error_type=True, color="red", logger=system_logger)
             # Wait for the message to be printed and saved to file.
@@ -760,6 +853,29 @@ def _loop_at_midnight_recs_archive(network_logger_name):
 
 
 def mitm_server_main(config_file_path: str, script_version: str):
+    # This is for Linux and macOS.
+    signal.signal(signal.SIGTERM, _graceful_shutdown)
+    signal.signal(signal.SIGINT, _graceful_shutdown)
+    # This is for Windows.
+    """
+    Example:
+    script = (Path(__file__).resolve().parent / "ServerTCPWithDNS.py").resolve()
+    p = subprocess.Popen(
+        [sys.executable, "-u", str(script)],
+        creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,
+        # inherit console; do NOT use CREATE_NEW_CONSOLE
+    )
+    time.sleep(30)
+    p.send_signal(signal.CTRL_BREAK_EVENT)
+    try:
+        p.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        print("Graceful interrupt timed out; terminating")
+        p.terminate()
+        p.wait()
+    """
+    signal.signal(signal.SIGBREAK, _graceful_shutdown)
+
     try:
         # Main function should return integer with error code, 0 is successful.
         return mitm_server(config_file_path, script_version)

atomicshop/mitm/recs_files.py

@@ -2,8 +2,9 @@ import datetime
 import os
 import multiprocessing
 import logging
+import zipfile
+import shutil
 
-from ..archiver import zips
 from .. import filesystem, print_api
 from .. wrappers.loggingw import consts, loggingw
 
@@ -13,6 +14,40 @@ REC_FILE_DATE_TIME_FORMAT: str = f'{consts.DEFAULT_ROTATING_SUFFIXES_FROM_WHEN["
 REC_FILE_DATE_FORMAT: str = REC_FILE_DATE_TIME_FORMAT.split('_')[0]
 
 
+def archive(
+        directory_path: str,
+        include_root_directory: bool = True,
+) -> str:
+    """
+    Function archives the directory.
+    :param directory_path: string, full path to the directory.
+    :param include_root_directory: boolean, default is 'True'.
+        'True': The root directory will be included in the archive.
+        'False': The root directory will not be included in the archive.
+        True is usually the case in most archiving utilities.
+    :return: string, full path to the archived file.
+    """
+
+    # This is commonly used and supported by most ZIP utilities.
+    compression_method = zipfile.ZIP_DEFLATED
+
+    archive_path: str = directory_path + '.zip'
+    with zipfile.ZipFile(archive_path, 'w', compression_method) as zip_object:
+        for root, _, files in os.walk(directory_path):
+            for file in files:
+                file_path = os.path.join(root, file)
+
+                # If including the root directory, use the relative path from the parent directory of the root
+                if include_root_directory:
+                    arcname = os.path.relpath(file_path, os.path.dirname(directory_path))
+                else:
+                    arcname = os.path.relpath(file_path, directory_path)
+
+                zip_object.write(file_path, arcname)
+
+    return archive_path
+
+
 def recs_archiver(
         recs_directory: str,
         logging_queue: multiprocessing.Queue,
@@ -69,6 +104,8 @@ def recs_archiver(
     try:
         archived_files: list = list()
         for directory_path, all_recs_files in file_list_per_directory:
+            print_api.print_api(f"Archiving recs files in directory: {directory_path.path}",
+                      logger=rec_packer_logger_with_queue_handler, color='blue')
             for recs_atomic_path in all_recs_files:
                 # We don't need to archive today's files.
                 if today_date_string == recs_atomic_path.datetime_string:
@@ -82,10 +119,29 @@ def recs_archiver(
             # Archive directories.
             archive_directories: list = filesystem.get_paths_from_directory(
                 directory_path.path, get_directory=True, recursive=False)
-            for archive_directory in archive_directories:
-                archived_file: str = zips.archive_directory(
-                    archive_directory.path, remove_original=True, include_root_directory=True)
-                archived_files.append(archived_file)
+
+            if not archive_directories:
+                print_api.print_api(
+                    f"No directories to archive in: {directory_path.path}",
+                    color='blue',
+                    logger=rec_packer_logger_with_queue_handler
+                )
+            else:
+                total_archived_files: int = 0
+                for archive_directory in archive_directories:
+                    files_to_archive: list = filesystem.get_paths_from_directory(
+                        directory_path=archive_directory.path, get_file=True, recursive=False)
+                    total_archived_files += len(files_to_archive)
+                    archived_file: str = archive(archive_directory.path, include_root_directory=True)
+                    # Remove the original directory after archiving.
+                    shutil.rmtree(archive_directory.path, ignore_errors=True)
+                    archived_files.append(archived_file)
+
+                print_api.print_api(
+                    f'Archived: 'f'Directories: {len(archive_directories)} | '
+                    f'Total Files: {total_archived_files} | In: {directory_path.path}',
+                    logger=rec_packer_logger_with_queue_handler, color='blue')
+                print_api.print_api(f'Archived files: {archived_files}', logger=rec_packer_logger_with_queue_handler)
 
         finalize_output_queue.put(None)