atomicshop 2.16.25__py3-none-any.whl → 2.16.27__py3-none-any.whl

atomicshop/__init__.py

@@ -1,4 +1,4 @@
 """Atomic Basic functions and classes to make developer life easier"""
 
 __author__ = "Den Kras"
-__version__ = '2.16.25'
+__version__ = '2.16.27'

atomicshop/file_io/csvs.py

@@ -254,3 +254,23 @@ def escape_csv_line_to_list(csv_line: list) -> list:
         result_csv_entries.append(escape_csv_value(entry))
 
     return result_csv_entries
+
+
+def get_number_of_cells_in_string_line(line: str) -> int:
+    """
+    Function to get number of cells in CSV line.
+
+    :param line: String, line of CSV file.
+    :return: int, number of cells in the line.
+    """
+
+    # Create CSV reader from 'input_file'. By default, the first row will be the header if 'fieldnames' is None.
+    csv_reader = csv.reader([line])
+
+    # Get the first row of the CSV file.
+    csv_list = list(csv_reader)
+
+    # Get the number of cells in the first row.
+    number_of_cells = len(csv_list[0])
+
+    return number_of_cells

atomicshop/mitm/config_static.py

@@ -48,6 +48,8 @@ TOML_TO_STATIC_CATEGORIES: dict = {
 
 
 class MainConfig:
+    LOGGER_NAME: str = 'network'
+
     SCRIPT_DIRECTORY: str = None
 
     ENGINES_DIRECTORY_PATH: str = None

atomicshop/mitm/initialize_engines.py

@@ -63,15 +63,15 @@ class ModuleCategory:
 
     def initialize_engine(self, logs_path: str, logger=None, reference_general: bool = False, **kwargs):
         # Initiating logger for each engine by its name
-        loggingw.create_logger(
-            logger_name=self.engine_name,
-            directory_path=logs_path,
-            add_stream=True,
-            add_timedfile=True,
-            formatter_streamhandler='DEFAULT',
-            formatter_filehandler='DEFAULT',
-            backupCount=config_static.LogRec.store_logs_for_x_days
-        )
+        # loggingw.create_logger(
+        #     logger_name=self.engine_name,
+        #     directory_path=logs_path,
+        #     add_stream=True,
+        #     add_timedfile=True,
+        #     formatter_streamhandler='DEFAULT',
+        #     formatter_filehandler='DEFAULT',
+        #     backupCount=config_static.LogRec.store_logs_for_x_days
+        # )
 
         if not reference_general:
             self.parser_class_object = import_first_class_name_from_file_path(

atomicshop/mitm/mitm_main.py

@@ -1,5 +1,6 @@
-import os
+import logging
 import threading
+import multiprocessing
 import time
 import datetime
 
@@ -19,6 +20,14 @@ from . import config_static, recs_files
 
 NETWORK_INTERFACE_IS_DYNAMIC: bool = bool()
 NETWORK_INTERFACE_IPV4_ADDRESS_LIST: list[str] = list()
+# noinspection PyTypeChecker
+RECS_PROCESS_INSTANCE: multiprocessing.Process = None
+
+
+EXCEPTIONS_CSV_LOGGER_NAME: str = 'exceptions'
+EXCEPTIONS_CSV_LOGGER_HEADER: str = 'time,exception'
+# noinspection PyTypeChecker
+MITM_ERROR_LOGGER: loggingw.ExceptionCsvLogger = None
 
 
 def exit_cleanup():
@@ -31,9 +40,13 @@ def exit_cleanup():
             dns.set_connection_dns_gateway_dynamic(use_default_connection=True)
             print_api("Returned default DNS gateway...", color='blue')
 
+    print_api(RECS_PROCESS_INSTANCE.is_alive())
+    RECS_PROCESS_INSTANCE.terminate()
+    RECS_PROCESS_INSTANCE.join()
 
-def mitm_server_main(config_file_path: str):
-    on_exit.register_exit_handler(exit_cleanup)
+
+def mitm_server(config_file_path: str):
+    on_exit.register_exit_handler(exit_cleanup, at_exit=False)
 
     # Main function should return integer with error code, 0 is successful.
     # Since listening server is infinite, this will not be reached.
@@ -45,23 +58,26 @@ def mitm_server_main(config_file_path: str):
     if result != 0:
         return result
 
+    global MITM_ERROR_LOGGER
+    MITM_ERROR_LOGGER = loggingw.ExceptionCsvLogger(EXCEPTIONS_CSV_LOGGER_NAME, config_static.LogRec.logs_path)
+
     # Create folders.
     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)
+        global RECS_PROCESS_INSTANCE
+        RECS_PROCESS_INSTANCE = 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)
 
-    # 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.LogRec.logs_path}{os.sep}{logger_name}.txt",
+    network_logger_name = config_static.MainConfig.LOGGER_NAME
+    network_logger = loggingw.create_logger(
+        logger_name=network_logger_name,
+        directory_path=config_static.LogRec.logs_path,
         add_stream=True,
         add_timedfile=True,
         formatter_streamhandler='DEFAULT',
@@ -69,6 +85,10 @@ def mitm_server_main(config_file_path: str):
         backupCount=config_static.LogRec.store_logs_for_x_days
     )
 
+    # Initiate Listener logger, which is a child of network logger, so he uses the same settings and handlers
+    listener_logger = loggingw.get_logger_with_level(f'{network_logger_name}.listener')
+    system_logger = loggingw.get_logger_with_level(f'{network_logger_name}.system')
+
     # Writing first log.
     system_logger.info("======================================")
     system_logger.info("Server Started.")
@@ -202,22 +222,6 @@ def mitm_server_main(config_file_path: str):
     # Assigning all the engines domains to all time domains, that will be responsible for adding new domains.
     config_static.Certificates.domains_all_times = list(domains_engine_list_full)
 
-    network_logger_name = "network"
-    network_logger = loggingw.create_logger(
-        logger_name=network_logger_name,
-        directory_path=config_static.LogRec.logs_path,
-        add_stream=True,
-        add_timedfile=True,
-        formatter_streamhandler='DEFAULT',
-        formatter_filehandler='DEFAULT',
-        backupCount=config_static.LogRec.store_logs_for_x_days
-    )
-    system_logger.info(f"Loaded network logger: {network_logger}")
-
-    # Initiate Listener logger, which is a child of network logger, so he uses the same settings and handlers
-    listener_logger = loggingw.get_logger_with_level(f'{network_logger_name}.listener')
-    system_logger.info(f"Loaded listener logger: {listener_logger}")
-
     print_api("Press [Ctrl]+[C] to stop.", color='blue')
 
     # Create request domain queue.
