atomicshop 2.16.10__py3-none-any.whl → 2.16.12__py3-none-any.whl

atomicshop/mitm/config_static.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 from . import import_config
 
 
-SCRIPT_VERSION: str = '1.7.0'
+SCRIPT_VERSION: str = '1.7.3'
 
 
 # CONFIG = None
@@ -19,6 +19,7 @@ LIST_OF_BOOLEANS: list = [
     ('tcp', 'enable'),
     ('tcp', 'engines_usage'),
     ('tcp', 'server_response_mode'),
+    ('logrec', 'enable_request_response_recordings_in_logs'),
     ('certificates', 'default_server_certificate_usage'),
     ('certificates', 'sni_add_new_domains_to_default_server_certificate'),
     ('certificates', 'custom_server_certificate_usage'),
@@ -34,8 +35,7 @@ LIST_OF_BOOLEANS: list = [
 TOML_TO_STATIC_CATEGORIES: dict = {
     'dns': 'DNSServer',
     'tcp': 'TCPServer',
-    'log': 'Log',
-    'recorder': 'Recorder',
+    'logrec': 'LogRec',
     'certificates': 'Certificates',
     'skip_extensions': 'SkipExtensions',
     'process_name': 'ProcessName'
@@ -101,13 +101,12 @@ class TCPServer:
 
 
 @dataclass
-class Log:
+class LogRec:
     logs_path: str
-
-
-@dataclass
-class Recorder:
     recordings_path: str
+    enable_request_response_recordings_in_logs: bool
+
+    recordings_directory_name: str = 'recs'
 
 
 @dataclass

atomicshop/mitm/connection_thread_worker.py

@@ -24,7 +24,25 @@ def thread_worker_main(
         reference_module
 ):
     def output_statistics_csv_row():
-        status_code = ','.join([str(x.code) for x in client_message.response_list_of_raw_decoded])
+        # If there is no '.code' attribute in HTTPResponse, this means that this is not a HTTP message, so there is no
+        # status code.
+        try:
+            http_status_code: str = ','.join([str(x.code) for x in client_message.response_list_of_raw_decoded])
+        except AttributeError:
+            http_status_code: str = str()
+
+        # Same goes for the '.path' attribute, if it is not HTTP message then there will be no path.
+        try:
+            http_path: str = client_message.request_raw_decoded.path
+        except AttributeError:
+            http_path: str = str()
+
+        # Same goes for the '.command' attribute, if it is not HTTP message then there will be no command.
+        try:
+            http_command: str = client_message.request_raw_decoded.command
+        except AttributeError:
+            http_command: str = str()
+
         response_size_bytes = ','.join([str(len(x)) for x in client_message.response_list_of_raw_bytes])
 
         statistics_writer.write_row(
@@ -32,13 +50,13 @@ def thread_worker_main(
             tls_type=tls_type,
             tls_version=tls_version,
             protocol=client_message.protocol,
-            path=client_message.request_raw_decoded.path,
-            status_code=status_code,
-            command=client_message.request_raw_decoded.command,
+            path=http_path,
+            status_code=http_status_code,
+            command=http_command,
             request_time_sent=client_message.request_time_received,
             request_size_bytes=len(client_message.request_raw_bytes),
             response_size_bytes=response_size_bytes,
-            recorded_file_path=recorded_file,
+            recorded_file_path=client_message.recorded_file_path,
             process_cmd=process_commandline,
             error=str())
 
@@ -126,7 +144,7 @@ def thread_worker_main(
                     message = "There was an exception in HTTP Parsing module!"
                     print_api(
                         message, error_type=True, logger=network_logger, logger_method='critical',
-                        traceback_string=True, oneline=True)
+                        traceback_string=True)
                     # Socket connection can be closed since we have a problem in current thread and break the loop
                     client_connection_boolean = False
                     break
@@ -160,10 +178,10 @@ def thread_worker_main(
                     message = "Exception in Parser"
                     print_api(
                         message, error_type=True, logger=parser.logger, logger_method='critical',
-                        traceback_string=True, oneline=True)
+                        traceback_string=True)
                     print_api(
                         message, error_type=True, logger=network_logger, logger_method='critical',
-                        traceback_string=True, oneline=True)
+                        traceback_string=True)
                     # At this point we can pass the exception and continue the script.
                     pass
                     # Socket connection can be closed since we have a problem in current thread and break the loop
@@ -193,10 +211,10 @@ def thread_worker_main(
                         message = "Exception in Responder"
                         print_api(
                             message, error_type=True, logger=responder.logger, logger_method='critical',
-                            traceback_string=True, oneline=True)
+                            traceback_string=True)
                         print_api(
                             message, error_type=True, logger=network_logger, logger_method='critical',
-                            traceback_string=True, oneline=True)
+                            traceback_string=True)
                         pass
                         # Socket connection can be closed since we have a problem in current thread and break the loop.
                         client_connection_boolean = False
@@ -220,8 +238,9 @@ def thread_worker_main(
                             service_client = socket_client.SocketClient(
                                 service_name=client_message.server_name, service_port=client_message.destination_port,
                                 tls=is_tls,
-                                dns_servers_list=
-                                config_static.TCPServer.forwarding_dns_service_ipv4_list___only_for_localhost)
+                                dns_servers_list=(
+                                    config_static.TCPServer.forwarding_dns_service_ipv4_list___only_for_localhost)
+                            )
                         # If we're not on localhost, then connect to domain directly.
                         else:
                             service_client = socket_client.SocketClient(
@@ -253,18 +272,19 @@ def thread_worker_main(
 
                 # This is the point after the response mode check was finished.
                 # Recording the message, doesn't matter what type of mode this is.
-                try:
-                    recorded_file = recorder(class_client_message=client_message,
-                                             record_path=config_static.Recorder.recordings_path).record()
-                except Exception:
-                    message = "Exception in Recorder"
-                    print_api(
-                        message, error_type=True, logger=recorder.logger, logger_method='critical',
-                        traceback_string=True, oneline=True)
-                    print_api(
-                        message, error_type=True, logger=network_logger, logger_method='critical',
-                        traceback_string=True, oneline=True)
-                    pass
+                if config_static.LogRec.enable_request_response_recordings_in_logs:
+                    try:
+                        recorded_file = recorder(class_client_message=client_message,
+                                                 record_path=config_static.LogRec.recordings_path).record()
+                        client_message.recorded_file_path = recorded_file
+                    except Exception:
+                        message = "Exception in Recorder"
+                        print_api(
+                            message, error_type=True, logger=recorder.logger, logger_method='critical',
+                            traceback_string=True)
+                        print_api(
+                            message, error_type=True, logger=network_logger, logger_method='critical',
+                            traceback_string=True)
 
                 function_recorded = True
 
@@ -294,7 +314,7 @@ def thread_worker_main(
                     message = "Not sending anything to the client, since there is no response available"
                     print_api(
                         message, error_type=True, logger=network_logger, logger_method='critical',
-                        traceback_string=True, oneline=True)
+                        traceback_string=True)
                     # Pass the exception
                     pass
                     # Break the while loop
@@ -312,18 +332,19 @@ def thread_worker_main(
         # === At this point while loop of 'client_connection_boolean' was broken =======================================
         # If recorder wasn't executed before, then execute it now
         if not function_recorded:
-            try:
-                recorded_file = recorder(
-                    class_client_message=client_message, record_path=config_static.Recorder.recordings_path).record()
-            except Exception:
-                message = "Exception in Recorder"
-                print_api(
-                    message, error_type=True, logger=recorder.logger, logger_method='critical',
-                    traceback_string=True, oneline=True)
-                print_api(
-                    message, error_type=True, logger=network_logger, logger_method='critical',
-                    traceback_string=True, oneline=True)
-                pass
+            if config_static.LogRec.enable_request_response_recordings_in_logs:
+                try:
+                    recorded_file = recorder(
+                        class_client_message=client_message, record_path=config_static.LogRec.recordings_path).record()
+                    client_message.recorded_file_path = recorded_file
+                except Exception:
+                    message = "Exception in Recorder"
+                    print_api(
+                        message, error_type=True, logger=recorder.logger, logger_method='critical',
+                        traceback_string=True)
+                    print_api(
+                        message, error_type=True, logger=network_logger, logger_method='critical',
+                        traceback_string=True)
 
             # Save statistics file.
             output_statistics_csv_row()
@@ -343,5 +364,4 @@ def thread_worker_main(
     except Exception:
         message = "Undocumented exception in thread worker"
         print_api(
-            message, error_type=True, logger=network_logger, logger_method='critical',
-            traceback_string=True, oneline=True)
+            message, error_type=True, logger=network_logger, logger_method='critical', traceback_string=True)

atomicshop/mitm/engines/__parent/parser___parent.py

@@ -1,4 +1,3 @@
-# v1.0.0 - 26.03.2023 14:00
 from ...shared_functions import create_custom_logger
 from ...message import ClientMessage
 

atomicshop/mitm/engines/__parent/recorder___parent.py

@@ -3,8 +3,8 @@ from datetime import datetime
 
 from ...shared_functions import build_module_names, create_custom_logger, get_json
 from ... import message, recs_files
-from ....urls import url_parser
-from .... import filesystem
+from .... import filesystem, urls
+from ....file_io import file_io
 
 
 # The class that is responsible for Recording Requests / Responses.
@@ -52,7 +52,7 @@ class RecorderParent:
         # This will happen if the message is not HTTP.
         try:
             # Parse the url to components.
-            http_path_parsed = url_parser(self.class_client_message.request_raw_decoded.path)
+            http_path_parsed = urls.url_parser(self.class_client_message.request_raw_decoded.path)
             # Get only directories.
             http_path_directories_string = '-'.join(http_path_parsed['directories'])
             # Add '_' character before 'http_path' to look better on the file name.
@@ -64,7 +64,7 @@ class RecorderParent:
         # If HTTP Path is not defined, 'http_path' will be empty, and it will not interfere with file name.
         self.record_file_path: str = \
             self.engine_record_path + os.sep + \
-            day_time_format + "_" + self.class_client_message.server_name + http_path + self.file_extension
+            day_time_format + "_" + self.class_client_message.server_name + self.file_extension
 
     def convert_messages(self):
         """
@@ -91,8 +91,7 @@ class RecorderParent:
         record_message = get_json(self.class_client_message)
 
         # Since we already dumped the object to dictionary string, we'll just save the object to regular file.
-        with open(self.record_file_path, 'w') as output_file:
-            output_file.write(record_message)
+        file_io.write_file(record_message, self.record_file_path, enable_long_file_path=True)
 
         self.logger.info(f"Recorded to file: {self.record_file_path}")
 

atomicshop/mitm/engines/__parent/responder___parent.py

@@ -1,4 +1,3 @@
-# v1.0.0 - 26.03.2023 14:20
 # Using to convert status code to status phrase / string.
 from http import HTTPStatus
 # Parsing PATH template to variables.

atomicshop/mitm/import_config.py

@@ -1,3 +1,4 @@
+import os
 from pathlib import Path
 
 from ..print_api import print_api
@@ -131,13 +132,14 @@ def manipulations_after_import():
     config_static.SkipExtensions.SKIP_EXTENSION_ID_LIST = skip_extensions
 
     # If the paths are relative, convert them to absolute paths.
-    config_static.Log.logs_path = filesystem.check_absolute_path___add_full(
-        config_static.Log.logs_path, config_static.MainConfig.SCRIPT_DIRECTORY)
-    config_static.Recorder.recordings_path = filesystem.check_absolute_path___add_full(
-        config_static.Recorder.recordings_path, config_static.MainConfig.SCRIPT_DIRECTORY)
+    config_static.LogRec.logs_path = filesystem.check_absolute_path___add_full(
+        config_static.LogRec.logs_path, config_static.MainConfig.SCRIPT_DIRECTORY)
     config_static.Certificates.custom_server_certificate_path = filesystem.check_absolute_path___add_full(
         config_static.Certificates.custom_server_certificate_path, config_static.MainConfig.SCRIPT_DIRECTORY)
 
+    config_static.LogRec.recordings_path = (
+            config_static.LogRec.logs_path + os.sep + config_static.LogRec.recordings_directory_name)
+
     # At this point the user that sets the config can set it to null or empty string ''. We will make sure
     # that the path is None if it's empty.
     if config_static.Certificates.custom_private_key_path:

atomicshop/mitm/initialize_engines.py

@@ -52,12 +52,12 @@ class ModuleCategory:
             raise ValueError(f"Engine Configuration file doesn't contain any domains: {engine_config_file_path}")
 
         # Full path to file
-        self.parser_file_path = filesystem.get_file_paths_from_directory(
-            engine_directory_path, file_name_check_pattern=configuration_data['parser_file'])[0]
-        self.responder_file_path = filesystem.get_file_paths_from_directory(
-            engine_directory_path, file_name_check_pattern=configuration_data['responder_file'])[0]
-        self.recorder_file_path = filesystem.get_file_paths_from_directory(
-            engine_directory_path, file_name_check_pattern=configuration_data['recorder_file'])[0]
+        self.parser_file_path = filesystem.get_paths_from_directory(
+            engine_directory_path, get_file=True, file_name_check_pattern=configuration_data['parser_file'])[0].path
+        self.responder_file_path = filesystem.get_paths_from_directory(
+            engine_directory_path, get_file=True, file_name_check_pattern=configuration_data['responder_file'])[0].path
+        self.recorder_file_path = filesystem.get_paths_from_directory(
+            engine_directory_path, get_file=True, file_name_check_pattern=configuration_data['recorder_file'])[0].path
 
     def initialize_engine(self, logs_path: str, logger=None, reference_general: bool = False, **kwargs):
         if not reference_general:

atomicshop/mitm/message.py

@@ -21,6 +21,7 @@ class ClientMessage:
         self.info: str = str()
         self.error: str = str()
         self.protocol: str = str()
+        self.recorded_file_path: str = str()
 
     def reinitialize(self) -> None:
         """

atomicshop/mitm/{initialize_mitm_server.py → mitm_main.py}

@@ -17,18 +17,22 @@ from .connection_thread_worker import thread_worker_main
 from . import config_static, recs_files
 
 
+NETWORK_INTERFACE_IS_DYNAMIC: bool = bool()
+NETWORK_INTERFACE_IPV4_ADDRESS_LIST: list[str] = list()
+
+
 def exit_cleanup():
-    if config_static.DNSServer.set_default_dns_gateway:
+    if permissions.is_admin():
         is_dns_dynamic, current_dns_gateway = dns.get_default_dns_gateway()
         print_api(f'Current DNS Gateway: {current_dns_gateway}')
 
-        if current_dns_gateway == config_static.DNSServer.set_default_dns_gateway and not is_dns_dynamic:
-            if permissions.is_admin():
-                dns.set_connection_dns_gateway_dynamic(use_default_connection=True)
-                print_api("Returned default DNS gateway...", color='blue')
+        if is_dns_dynamic != NETWORK_INTERFACE_IS_DYNAMIC or \
+                (not is_dns_dynamic and current_dns_gateway != NETWORK_INTERFACE_IPV4_ADDRESS_LIST):
+            dns.set_connection_dns_gateway_dynamic(use_default_connection=True)
+            print_api("Returned default DNS gateway...", color='blue')
 
 
-def initialize_mitm_server(config_file_path: str):
+def mitm_server_main(config_file_path: str):
     on_exit.register_exit_handler(exit_cleanup)
 
     # Main function should return integer with error code, 0 is successful.
@@ -42,20 +46,22 @@ def initialize_mitm_server(config_file_path: str):
         return result
 
     # Create folders.
-    filesystem.create_directory(config_static.Log.logs_path)
-    filesystem.create_directory(config_static.Recorder.recordings_path)
+    filesystem.create_directory(config_static.LogRec.logs_path)
+
+    if config_static.LogRec.enable_request_response_recordings_in_logs:
+        filesystem.create_directory(config_static.LogRec.recordings_path)
+        # Compress recordings of the previous days if there are any.
+        recs_files.recs_archiver_in_process(config_static.LogRec.recordings_path)
+
     if config_static.Certificates.sni_get_server_certificate_from_server_socket:
         filesystem.create_directory(
             config_static.Certificates.sni_server_certificate_from_server_socket_download_directory)
 
-    # Compress recordings of the previous days if there are any.
-    recs_files.recs_archiver_in_process(config_static.Recorder.recordings_path)
-
     # Create a logger that will log messages to file, Initiate System logger.
     logger_name = "system"
     system_logger = loggingw.create_logger(
         logger_name=logger_name,
-        file_path=f"{config_static.Log.logs_path}{os.sep}{logger_name}.txt",
+        file_path=f"{config_static.LogRec.logs_path}{os.sep}{logger_name}.txt",
         add_stream=True,
         add_timedfile=True,
         formatter_streamhandler='DEFAULT',
@@ -68,8 +74,9 @@ def initialize_mitm_server(config_file_path: str):
     system_logger.info(f"Python Version: {get_current_python_version_string()}")
     system_logger.info(f"Script Version: {config_static.SCRIPT_VERSION}")
     system_logger.info(f"Atomic Workshop Version: {atomicshop.__version__}")
-    system_logger.info(f"Log folder: {config_static.Log.logs_path}")
-    system_logger.info(f"Recordings folder for Requests/Responses: {config_static.Recorder.recordings_path}")
+    system_logger.info(f"Log folder: {config_static.LogRec.logs_path}")
+    if config_static.LogRec.enable_request_response_recordings_in_logs:
+        system_logger.info(f"Recordings folder for Requests/Responses: {config_static.LogRec.recordings_path}")
     system_logger.info(f"Loaded system logger: {system_logger}")
 
     system_logger.info(f"TCP Server Target IP: {config_static.DNSServer.target_tcp_server_ipv4}")
@@ -103,8 +110,9 @@ def initialize_mitm_server(config_file_path: str):
     system_logger.info("Importing engine modules.")
 
     # Get full paths of all the 'engine_config.ini' files.
-    engine_config_path_list = filesystem.get_file_paths_from_directory(
+    engine_config_path_list = filesystem.get_paths_from_directory(
         directory_path=config_static.MainConfig.ENGINES_DIRECTORY_PATH,
+        get_file=True,
         file_name_check_pattern=config_static.MainConfig.ENGINE_CONFIG_FILE_NAME)
 
     # Iterate through all the 'engine_config.ini' file paths.
@@ -113,8 +121,8 @@ def initialize_mitm_server(config_file_path: str):
     for engine_config_path in engine_config_path_list:
         # Initialize engine.
         current_module = ModuleCategory(config_static.MainConfig.SCRIPT_DIRECTORY)
-        current_module.fill_engine_fields_from_config(engine_config_path)
-        current_module.initialize_engine(logs_path=config_static.Log.logs_path,
+        current_module.fill_engine_fields_from_config(engine_config_path.path)
+        current_module.initialize_engine(logs_path=config_static.LogRec.logs_path,
                                          logger=system_logger)
 
         # Extending the full engine domain list with this list.
@@ -125,7 +133,7 @@ def initialize_mitm_server(config_file_path: str):
     # ==== Initialize Reference Module =============================================================================
     reference_module = ModuleCategory(config_static.MainConfig.SCRIPT_DIRECTORY)
     reference_module.fill_engine_fields_from_general_reference(config_static.MainConfig.ENGINES_DIRECTORY_PATH)
-    reference_module.initialize_engine(logs_path=config_static.Log.logs_path,
+    reference_module.initialize_engine(logs_path=config_static.LogRec.logs_path,
                                        logger=system_logger, stdout=False, reference_general=True)
     # === EOF Initialize Reference Module ==========================================================================
     # === Engine logging ===========================================================================================
@@ -151,8 +159,12 @@ def initialize_mitm_server(config_file_path: str):
             message = f"[*] Engine domains found, but the DNS routing is set not to use them for routing."
             print_api(message, color="yellow", logger=system_logger)
         elif not engines_list and config_static.DNSServer.resolve_to_tcp_server_only_engine_domains:
-            raise ValueError("No engines were found, but the DNS routing is set to use them for routing.\n"
-                             "Please check your DNS configuration in the 'config.ini' file.")
+            error_message = (
+                f"No engines were found in: [{config_static.MainConfig.ENGINES_DIRECTORY_PATH}]\n"
+                f"But the DNS routing is set to use them for routing.\n"
+                f"Please check your DNS configuration in the 'config.ini' file.")
+            print_api(error_message, color="red")
+            return 1
 
         if config_static.DNSServer.resolve_to_tcp_server_all_domains:
             print_api("All domains will be routed by the DNS server to Built-in TCP Server.", logger=system_logger)
@@ -175,8 +187,12 @@ def initialize_mitm_server(config_file_path: str):
             message = f"Engines found, and the TCP server is set to use them for processing."
             print_api(message, logger=system_logger)
         elif not engines_list and config_static.TCPServer.engines_usage:
-            raise ValueError("No engines were found, but the TCP server is set to use them for processing.\n"
-                             "Please check your TCP configuration in the 'config.ini' file.")
+            error_message = (
+                f"No engines were found in: [{config_static.MainConfig.ENGINES_DIRECTORY_PATH}]\n"
+                f"But the TCP server is set to use them for processing.\n"
+                f"Please check your TCP configuration in the 'config.ini' file.")
+            print_api(error_message, color="red")
+            return 1
     else:
         print_api("TCP Server is disabled.", logger=system_logger, color="yellow")
 
@@ -188,7 +204,7 @@ def initialize_mitm_server(config_file_path: str):
     network_logger_name = "network"
     network_logger = loggingw.create_logger(
         logger_name=network_logger_name,
-        directory_path=config_static.Log.logs_path,
+        directory_path=config_static.LogRec.logs_path,
         add_stream=True,
         add_timedfile=True,
         formatter_streamhandler='DEFAULT',
@@ -216,7 +232,7 @@ def initialize_mitm_server(config_file_path: str):
                 # Passing the engine domain list to DNS server to work with.
                 # 'list' function re-initializes the current list, or else it will be the same instance object.
                 tcp_resolve_domain_list=list(config_static.Certificates.domains_all_times),
-                log_directory_path=config_static.Log.logs_path,
+                log_directory_path=config_static.LogRec.logs_path,
                 offline_mode=config_static.DNSServer.offline_mode,
                 resolve_to_tcp_server_only_tcp_resolve_domains=(
                     config_static.DNSServer.resolve_to_tcp_server_only_engine_domains),
@@ -268,7 +284,7 @@ def initialize_mitm_server(config_file_path: str):
                 ssh_pass=config_static.ProcessName.ssh_pass,
                 ssh_script_to_execute=config_static.ProcessName.ssh_script_to_execute,
                 logger=listener_logger,
-                statistics_logs_directory=config_static.Log.logs_path,
+                statistics_logs_directory=config_static.LogRec.logs_path,
                 forwarding_dns_service_ipv4_list___only_for_localhost=(
                     config_static.TCPServer.forwarding_dns_service_ipv4_list___only_for_localhost),
                 skip_extension_id_list=config_static.SkipExtensions.SKIP_EXTENSION_ID_LIST,
@@ -298,11 +314,18 @@ def initialize_mitm_server(config_file_path: str):
             set_dns_gateway = True
 
         if set_dns_gateway:
-            # noinspection PyTypeChecker
-            dns.set_connection_dns_gateway_static(
-                dns_servers=dns_gateway_server_list,
-                use_default_connection=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)):
+                dns.set_connection_dns_gateway_static(
+                    dns_servers=dns_gateway_server_list,
+                    use_default_connection=True
+                )
 
         # General exception handler will catch all the exceptions that occurred in the threads and write it to the log.
         # noinspection PyBroadException
@@ -319,13 +342,14 @@ def initialize_mitm_server(config_file_path: str):
             socket_thread.start()
         except Exception:
             message = f"Unhandled Exception occurred in 'loop_for_incoming_sockets' function"
-            print_api(message, error_type=True, color="red", logger=network_logger, traceback_string=True, oneline=True)
+            print_api(message, error_type=True, color="red", logger=network_logger, traceback_string=True)
 
         # Compress recordings each day in a separate process.
         recs_archiver_thread = threading.Thread(target=_loop_at_midnight_recs_archive)
         recs_archiver_thread.daemon = True
         recs_archiver_thread.start()
 
+    if config_static.DNSServer.enable or config_static.TCPServer.enable:
         # This is needed for Keyboard Exception.
         while True:
             time.sleep(1)
@@ -338,7 +362,8 @@ def _loop_at_midnight_recs_archive():
         current_date = datetime.datetime.now().strftime('%d')
         # If it's midnight, start the archiving process.
         if current_date != previous_date:
-            recs_files.recs_archiver_in_process(config_static.Recorder.recordings_path)
+            if config_static.LogRec.enable_request_response_recordings_in_logs:
+                recs_files.recs_archiver_in_process(config_static.LogRec.recordings_path)
             # Update the previous date.
             previous_date = current_date
         # Sleep for 1 minute.

atomicshop/mitm/recs_files.py

@@ -22,43 +22,44 @@ def recs_archiver(recs_directory: str) -> list:
     today_date_string = datetime.datetime.now().strftime(REC_FILE_DATE_FORMAT)
 
     # There should not be recording json files in recs root.
-    files_in_recs_root: list = filesystem.get_file_paths_from_directory(
-        recs_directory, file_name_check_pattern='*.json', recursive=False)
+    files_in_recs_root: list = filesystem.get_paths_from_directory(
+        recs_directory, get_file=True, file_name_check_pattern='*\\.json', recursive=False)
     if files_in_recs_root:
         raise NotImplementedError("The files in recs root directory are not implemented yet.")
 
     # Each engine should have its own directory inside recordings. We will find all the directories inside recs folder.
-    directory_paths_in_recs: list = filesystem.get_directory_paths_from_directory(recs_directory, recursive=False)
+    directory_paths_in_recs: list = filesystem.get_paths_from_directory(
+        recs_directory, get_directory=True, recursive=False)
 
     file_list_per_directory: list = list()
     for directory_path in directory_paths_in_recs:
-        all_recs_files = reading.get_logs_paths(
-            log_files_directory_path=directory_path,
-            file_name_pattern='*.json',
-            date_format=REC_FILE_DATE_FORMAT
+        all_recs_files = filesystem.get_paths_from_directory(
+            directory_path=directory_path.path,
+            get_file=True,
+            file_name_check_pattern='*.json',
+            datetime_format=REC_FILE_DATE_FORMAT,
+            recursive=False
         )
         file_list_per_directory.append((directory_path, all_recs_files))
 
     archived_files: list = list()
     for directory_path, all_recs_files in file_list_per_directory:
-        archive_directories: list = list()
-        for recs_file_dict in all_recs_files:
+        for recs_atomic_path in all_recs_files:
             # We don't need to archive today's files.
-            if today_date_string == recs_file_dict['date_string']:
+            if today_date_string == recs_atomic_path.datetime_string:
                 continue
 
-            target_directory_path: str = f"{directory_path}{os.sep}{recs_file_dict['date_string']}"
-            if target_directory_path not in archive_directories:
-                archive_directories.append(target_directory_path)
-
+            target_directory_path: str = f"{directory_path.path}{os.sep}{recs_atomic_path.datetime_string}"
             filesystem.create_directory(target_directory_path)
             filesystem.move_file(
-                recs_file_dict['file_path'], f'{target_directory_path}{os.sep}{recs_file_dict["file_name"]}')
+                recs_atomic_path.path, f'{target_directory_path}{os.sep}{recs_atomic_path.name}')
 
         # 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, remove_original=True, include_root_directory=True)
+                archive_directory.path, remove_original=True, include_root_directory=True)
             archived_files.append(archived_file)
 
     return archived_files
@@ -71,4 +72,3 @@ def recs_archiver_in_process(recs_directory: str):
 
     process = multiprocessing.Process(target=recs_archiver, args=(recs_directory,))
     process.start()
-

atomicshop/mitm/statistic_analyzer.py

@@ -28,9 +28,9 @@ def analyze(main_file_path: str):
     summary_path: str = filesystem.check_absolute_path___add_full(config['report_file_path'], script_directory)
 
     # Get the content from statistics files.
+    log_file_path_pattern: str = f"{config['statistic_files_path']}{os.sep}statistics.csv"
     statistics_content: list = reading.get_all_log_files_into_list(
-        config['statistic_files_path'],
-        file_name_pattern='statistics*.csv',
+        log_file_path=log_file_path_pattern,
         log_type='csv'
     )