@@ -330,7 +334,7 @@ def mitm_server_main(config_file_path: str):
         global NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST
         NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST = dns.get_default_dns_gateway()
         if set_dns_gateway:
-            # Set the DNS gateway to the specified one only if the DNS gateway is dynamic or it is static but different
+            # 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)):
@@ -339,22 +343,16 @@ def mitm_server_main(config_file_path: str):
                     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
-        try:
-            socket_thread = threading.Thread(
-                target=socket_wrapper_instance.loop_for_incoming_sockets,
-                kwargs={
-                    'reference_function_name': thread_worker_main,
-                    'reference_function_args': (network_logger, statistics_writer, engines_list, reference_module,)
-                }
-            )
+        socket_thread = threading.Thread(
+            target=socket_wrapper_instance.loop_for_incoming_sockets,
+            kwargs={
+                'reference_function_name': thread_worker_main,
+                'reference_function_args': (network_logger, statistics_writer, engines_list, reference_module,)
+            }
+        )
 
-            socket_thread.daemon = True
-            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)
+        socket_thread.daemon = True
+        socket_thread.start()
 
         # Compress recordings each day in a separate process.
         recs_archiver_thread = threading.Thread(target=_loop_at_midnight_recs_archive)
@@ -375,8 +373,25 @@ def _loop_at_midnight_recs_archive():
         # If it's midnight, start the archiving process.
         if current_date != previous_date:
             if config_static.LogRec.enable_request_response_recordings_in_logs:
-                recs_files.recs_archiver_in_process(config_static.LogRec.recordings_path)
+                global RECS_PROCESS_INSTANCE
+                RECS_PROCESS_INSTANCE = recs_files.recs_archiver_in_process(config_static.LogRec.recordings_path)
             # Update the previous date.
             previous_date = current_date
         # Sleep for 1 minute.
         time.sleep(60)
+
+
+def mitm_server_main(config_file_path: str):
+    try:
+        # Main function should return integer with error code, 0 is successful.
+        return mitm_server(config_file_path)
+    except KeyboardInterrupt:
+        print_api("Server Stopped by [KeyboardInterrupt].", color='blue')
+        exit_cleanup()
+        return 0
+    except Exception as e:
+        RECS_PROCESS_INSTANCE.terminate()
+
+        MITM_ERROR_LOGGER.write(e)
+        exit_cleanup()
+        return 1

atomicshop/mitm/recs_files.py

@@ -64,10 +64,11 @@ def recs_archiver(recs_directory: str) -> list:
     return archived_files
 
 
-def recs_archiver_in_process(recs_directory: str):
+def recs_archiver_in_process(recs_directory: str) -> multiprocessing.Process:
     """
     Archive recs files in a directory for each day in a separate process.
     """
 
     process = multiprocessing.Process(target=recs_archiver, args=(recs_directory,))
     process.start()
+    return process

atomicshop/mitm/shared_functions.py

@@ -4,6 +4,8 @@ import inspect
 from ..wrappers.loggingw import loggingw
 from ..basics import dicts
 
+from . import config_static
+
 
 # If the string has several dot characters (".") - return the most right string after the last dot.
 # Meaning if the class name contains several child classes like: classes.parsers.parser_something,
@@ -32,7 +34,8 @@ def create_custom_logger():
     # 'f_globals' is a dictionary of all the global variables of the calling initiated class.
     class_name = calling_frame.f_globals['__name__']
     # Get the logger name only.
-    logger_name = build_module_names(class_name)[0]
+    engine_logger_part = build_module_names(class_name)[0]
+    logger_name = f'{config_static.MainConfig.LOGGER_NAME}.{engine_logger_part}'
 
     return loggingw.get_logger_with_level(logger_name)
 

atomicshop/on_exit.py

@@ -91,25 +91,54 @@ class ExitHandler:
             # Exit the process gracefully
             raise SystemExit(0)
 
-    def register_handlers(self):
-        win32api.SetConsoleCtrlHandler(self.console_handler, True)
-        atexit.register(self.atexit_handler)
-        signal.signal(signal.SIGINT, self.signal_handler)
-        signal.signal(signal.SIGTERM, self.signal_handler)
-
-
-def register_exit_handler(clean_up_function, *args, **kwargs):
+    def register_handlers(
+            self,
+            at_exit: bool = True,
+            console_close: bool = True,
+            kill_signal: bool = True
+    ):
+        """
+        Register the exit handlers.
+
+        :param at_exit: Register the atexit handler.
+            Just remember that the atexit handler will be called right away on [Ctrl+C], meaning if you want to do
+            something specifically on KeyboardInterrupt, you should handle it separately and set this parameter to False.
+            Same goes for all the exceptions.
+        :param console_close: Register the console close handler.
+        :param kill_signal: Register the kill signal handler.
+        """
+        if at_exit:
+            atexit.register(self.atexit_handler)
+        if console_close:
+            win32api.SetConsoleCtrlHandler(self.console_handler, True)
+        if kill_signal:
+            signal.signal(signal.SIGINT, self.signal_handler)
+            signal.signal(signal.SIGTERM, self.signal_handler)
+
+
+def register_exit_handler(
+        clean_up_function,
+        at_exit: bool = True,
+        console_close: bool = True,
+        kill_signal: bool = True,
+        *args, **kwargs):
     """
     This function will register the exit handler to handle exit events: Closing the console, pressing 'CTRL+C',
     Killing the process.
 
     :param clean_up_function: The action to run when one of exit types is triggered.
+    :param at_exit: Register the atexit handler.
+        Just remember that the atexit handler will be called right away on [Ctrl+C], meaning if you want to do something
+        specifically on KeyboardInterrupt, you should handle it separately and set this parameter to False.
+        Same goes for all the exceptions.
+    :param console_close: Register the console close handler.
+    :param kill_signal: Register the kill signal handler.
     :param args: The arguments to pass to the cleanup action.
     :param kwargs: The keyword arguments to pass to the cleanup action.
     """
     global EXIT_HANDLER_INSTANCE
     EXIT_HANDLER_INSTANCE = ExitHandler(clean_up_function, args, kwargs)
-    EXIT_HANDLER_INSTANCE.register_handlers()
+    EXIT_HANDLER_INSTANCE.register_handlers(at_exit=at_exit, console_close=console_close, kill_signal=kill_signal)
 
 
 def restart_function(callable_function, *args, **kwargs):

atomicshop/print_api.py

@@ -1,4 +1,5 @@
 import sys
+import logging
 
 from .basics.ansi_escape_codes import ColorsBasic, get_colors_basic_dict
 from .basics import tracebacks
@@ -94,6 +95,20 @@ def print_api(
             from bidi.algorithm import get_display
             message = get_display(message)
 
+        if logger_method == 'error' or logger_method == 'critical':
+            error_type = True
+
+        # If exception was raised and 'stderr=True'.
+        if sys.exc_info()[0] is not None and stderr and traceback_string:
+            # If 'traceback' is set to 'True', we'll output traceback of exception.
+            if traceback_string:
+                if message:
+                    message = f'{message}\n{tracebacks.get_as_string()}{message}'
+                else:
+                    message = tracebacks.get_as_string()
+
+            color = 'red'
+
         # If 'stdcolor' is 'True', the console output will be colored.
         if stdcolor:
             # If 'logger.error' should be outputted to console, and 'color' wasn't selected, then set color to 'yellow'.
@@ -103,19 +118,22 @@ def print_api(
             elif logger_method == 'critical' and not color:
                 color = 'red'
 
-            if color:
+            if color and not logger:
                 message = get_colors_basic_dict(color) + message + ColorsBasic.END
+            elif color and logger:
+                # Save the original formatter
+                original_formatter = None
 
-        if logger_method == 'error' or logger_method == 'critical':
-            error_type = True
-
-        # If exception was raised and 'stderr=True'.
-        if sys.exc_info()[0] is not None and stderr:
-            # If 'traceback' is set to 'True', we'll output traceback of exception.
-            if traceback_string:
-                message = f'{message} | Exception: {tracebacks.get_as_string()}'
+                # Find the stream handler and change its formatter
+                for handler in logger.handlers:
+                    if isinstance(handler, logging.StreamHandler):
+                        # Save the original formatter
+                        original_formatter = handler.formatter
 
-            color = 'red'
+                        # Create a colored formatter for errors
+                        color_formatter = logging.Formatter(
+                            get_colors_basic_dict(color) + original_formatter + ColorsBasic.END)
+                        handler.setFormatter(color_formatter)
 
         # If 'online' is set to 'True', we'll output message as oneline.
         if oneline:
@@ -130,6 +148,12 @@ def print_api(
             if print_end == '\n':
                 # Use logger to output message.
                 getattr(logger, logger_method)(message)
+
+            if stdcolor:
+                # Restore the original formatter after logging
+                for handler in logger.handlers:
+                    if isinstance(handler, logging.StreamHandler):
+                        handler.setFormatter(original_formatter)
         # If logger wasn't passed.
         else:
             # Use print to output the message.

atomicshop/wrappers/loggingw/loggingw.py

@@ -1,8 +1,12 @@
 import logging
 import os
 from typing import Literal, Union
+import datetime
 
 from . import loggers, handlers
+from ...file_io import csvs
+from ...basics import tracebacks
+from ...print_api import print_api
 
 
 class LoggingwLoggerAlreadyExistsError(Exception):
@@ -258,3 +262,93 @@ def get_datetime_format_string_from_logger_file_handlers(logger: logging.Logger)
                 datetime_format_strings.append(date_time_format_string)
 
     return datetime_format_strings
+
+
+def is_logger_exists(logger_name: str) -> bool:
+    """
+    Function to check if the logger exists.
+    :param logger_name: Name of the logger.
+    :return: True if the logger exists, False if it doesn't.
+    """
+
+    return loggers.is_logger_exists(logger_name)
+
+
+class ExceptionCsvLogger:
+    def __init__(
+            self,
+            logger_name: str,
+            custom_header: str = None,
+            directory_path: str = None
+    ):
+        """
+        Initialize the ExceptionCsvLogger object.
+
+        :param logger_name: Name of the logger.
+        :param custom_header: Custom header to write to the log file.
+            If None, the default header will be used: "timestamp,exception", since that what is written to the log file.
+            If you want to add more columns to the csv file, you can provide a custom header:
+                "custom1,custom2,custom3".
+            These will be added to the default header as:
+                "timestamp,custom1,custom2,custom3,exception".
+        :param directory_path: Directory path where the log file will be saved.
+            You can leave it as None, but if the logger doesn't exist, you will get an exception.
+        """
+
+        if custom_header:
+            self.header = f"timestamp,{custom_header},exception"
+        else:
+            self.header = "timestamp,exception"
+
+        if is_logger_exists(logger_name):
+            self.logger = get_logger_with_level(logger_name)
+        else:
+            if directory_path is None:
+                raise ValueError("You need to provide 'directory_path' if the logger doesn't exist.")
+
+            self.logger = create_logger(
+                logger_name=logger_name,
+                directory_path=directory_path,
+                file_type="csv",
+                add_timedfile=True,
+                formatter_filehandler='MESSAGE',
+                header=self.header)
+
+    def write(
+            self,
+            message: Union[str, Exception] = None,
+            custom_csv_string: str = None
+    ):
+        """
+        Write the message to the log file.
+
+        :param message: The message to write to the log file.
+            If None, the message will be retrieved from current traceback frame.
+        :param custom_csv_string: Custom CSV string to add between the timestamp and the exception.
+            Currently, without the 'custom_csv_string', the csv line written as "timestamp,exception" as the header.
+            If you add a 'custom_csv_string', the csv line will be written as "timestamp,custom_csv_string,exception".
+            Meaning, that you need to provide the 'custom_header' during the initialization of the object.
+            Off course, you can use as many commas as you need in the 'custom_csv_string': "custom1,custom2,custom3".
+            This need to be mirrored in the 'custom_header' as well: "custom1,custom2,custom3".
+        """
+
+        if message is None or isinstance(message, Exception):
+            message = tracebacks.get_as_string()
+
+        if custom_csv_string:
+            output_csv_line: str = csvs.escape_csv_line_to_string([datetime.datetime.now(), custom_csv_string, message])
+        else:
+            output_csv_line: str = csvs.escape_csv_line_to_string([datetime.datetime.now(), message])
+
+        # If the number of cells in the 'output_csv_line' doesn't match the number of cells in the 'header',
+        # raise an exception.
+        if (csvs.get_number_of_cells_in_string_line(output_csv_line) !=
+                csvs.get_number_of_cells_in_string_line(self.header)):
+            raise ValueError(
+                "Number of cells in the 'output_csv_line' doesn't match the number of cells in the 'header'.")
+
+        self.logger.info(output_csv_line)
+        print_api('', error_type=True, color="red", traceback_string=True)
+
+    def get_logger(self):
+        return self.logger

atomicshop/wrappers/socketw/dns_server.py

@@ -5,12 +5,14 @@ import threading
 import socket
 import logging
 from pathlib import Path
+from typing import Literal
 
 from ...print_api import print_api
 from ..loggingw import loggingw
 from ..psutilw import networks
 from ... import queues
-from ...basics import booleans
+from ...basics import booleans, tracebacks
+from ...file_io import csvs
 
 # noinspection PyPackageRequirements
 import dnslib
@@ -26,6 +28,115 @@ class DnsConfigurationValuesError(Exception):
     pass
 
 
+LOGGER_NAME: str = 'dns_traffic'
+DNS_STATISTICS_HEADER: str = (
+    'timestamp,dns_type,client_ipv4,client_port,qname,qtype,qclass,header,error')
+
+
+class DnsStatisticsCSVWriter:
+    """
+    Class to write statistics to CSV file.
+    This can be initiated at the main, and then passed to the thread worker function.
+    """
+    def __init__(
+            self,
+            statistics_directory_path: str
+    ):
+        self.csv_logger = loggingw.create_logger(
+            logger_name=LOGGER_NAME,
+            directory_path=statistics_directory_path,
+            add_timedfile=True,
+            formatter_filehandler='MESSAGE',
+            file_type='csv',
+            header=DNS_STATISTICS_HEADER
+        )
+
+    def write_row(
+            self,
+            client_address: tuple,
+            timestamp=None,
+            dns_type: Literal['request', 'response'] = None,
+            dns_request = None,
+            dns_response = None,
+            error: str = None,
+    ):
+        if not timestamp:
+            timestamp = datetime.datetime.now()
+
+        if not dns_type:
+            if not dns_request and not dns_response:
+                raise ValueError("Either DNS Request or DNS Response must be provided.")
+            elif dns_request and dns_response:
+                raise ValueError("Either DNS Request or DNS Response must be provided. Not both.")
+
+        if dns_request:
+            dns_type = 'request'
+        elif dns_response:
+            dns_type = 'response'
+
+        if dns_type not in ['request', 'response']:
+            raise ValueError(f"DNS Type can be only 'request' or 'response'. Provided: {dns_type}")
+
+        client_ipv4, client_port = client_address
+        client_ipv4: str
+        client_port: str = str(client_port)
+
+        qname: str = str()
+        qtype: str = str()
+        qclass: str = str()
+        rr: str = str()
+        header: str = str()
+
+        if dns_request:
+            qname = str(dns_request.q.qname)[:-1]
+            qtype = dnslib.QTYPE[dns_request.q.qtype]
+            qclass = dnslib.CLASS[dns_request.q.qclass]
+
+        if dns_response:
+            qname = str(dns_response.q.qname)[:-1]
+            qtype = dnslib.QTYPE[dns_response.q.qtype]
+            qclass = dnslib.CLASS[dns_response.q.qclass]
+            rr: str = str(dns_response.rr)
+            header = str(dns_response.header)
+
+        escaped_line_string: str = csvs.escape_csv_line_to_string([
+            timestamp,
+            dns_type,
+            client_ipv4,
+            client_port,
+            qname,
+            qtype,
+            qclass,
+            rr,
+            header,
+            error
+        ])
+
+        self.csv_logger.info(escaped_line_string)
+
+    def write_error(
+            self,
+            dns_type: Literal['request', 'response'],
+            error_message: str,
+            client_address: tuple
+    ):
+        """
+        Write the error message to the statistics CSV file.
+        This is used for easier execution, since most of the parameters will be empty on accept.
+
+        :param dns_type: Literal['request', 'response'], DNS request or response.
+        :param error_message: string, error message.
+        :param client_address: tuple, client address (IPv4, Port).
+        :return:
+        """
+
+        self.write_row(
+            dns_type=dns_type,
+            client_address=client_address,
+            error=error_message
+        )
+
+
 class DnsServer:
     """
     DnsServer class is responsible to handle DNS Requests on port 53 based on configuration and send DNS Response back.
@@ -129,13 +240,7 @@ class DnsServer:
 
         # Logger that logs all the DNS Requests and responses in DNS format. These entries will not present in
         # network log of TCP Server module.
-        self.dns_full_logger = loggingw.create_logger(
-            logger_name="dns_full",
-            directory_path=self.log_directory_path,
-            add_timedfile=True,
-            formatter_filehandler='DEFAULT',
-            backupCount=backupCount_log_files_x_days
-        )
+        self.dns_statistics_csv_writer = DnsStatisticsCSVWriter(statistics_directory_path=log_directory_path)
 
         # Check if the logger was provided, if not, create a new logger.
         if not logger:
@@ -250,20 +355,19 @@ class DnsServer:
                     client_data: bytes
                     client_address: tuple
                 except ConnectionResetError:
+                    traceback_string = tracebacks.get_as_string(one_line=True)
                     # This error happens when the client closes the connection before the server.
                     # This is not an error for a DNS Server, but we'll log it anyway only with the full DNS logger.
-                    message = "Error: to receive DNS request, An existing connection was forcibly closed"
-                    # print_api(message, logger=self.logger, logger_method='error', traceback_string=True)
-                    print_api(
-                        message, logger=self.dns_full_logger, logger_method='error', traceback_string=True)
-                    self.dns_full_logger.info("==========")
+                    message = (f"Error: to receive DNS request, An existing connection was forcibly closed | "
+                               f"{traceback_string}")
+                    self.dns_statistics_csv_writer.write_error(
+                        dns_type='request', client_address=client_address, error_message=message)
                     pass
                     continue
                 except Exception:
                     message = "Unknown Exception: to receive DNS request"
                     print_api(
                         message, logger=self.logger, logger_method='critical', traceback_string=True)
-                    self.logger.info("==========")
                     pass
                     continue
 
@@ -297,26 +401,18 @@ class DnsServer:
                     # "dns_object.q.qname" returns only the questioned domain with "." (dot) in the end,
                     # which needs to be removed.
                     question_domain: str = str(dns_object.q.qname)[:-1]
-                    self.dns_full_logger.info(f"QCLASS: {qclass_string}")
-                    self.dns_full_logger.info(f"QTYPE: {qtype_string}")
-                    self.dns_full_logger.info(f"Question Domain: {question_domain}")
+                    self.dns_statistics_csv_writer.write_row(client_address=client_address, dns_request=dns_object)
 
                     message = (f"Received DNS request: {question_domain} | {qclass_string} | {qtype_string} |   "
                                f"From: {client_address}.")
                     self.logger.info(message)
-                    self.dns_full_logger.info(message)
-
-                    self.dns_full_logger.info("--")
 
                     # Nullifying the DNS cache for current request before check.
                     dns_cached_request = False
                     # Check if the received data request from client is already in the cache
                     if client_data in self.dns_questions_to_answers_cache:
-                        message = "!!! Question / Answer is already in the dictionary..."
+                        # message = "!!! Question / Answer is already in the dictionary..."
                         # self.logger.info(message)
-                        self.dns_full_logger.info(message)
-
-                        self.dns_full_logger.info("--")
 
                         # Get the response from the cached answers list
                         dns_response = self.dns_questions_to_answers_cache[client_data]
@@ -395,7 +491,6 @@ class DnsServer:
                                         message = f"!!! Question / Answer is in offline mode returning " \
                                                   f"{self.offline_route_ipv6}."
                                         self.logger.info(message)
-                                        self.dns_full_logger.info(message)
 
                                     # SRV Record type explanation:
                                     # https://www.cloudflare.com/learning/dns/dns-records/dns-srv-record/
@@ -412,7 +507,6 @@ class DnsServer:
                                         message = f"!!! Question / Answer is in offline mode returning: " \
                                                   f"{self.offline_srv_answer}."
                                         self.logger.info(message)
-                                        self.dns_full_logger.info(message)
                                     elif qtype_string == "ANY":
                                         dns_built_response.add_answer(
                                             *RR.fromZone(question_domain + " " + str(self.response_ttl) + " CNAME " +
@@ -422,7 +516,6 @@ class DnsServer:
                                         message = f"!!! Question / Answer is in offline mode returning " \
                                                   f"{self.offline_route_domain}."
                                         self.logger.info(message)
-                                        self.dns_full_logger.info(message)
                                     else:
                                         dns_built_response.add_answer(
                                             *RR.fromZone(
@@ -433,7 +526,6 @@ class DnsServer:
                                         message = f"!!! Question / Answer is in offline mode returning " \
                                                   f"{self.offline_route_ipv4}."
                                         self.logger.info(message)
-                                        self.dns_full_logger.info(message)
                                 # Values error means in most cases that you create wrong response
                                 # for specific type of request.
                                 except ValueError:
@@ -450,18 +542,14 @@ class DnsServer:
                                 except Exception:
                                     message = \
                                         (f"Unknown exception while creating response for QTYPE: {qtype_string}. "
-                                         f"Response: ")
+                                         f"Response: \n{dns_built_response}")
                                     print_api(message, logger=self.logger, logger_method='critical',
                                               traceback_string=True)
-                                    print_api(f"{dns_built_response}", logger=self.logger, logger_method='critical',
-                                              traceback_string=True)
                                     # Pass the exception.
                                     pass
                                     # Continue to the next DNS request, since there's nothing to do here right now.
                                     continue
 
-                                self.dns_full_logger.info("--")
-
                                 # Encode the response that was built above to legit DNS Response
                                 dns_response = dns_built_response.pack()
                             # If we're in online mode
@@ -476,7 +564,7 @@ class DnsServer:
                                     # Since, it's probably going to succeed.
                                     if counter > 0:
                                         self.logger.info(f"Retry #: {counter}/{self.dns_service_retries}")
-                                    self.dns_full_logger.info(
+                                    self.logger.info(
                                         f"Forwarding request. Creating UDP socket to: "
                                         f"{self.forwarding_dns_service_ipv4}:"
                                         f"{self.forwarding_dns_service_port}")
@@ -486,7 +574,7 @@ class DnsServer:
 
                                         message = "Socket created, Forwarding..."
                                         # self.logger.info(message)
-                                        self.dns_full_logger.info(message)
+                                        self.logger.info(message)
 
                                         google_dns_ipv4_socket.sendto(client_data, (
                                             self.forwarding_dns_service_ipv4,
@@ -495,7 +583,7 @@ class DnsServer:
                                         # The script needs to wait a second or receive can hang
                                         message = "Request sent to the forwarding DNS, Receiving the answer..."
                                         # self.logger.info(message)
-                                        self.dns_full_logger.info(message)
+                                        self.logger.info(message)
 
                                         dns_response, google_address = \
                                             google_dns_ipv4_socket.recvfrom(self.buffer_size_receive)
@@ -516,7 +604,6 @@ class DnsServer:
                                                 f"Couldn't forward DNS request to: "
                                                 f"[{self.forwarding_dns_service_ipv4}]. "
                                                 f"Continuing to next request.")
-                                            self.dns_full_logger.info("==========")
 
                                         # From here continue to the next iteration of While loop.
                                         continue
@@ -529,12 +616,12 @@ class DnsServer:
                                 if retried:
                                     continue
 
-                                self.dns_full_logger.info(
+                                self.logger.info(
                                     f"Answer received from: {self.forwarding_dns_service_ipv4}")
 
                                 # Closing the socket to forwarding service
                                 google_dns_ipv4_socket.close()
-                                self.dns_full_logger.info("Closed socket to forwarding service")
+                                self.logger.info("Closed socket to forwarding service")
 
                                 # Appending current DNS Request and DNS Answer to the Cache
                                 self.dns_questions_to_answers_cache.update({client_data: dns_response})
@@ -542,14 +629,15 @@ class DnsServer:
                     # If 'forward_to_tcp_server' it means that we built the response, and we don't need to reparse it,
                     # since we already have all the data.
                     if forward_to_tcp_server:
-                        self.dns_full_logger.info(f"Response IP: {dns_built_response.short()}")
-                        self.logger.info(f"Response {dns_built_response.short()}")
+                        # self.logger.info(f"Response {dns_built_response.short()}")
+                        self.dns_statistics_csv_writer.write_row(
+                            client_address=client_address, dns_response=dns_built_response)
 
                         message = f"Response Details: {dns_built_response.rr}"
-                        print_api(message, logger=self.dns_full_logger, logger_method='info', oneline=True)
+                        print_api(message, logger=self.logger, logger_method='info', oneline=True)
 
-                        message = f"Response Full Details: {dns_built_response.format(prefix='', sort=True)}"
-                        print_api(message, logger=self.dns_full_logger, logger_method='info', oneline=True)
+                        # message = f"Response Full Details: {dns_built_response.format(prefix='', sort=True)}"
+                        # print_api(message, logger=self.logger, logger_method='info', oneline=True)
 
                         # Now we can turn it to false, so it won't trigger this
                         # condition next time if the response was not built
@@ -569,20 +657,23 @@ class DnsServer:
                         if dns_response_parsed.rr:
                             for rr in dns_response_parsed.rr:
                                 if isinstance(rr.rdata, A):
-                                    self.dns_full_logger.info(f"Response IP: {rr.rdata}")
+                                    self.dns_statistics_csv_writer.write_row(
+                                        client_address=client_address, dns_response=dns_response_parsed)
+
+                                    self.logger.info(f"Response IP: {rr.rdata}")
 
                                     # Adding the address to the list as 'str' object and not 'dnslib.dns.A'.
                                     ipv4_addresses.append(str(rr.rdata))
 
-                        message = f"Response Details: {dns_response_parsed.rr}"
-                        print_api(message, logger=self.dns_full_logger, logger_method='info', oneline=True)
-
-                        message = f"Response Full Details: {dns_response_parsed}"
-                        print_api(message, logger=self.dns_full_logger, logger_method='info', oneline=True)
+                        # message = f"Response Details: {dns_response_parsed.rr}"
+                        # print_api(message, logger=self.dns_statistics_csv_writer, logger_method='info', oneline=True)
+                        #
+                        # message = f"Response Full Details: {dns_response_parsed}"
+                        # print_api(message, logger=self.dns_statistics_csv_writer, logger_method='info', oneline=True)
 
-                    self.dns_full_logger.info("Sending DNS response back to client...")
+                    self.logger.info("Sending DNS response back to client...")
                     main_socket_object.sendto(dns_response, client_address)
-                    self.dns_full_logger.info("DNS Response sent...")
+                    self.logger.info("DNS Response sent...")
 
                     # 'ipv4_addresses' list contains entries of type 'dnslib.dns.A' and not string.
                     # We'll convert each entry to string, so strings can be searched in this list.
@@ -661,9 +752,9 @@ class DnsServer:
                                 ) as output_file:
                                     output_file.write(record_string_line)
 
-                                self.dns_full_logger.info(
-                                    f"Saved new known domains file: "
-                                    f"{self.log_directory_path}{os.sep}{self.known_domains_filename}")
+                                # self.logger.info(
+                                #     f"Saved new known domains file: "
+                                #     f"{self.log_directory_path}{os.sep}{self.known_domains_filename}")
 
                     # Known domain list managements EOF
                     # ==================================================================================================
@@ -720,9 +811,9 @@ class DnsServer:
                                     ) as output_file:
                                         output_file.write(record_string_line)
 
-                                    self.dns_full_logger.info(
-                                        f"Saved new known IPv4 addresses file: "
-                                        f"{self.log_directory_path}{os.sep}{self.known_ipv4_filename}")
+                                    # self.logger.info(
+                                    #     f"Saved new known IPv4 addresses file: "
+                                    #     f"{self.log_directory_path}{os.sep}{self.known_ipv4_filename}")
 
                     # Known IPv4 address to domains list management EOF
                     # ==================================================================================================
@@ -743,7 +834,7 @@ class DnsServer:
                     # EOF Writing IPs by time.
                     # ==================================================================================================
 
-                    self.dns_full_logger.info("==========")
+                    # self.logger.info("==========")
                 except Exception:
                     message = "Unknown Exception: to parse DNS request"
                     print_api(

atomicshop/wrappers/socketw/socket_wrapper.py

@@ -5,6 +5,7 @@ from pathlib import Path
 
 from ..psutilw import networks
 from ..certauthw import certauthw
+from ..loggingw import loggingw
 from ...script_as_string_processor import ScriptAsStringProcessor
 from ...permissions import permissions
 from ... import queues, filesystem, certificates
@@ -143,6 +144,7 @@ class SocketWrapper:
         :param ssh_pass: string, SSH password that will be used to connect to remote host.
         :param ssh_script_to_execute: string, script that will be executed to get the process name on ssh remote host.
         :param logger: logging.Logger object, logger object that will be used to log messages.
+            If not provided, logger will be created with default settings.
         :param statistics_logs_directory: string, path to directory where daily statistics.csv files will be stored.
             After you initialize the SocketWrapper object, you can get the statistics_writer object from it and use it
             to write statistics to the file in a worker thread.
@@ -219,6 +221,16 @@ class SocketWrapper:
         self.statistics_writer = statistics_csv.StatisticsCSVWriter(
             statistics_directory_path=self.statistics_logs_directory)
 
+        if not self.logger:
+            self.logger = loggingw.create_logger(
+                logger_name='SocketWrapper',
+                directory_path=self.statistics_logs_directory,
+                add_stream=True,
+                add_timedfile=True,
+                formatter_streamhandler='DEFAULT',
+                formatter_filehandler='DEFAULT'
+            )
+
         self.test_config()
 
     def test_config(self):

atomicshop/wrappers/socketw/statistics_csv.py

@@ -5,9 +5,9 @@ from ..loggingw import loggingw
 
 
 LOGGER_NAME: str = 'statistics'
-STATISTICS_HEADER: str = \
-    ('request_time_sent,tls,protocol,host,path,command,status_code,request_size_bytes,response_size_bytes,file_path,'
-     'process_cmd,error')
+STATISTICS_HEADER: str = (
+    'request_time_sent,tls,protocol,host,path,command,status_code,request_size_bytes,response_size_bytes,file_path,'
+    'process_cmd,error')
 
 
 class StatisticsCSVWriter:
@@ -19,8 +19,6 @@ class StatisticsCSVWriter:
             self,
             statistics_directory_path: str
     ):
-        self.statistics_directory_path = statistics_directory_path
-
         self.csv_logger = loggingw.create_logger(
             logger_name=LOGGER_NAME,
             directory_path=statistics_directory_path,

{atomicshop-2.16.25.dist-info → atomicshop-2.16.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.16.25
+Version: 2.16.27
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License: MIT License

{atomicshop-2.16.25.dist-info → atomicshop-2.16.27.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=pTUwA9Doe40KLzzXkZWZrr_xInKxBNkTkjXbxjBfS_A,124
+atomicshop/__init__.py,sha256=uvGTfzSHIYxELvSkSy25hxKozcYi2WpTk6bDs1_wXVs,124
 atomicshop/_basics_temp.py,sha256=6cu2dd6r2dLrd1BRNcVDKTHlsHs_26Gpw8QS6v32lQ0,3699
 atomicshop/_create_pdf_demo.py,sha256=Yi-PGZuMg0RKvQmLqVeLIZYadqEZwUm-4A9JxBl_vYA,3713
 atomicshop/_patch_import.py,sha256=ENp55sKVJ0e6-4lBvZnpz9PQCt3Otbur7F6aXDlyje4,6334
@@ -23,9 +23,9 @@ atomicshop/http_parse.py,sha256=nrf2rZcprLqtW8HVrV7TCZ1iTBcWRRy-mXIlAOzcaJs,9703
 atomicshop/inspect_wrapper.py,sha256=sGRVQhrJovNygHTydqJj0hxES-aB2Eg9KbIk3G31apw,11429
 atomicshop/ip_addresses.py,sha256=Hvi4TumEFoTEpKWaq5WNF-YzcRzt24IxmNgv-Mgax1s,1190
 atomicshop/keyboard_press.py,sha256=1W5kRtOB75fulVx-uF2yarBhW0_IzdI1k73AnvXstk0,452
-atomicshop/on_exit.py,sha256=Wf1iy2e0b0Zu7oRxrct3VkLdQ_x9B32-z_JerKTt9Z0,5493
+atomicshop/on_exit.py,sha256=Rpg2SaF0aginuO7JYwA49YJYnS8F6K2jUqhjH65WzuU,6889
 atomicshop/pbtkmultifile_argparse.py,sha256=aEk8nhvoQVu-xyfZosK3ma17CwIgOjzO1erXXdjwtS4,4574
-atomicshop/print_api.py,sha256=j0bZ9b2rFKCcr0TVx1ARraVKeEs6JaaSgIlBdndy1nI,11600
+atomicshop/print_api.py,sha256=37zugPqm04XFLmMnXxNo0bJtv1ImNSDHosPTlOuYyhw,12760
 atomicshop/process.py,sha256=PeLvyixXaCfftdUF3oMbohI1L4MdLtvQVDx2V1Tz_Rk,16662
 atomicshop/python_file_patcher.py,sha256=-uhbUX-um5k-If_XXuOfCr8wMzZ3QE6h9N8xGWw6W_o,5486
 atomicshop/python_functions.py,sha256=zJg4ogUwECxrDD7xdDN5JikIUctITM5lsyabr_ZNsRw,4435
@@ -114,7 +114,7 @@ atomicshop/etws/traces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 atomicshop/etws/traces/trace_dns.py,sha256=WvOZm7KNdP4r6ofkZhUGi9WjtYlkV3mUp_yxita3Qg4,6399
 atomicshop/etws/traces/trace_sysmon_process_creation.py,sha256=OM-bkK38uYMwWLZKNOTDa0Xdk3sO6sqsxoMUIiPvm5g,4656
 atomicshop/file_io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/file_io/csvs.py,sha256=oZiaIEd1q50ypNdd9mlHWb-f7HAdGa_D6jLd3T_4sWU,8777
+atomicshop/file_io/csvs.py,sha256=XFZ-kvg2nWLXUpFh_FyPwOXB_TYLFRrHpS5hWMblTi8,9353
 atomicshop/file_io/docxs.py,sha256=ffJhnmM_WyD8mCoq2dGdpfahdIrGTPy96QVlH5EWjeI,5754
 atomicshop/file_io/file_io.py,sha256=IVqs0Kd7PV8O-NH9321hK_IvPqWx2z_45zdDtqgw4II,7113
 atomicshop/file_io/jsons.py,sha256=q9ZU8slBKnHLrtn3TnbK1qxrRpj5ZvCm6AlsFzoANjo,5303
@@ -122,15 +122,15 @@ atomicshop/file_io/tomls.py,sha256=ol8EvQPf9sryTmZUf1v55BYSUQ6ml7HVVBHpNKbsIlA,9
 atomicshop/file_io/xlsxs.py,sha256=v_dyg9GD4LqgWi6wA1QuWRZ8zG4ZwB6Dz52ytdcmmmI,2184
 atomicshop/file_io/xmls.py,sha256=zh3SuK-dNaFq2NDNhx6ivcf4GYCfGM8M10PcEwDSpxk,2104
 atomicshop/mitm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/mitm/config_static.py,sha256=UNvRTb3ZuFVGZpF33fvaIf0xw_VGyml2ExIwqW_uYcg,7777
+atomicshop/mitm/config_static.py,sha256=ROAtbibSWSsF3BraUbhu-QO3MPIFqYY5KUKgsQbiSkk,7813
 atomicshop/mitm/config_toml_editor.py,sha256=2p1CMcktWRR_NW-SmyDwylu63ad5e0-w1QPMa8ZLDBw,1635
 atomicshop/mitm/connection_thread_worker.py,sha256=rfullUfMRR5YUEI45KJdGXlbOGYF89GfPkhUBoHizhM,20297
 atomicshop/mitm/import_config.py,sha256=_nu8mgA-M4s6dZ8_QWx3x0aVb75upvsCuX_PIUg4X2w,8345
-atomicshop/mitm/initialize_engines.py,sha256=Od1vC1ZGls0BNZiPgoRQj8Mc44UO8INJj3w1p5YQw5A,8274
+atomicshop/mitm/initialize_engines.py,sha256=VyJE8QnzlgD3QbX5inz5o6rC3zQ3is9CeTL7-B10g1w,8292
 atomicshop/mitm/message.py,sha256=d_sm3O_aoZf87dDQP44xOMNEG-uZBN1ZecQgMCacbZs,1814
-atomicshop/mitm/mitm_main.py,sha256=gA8sV7hI107OnoeedCHpy8f3zcE4vAsBc44l_VTjVFo,21622
-atomicshop/mitm/recs_files.py,sha256=B8fSuvYXlh50LWfwLRw_bYswreTjmdZLuHJzbDC5Gss,2930
-atomicshop/mitm/shared_functions.py,sha256=hplm98tz8pgJ4WHUVI9sf_oVqUM2KJ1Y2pD6EFSb8P0,1879
+atomicshop/mitm/mitm_main.py,sha256=L8fcFNU_azIJepymb3JZRnfvvRIsUf1gWNcFQKeQTcs,21876
+atomicshop/mitm/recs_files.py,sha256=VjgtJF7vy365mBjctwB2bpDYoLMkEeogzF8kbb01dAk,2977
+atomicshop/mitm/shared_functions.py,sha256=jjCDZVQCwQ8hf9QNMe3T8W3ISkfZo4Mm2HtXOJLZYgI,1999
 atomicshop/mitm/statistic_analyzer.py,sha256=mBmwEe68WAjnIskGndQTRldnsAsDHuaOW0O7UXlM3Pc,26702
 atomicshop/mitm/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/engines/create_module_template.py,sha256=tRjVSm1sD6FzML71Qbuwvita0qsusdFGm8NZLsZ-XMs,4853
@@ -249,7 +249,7 @@ atomicshop/wrappers/loggingw/filters.py,sha256=CMs5PAMb68zxJgBcQobaOFDG5kLJBOVYn
 atomicshop/wrappers/loggingw/formatters.py,sha256=7XUJvlB0CK4DCkEp8NTL0S0dkyrZD0UTADgEwkStKOY,5483
 atomicshop/wrappers/loggingw/handlers.py,sha256=hAPFJQ-wFoNO8QzGrJRSvyuP09Q1F0Dl9_w7zzlgcW0,18155
 atomicshop/wrappers/loggingw/loggers.py,sha256=mmM__XR3W4QC82wbsDRG_M4_0JYGGEP0Qn0WCOSp-go,2910
-atomicshop/wrappers/loggingw/loggingw.py,sha256=nt4UxOBHL--M-Ls9b3eicffCrspYWDWG1q4ZVlHATIs,12068
+atomicshop/wrappers/loggingw/loggingw.py,sha256=oqH_u1AFyu4YG468ZDnCalRNNu2438AEYZa2MFB9iqg,16143
 atomicshop/wrappers/loggingw/reading.py,sha256=ERBSiQbEksySKpXpu2E_6k9dZ6MPH95ZIsmdjWW9MUE,16436
 atomicshop/wrappers/mongodbw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/mongodbw/install_mongodb.py,sha256=3ZPqrXxj3lC-PnAKGXclylLuOqsbyXYeUpb5iGjdeUU,6626
@@ -296,7 +296,7 @@ atomicshop/wrappers/socketw/accepter.py,sha256=hZZKVYlF3LOHQJsSIEKXZUf6QXXWm-Atq
 atomicshop/wrappers/socketw/base.py,sha256=evoOIxg5Xff3THJnrVX00D5HobaOpDp6_e_gso7TJmA,2191
 atomicshop/wrappers/socketw/certificator.py,sha256=3CpQKtcW68FSbH6LVSEZTqWBS6Yg_-3K0x4nFkId4UY,12236
 atomicshop/wrappers/socketw/creator.py,sha256=3_OraDkw2DAWZfoSdY3svCGMOIxpjLEEY7NxWd7M5P4,9873
-atomicshop/wrappers/socketw/dns_server.py,sha256=G3roqkj_gMRTkVs2kgwiQR9S7YqA-uQWraCt8FqKjlo,46375
+atomicshop/wrappers/socketw/dns_server.py,sha256=r1kWeKVoiqqNb_HpZdk0Pm3Xo-NGDkCs0_0DzMmtE8o,48954
 atomicshop/wrappers/socketw/exception_wrapper.py,sha256=B-X5SHLSUIWToihH2MKnOB1F4A81_X0DpLLfnYKYbEc,7067
 atomicshop/wrappers/socketw/get_process.py,sha256=zKEqh98cB9UDLFhtxVpperfXsCjyIMNANHilDD06p0U,6094
 atomicshop/wrappers/socketw/receiver.py,sha256=XVvWOoeCo3vA0O5p19ryi-hcDIyx382WNG7WzMNVeYk,9322
@@ -304,13 +304,13 @@ atomicshop/wrappers/socketw/sender.py,sha256=OcX1aeI2OBDPPfvQkiEcV4Ak22DSJVvjMGY
 atomicshop/wrappers/socketw/sni.py,sha256=fVwyh3h9IqfLMnf4__bMIzcF4c-Kk9mlbDWMRXKN-ow,17155
 atomicshop/wrappers/socketw/socket_client.py,sha256=hcHtOh43UhJAxYe7DSg4YVSJnCEKLRWKPiZ8DD8ite8,20237
 atomicshop/wrappers/socketw/socket_server_tester.py,sha256=Qobmh4XV8ZxLUaw-eW4ESKAbeSLecCKn2OWFzMhadk0,6420
-atomicshop/wrappers/socketw/socket_wrapper.py,sha256=M47tjC8SoXZJV2fC_OYmSNNTs-3-ZQcpaB1WmvqVCTU,33408
+atomicshop/wrappers/socketw/socket_wrapper.py,sha256=VQNvR68xj0RD_v1OL19tDZf4xRskZQjrVE6piHvRXR8,33896
 atomicshop/wrappers/socketw/ssl_base.py,sha256=kmiif84kMhBr5yjQW17p935sfjR5JKG0LxIwBA4iVvU,2275
-atomicshop/wrappers/socketw/statistics_csv.py,sha256=V_m1D0KpizQox3IEWp2AUcncwWy5kG25hbFrc-mBSJE,3029
+atomicshop/wrappers/socketw/statistics_csv.py,sha256=w1AH-zf4mBuT4euf28UKij9ihM-b1BRU9Qfby0QDdqI,2957
 atomicshop/wrappers/winregw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/winregw/winreg_network.py,sha256=bQ8Jql8bVGBJ0dt3VQ56lga_1LBOMLI3Km_otvvbU6c,7138
-atomicshop-2.16.25.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.16.25.dist-info/METADATA,sha256=z4GJ2-D1uAfF0ltaaiRvnPTbFz9vyac3kJGHf9fNH7U,10473
-atomicshop-2.16.25.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-atomicshop-2.16.25.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.16.25.dist-info/RECORD,,
+atomicshop-2.16.27.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.16.27.dist-info/METADATA,sha256=JD7sHdbqBZwiuJmXdvhYXs4qgSy5S5riQpv0m6lAMKU,10473
+atomicshop-2.16.27.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-2.16.27.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.16.27.dist-info/RECORD,,