atomicshop 2.16.44__py3-none-any.whl → 2.16.45__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.44'
+__version__ = '2.16.45'

atomicshop/archiver/search_in_archive.py

@@ -65,8 +65,9 @@ def _handle_callback_matching(
         callback_result = callback(archived_file_bytes)
         if callback_result:
             # Initialize key for callback function name if not present
-            if callback.__name__ not in results:
-                results[callback.__name__] = []
+            if _get_callback_name(callback) not in results:
+                results[_get_callback_name(callback)]: dict = {}
+                results[_get_callback_name(callback)]['files']: list = []
 
             if archive_type == 'zip':
                 file_info = {
@@ -82,7 +83,8 @@ def _handle_callback_matching(
                     'size': item.uncompressed,
                     'modified_time': item.creationtime
                 }
-            results[callback.__name__].append(file_info)
+            results[_get_callback_name(callback)]['files'].append(file_info)
+            results[_get_callback_name(callback)]['callable_result'] = callback_result
             if return_first_only:
                 found_set.add(item.filename)
             return True
@@ -149,11 +151,42 @@ def _search_in_archive(
             break  # All files found, stop searching
 
 
-def _initialize_results(callback_functions):
-    if callback_functions:
-        return {callback.__name__: [] for callback in callback_functions}
+def _get_callback_name(callback: callable) -> str:
+    """
+    Get the name of the callback function.
+    :param callback: callable.
+    :return: string, the name of the callback function. If the function is part of the class, the name will be
+        'class_name.function_name', if not the only the function name will be returned.
+    """
+    try:
+        class_name = callback.__self__.__class__.__name__
+    except AttributeError:
+        class_name = None
+
+    function_name = callback.__name__
+
+    if class_name:
+        return f"{class_name}.{function_name}"
     else:
-        return {}
+        return function_name
+
+
+# def _initialize_results(callback_functions: list[callable]) -> dict:
+#     """
+#     Initialize the results dictionary.
+#     :param callback_functions:
+#     :return:
+#     """
+#     if callback_functions:
+#         result_dict: dict = {}
+#         for callback in callback_functions:
+#             result_dict[_get_callback_name(callback)]: dict = {}
+#             result_dict[_get_callback_name(callback)]['files']: list = []
+#             result_dict[_get_callback_name(callback)]['callable_result']: any = None
+#
+#         return result_dict
+#     else:
+#         return {}
 
 
 def _get_archive_type(file_object) -> Union[str, None]:
@@ -212,7 +245,7 @@ def search_file_in_archive(
         recursive: bool = False,
         callback_functions: list = None,
         extract_file_to_path: str = None
-) -> dict[str, list[bytes]]:
+) -> dict[list[bytes], str]:
     """
     Function searches for the file names inside the zip file and returns a dictionary where the keys are the
     names of the callback functions and the values are lists of found file bytes.
@@ -236,7 +269,8 @@ def search_file_in_archive(
         raise ValueError("Either file_names_to_search or callback_functions must be provided.")
 
     # Initialize results dictionary.
-    results = _initialize_results(callback_functions)
+    # results = _initialize_results(callback_functions)
+    results: dict[list[bytes], str] = {}
     found_set = set()
 
     _search_archive_content(

atomicshop/basics/classes.py

@@ -1,8 +1,10 @@
 import os
 import sys
 import ast
-import importlib
 from pathlib import Path
+import pkgutil
+import importlib
+import inspect
 
 from ..file_io.file_io import read_file
 
@@ -26,6 +28,63 @@ class ParserParent:
 """
 
 
+def get_list_of_classes_in_module(
+        imported_package,
+        imported_base_class
+) -> list:
+    """
+    Function that returns a list of classes that are subclasses of the imported_base_class from the imported_package.
+
+    Example:
+        # Package structure:
+        # unpackers
+        # ├── __init__.py
+        # ├── unpacker_base.py
+        # ├── unpacker_1.py
+        # ├── unpacker_2.py
+        # ├── unpacker_3.py
+        # └── ... (other unpacker modules)
+
+        # unpacker_base.py:
+        from abc import abstractmethod
+        class Unpacker:
+            @abstractmethod
+            def unpack(self, file_path):
+                pass
+
+        # unpacker_1.py:
+        from unpackers.unpacker_base import Unpacker
+        class Unpacker1(Unpacker):
+            def unpack(self, file_path):
+                print(f"Unpacking file with Unpacker1: {file_path}")
+
+        # main_script.py:
+        # Import the base class
+        from unpackers.unpacker_base import Unpacker
+        # Import the package
+        import unpackers
+        # Get the list of classes
+        unpacker_classes = get_list_of_classes_in_module(imported_package=unpackers, imported_base_class=Unpacker)
+
+    :param imported_package:
+    :param imported_base_class:
+    :return:
+    """
+    unpacker_classes = []
+
+    # Iterate over all modules in the 'imported_package' package
+    for loader, module_name, is_pkg in pkgutil.iter_modules(imported_package.__path__):
+        # Import the module
+        module = importlib.import_module(f"{imported_package.__name__}.{module_name}")
+
+        # Inspect module members to find Unpacker subclasses
+        for name, obj in inspect.getmembers(module, inspect.isclass):
+            if issubclass(obj, imported_base_class) and obj is not imported_base_class:
+                unpacker_classes.append(obj)
+
+    return unpacker_classes
+
+
 def create_empty_class():
     """
     Function creates empty class, you can add parameters to it dynamically.

atomicshop/mitm/connection_thread_worker.py

@@ -1,6 +1,7 @@
 from datetime import datetime
 
 from ..wrappers.socketw import receiver, sender, socket_client, base
+from .. import websocket_parse
 from ..http_parse import HTTPRequestParse, HTTPResponseParse
 from ..basics import threads, tracebacks
 from ..print_api import print_api
@@ -65,6 +66,7 @@ def thread_worker_main(
             raise ValueError(f"Error in statistics error list. Values: {statistics_error_list}")
 
         statistics_writer.write_row(
+            thread_id=str(thread_id),
             host=client_message.server_name,
             tls_type=tls_type,
             tls_version=tls_version,
@@ -92,12 +94,15 @@ def thread_worker_main(
 
     def parse_http():
         nonlocal error_message
+        nonlocal protocol
         # Parsing the raw bytes as HTTP.
         request_decoded, is_http_request, request_parsing_info, request_parsing_error = (
             HTTPRequestParse(client_message.request_raw_bytes).parse())
 
         if is_http_request:
-            client_message.protocol = 'HTTP'
+            if protocol == '':
+                protocol = 'HTTP'
+
             client_message.request_raw_decoded = request_decoded
             print_api(request_parsing_info, logger=network_logger, logger_method='info')
             network_logger.info(f"Method: {request_decoded.command} | Path: {request_decoded.path}")
@@ -107,6 +112,29 @@ def thread_worker_main(
             # statistics_error_list.append(error_message)
             print_api(request_parsing_error, logger=network_logger, logger_method='error', color='yellow')
 
+        is_http_request_a_websocket()
+
+    def is_http_request_a_websocket():
+        nonlocal protocol
+
+        if protocol == 'HTTP':
+            if (client_message.request_raw_decoded and
+                    hasattr(client_message.request_raw_decoded, 'headers') and
+                    'Upgrade' in client_message.request_raw_decoded.headers):
+                if client_message.request_raw_decoded.headers['Upgrade'] == 'websocket':
+                    protocol = 'Websocket'
+
+                    network_logger.info(f'Protocol upgraded to Websocket')
+
+    def parse_websocket(raw_bytes):
+        is_deflated = websocket_parse.is_frame_deflated(raw_bytes)
+        request_decoded = websocket_frame_parser.parse_frame_bytes(raw_bytes)
+
+        return {
+            'is_deflated': is_deflated,
+            'frame': request_decoded
+        }
+
     def finish_thread():
         # At this stage there could be several times that the same socket was used to the service server - we need to
         # close this socket as well if it still opened.
@@ -141,6 +169,13 @@ def thread_worker_main(
     thread_id = threads.current_thread_id()
     client_message.thread_id = thread_id
 
+    protocol: str = str()
+    # # This is Client Masked Frame Parser.
+    # websocket_masked_frame_parser = websocket_parse.WebsocketFrameParser()
+    # # This is Server UnMasked Frame Parser.
+    # websocket_unmasked_frame_parser = websocket_parse.WebsocketFrameParser()
+    websocket_frame_parser = websocket_parse.WebsocketFrameParser()
+
     # Loading parser by domain, if there is no parser for current domain - general reference parser is loaded.
     # These should be outside any loop and initialized only once entering the thread.
     parser, responder, recorder = assign_class_by_domain(
@@ -201,6 +236,12 @@ def thread_worker_main(
                 client_message.request_raw_bytes = client_received_raw_data
 
                 parse_http()
+                if protocol != '':
+                    client_message.protocol = protocol
+
+                # Parse websocket frames only if it is not the first protocol upgrade request.
+                if protocol == 'Websocket' and cycle_count != 0:
+                    client_message.request_raw_decoded = parse_websocket(client_message.request_raw_bytes)
 
                 # Custom parser, should parse HTTP body or the whole message if not HTTP.
                 parser_instance = parser(client_message)
@@ -219,6 +260,12 @@ def thread_worker_main(
                     # Re-initiate the 'client_message.response_list_of_raw_bytes' list, since we'll be appending
                     # new entries for empty list.
                     client_message.response_list_of_raw_bytes = list()
+
+                    # If it's the first cycle and the protocol is Websocket, then we'll create the HTTP Handshake
+                    # response automatically.
+                    if protocol == 'Websocket' and cycle_count == 0:
+                        client_message.response_list_of_raw_bytes.append(
+                            websocket_parse.create_byte_http_response(client_message.request_raw_bytes))
                     # Creating response for parsed message and printing
                     responder.create_response(client_message)
 
@@ -283,9 +330,14 @@ def thread_worker_main(
 
                         if is_http_response:
                             client_message.response_list_of_raw_decoded.append(response_raw_decoded)
+                        elif protocol == 'Websocket' and cycle_count != 0:
+                            response_decoded = parse_websocket(response_raw_bytes)
+                            client_message.response_list_of_raw_decoded.append(response_decoded)
                         else:
                             client_message.response_list_of_raw_decoded.append(None)
 
+
+
                     # So if the socket was closed and there was an error we can break the loop
                     if not service_ssl_socket:
                         record_and_statistics_write()

atomicshop/mitm/engines/__parent/recorder___parent.py

@@ -47,9 +47,9 @@ class RecorderParent:
         self.build_record_path_to_engine()
 
         # 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 + self.file_extension
+        self.record_file_path: str = (
+            f"{self.engine_record_path}{os.sep}{day_time_format}_"
+            f"{self.class_client_message.server_name}{self.file_extension}")
 
     def convert_messages(self):
         """

atomicshop/websocket_parse.py

@@ -59,78 +59,106 @@ def create_byte_http_response(
         raise ValueError("The event is not a Request object.")
 
 
-def parse_frame_bytes(data_bytes: bytes):
-    # Define the read_exact function
-    def read_exact(n: int) -> Generator[None, None, bytes]:
-        return reader.read_exact(n)
-
-    # Helper function to run generator-based coroutines
-    def run_coroutine(coroutine):
-        try:
-            while True:
-                next(coroutine)
-        except StopIteration as e:
-            return e.value
-        except Exception as e:
-            raise e  # Re-raise exceptions to be handled by the caller
-
-    # Function to parse frames
-    def parse_frame(mask: bool):
-        try:
-            # Use Frame.parse to parse the frame
-            frame_parser = Frame.parse(
-                read_exact,
-                mask=mask,  # Client frames are masked
-                max_size=None,
-                extensions=[permessage_deflate],  # Include the extension unconditionally
-            )
-            current_frame = run_coroutine(frame_parser)
-        except EOFError as e:
-            # Not enough data to parse a complete frame
-            raise e
-        except (ProtocolError, PayloadTooBig) as e:
-            print("Error parsing frame:", e)
-            raise e
-        except Exception as e:
-            print("Error parsing frame:", e)
-            raise e
-        return current_frame
-
-    def process_frame(current_frame):
-        if current_frame.opcode == Opcode.TEXT:
-            message = current_frame.data.decode('utf-8', errors='replace')
-            return message
-        elif current_frame.opcode == Opcode.BINARY:
-            return current_frame.data
-        elif current_frame.opcode == Opcode.CLOSE:
-            print("Received close frame")
-        elif current_frame.opcode == Opcode.PING:
-            print("Received ping")
-        elif current_frame.opcode == Opcode.PONG:
-            print("Received pong")
-        else:
-            raise WebsocketParseWrongOpcode("Received unknown frame with opcode:", current_frame.opcode)
-
-    # Create the StreamReader instance
-    reader = StreamReader()
-
-    # Instantiate the permessage-deflate extension
-    permessage_deflate = PerMessageDeflate(
-        remote_no_context_takeover=False,
-        local_no_context_takeover=False,
-        remote_max_window_bits=15,
-        local_max_window_bits=15,
-    )
-
-    masked = is_frame_masked(data_bytes)
+class WebsocketFrameParser:
+    def __init__(self):
+        # Instantiate the permessage-deflate extension.
+        # If a frame uses 'deflate', then the 'permessage_deflate' should be the same object during parsing of
+        # several message on the same socket. Each time 'PerMessageDeflate' is initiated, the context changes
+        # and more than one message can't be parsed.
+        self.permessage_deflate_masked = PerMessageDeflate(
+            remote_no_context_takeover=False,
+            local_no_context_takeover=False,
+            remote_max_window_bits=15,
+            local_max_window_bits=15,
+        )
 
-    # Feed the data into the reader
-    reader.feed_data(data_bytes)
+        # We need separate instances for masked (frames from client) and unmasked (frames from server).
+        self.permessage_deflate_unmasked = PerMessageDeflate(
+            remote_no_context_takeover=False,
+            local_no_context_takeover=False,
+            remote_max_window_bits=15,
+            local_max_window_bits=15,
+        )
 
-    # Parse and process frames
-    frame = parse_frame(masked)
-    result = process_frame(frame)
-    return result
+    def parse_frame_bytes(
+            self,
+            data_bytes: bytes
+    ):
+        # Define the read_exact function
+        def read_exact(n: int) -> Generator[None, None, bytes]:
+            return reader.read_exact(n)
+
+        # Helper function to run generator-based coroutines
+        def run_coroutine(coroutine):
+            try:
+                while True:
+                    next(coroutine)
+            except StopIteration as e:
+                return e.value
+            except Exception as e:
+                raise e  # Re-raise exceptions to be handled by the caller
+
+        # Function to parse frames
+        def parse_frame(mask: bool, deflate: bool):
+            try:
+                if mask:
+                    # Decide whether to include permessage-deflate extension
+                    extensions = [self.permessage_deflate_masked] if deflate else []
+                else:
+                    extensions = [self.permessage_deflate_unmasked] if deflate else []
+
+                # Use Frame.parse to parse the frame
+                frame_parser = Frame.parse(
+                    read_exact,
+                    mask=mask,  # Client frames are masked
+                    max_size=None,
+                    extensions=extensions
+                )
+                current_frame = run_coroutine(frame_parser)
+            except EOFError as e:
+                # Not enough data to parse a complete frame
+                raise e
+            except (ProtocolError, PayloadTooBig) as e:
+                print("Error parsing frame:", e)
+                raise e
+            except Exception as e:
+                print("Error parsing frame:", e)
+                raise e
+            return current_frame
+
+        def process_frame(current_frame):
+            if current_frame.opcode == Opcode.TEXT:
+                message = current_frame.data.decode('utf-8', errors='replace')
+                return message
+            elif current_frame.opcode == Opcode.BINARY:
+                return current_frame.data
+            elif current_frame.opcode == Opcode.CLOSE:
+                print("Received close frame")
+            elif current_frame.opcode == Opcode.PING:
+                print("Received ping")
+            elif current_frame.opcode == Opcode.PONG:
+                print("Received pong")
+            else:
+                raise WebsocketParseWrongOpcode("Received unknown frame with opcode:", current_frame.opcode)
+
+        # Create the StreamReader instance
+        reader = StreamReader()
+
+        masked = is_frame_masked(data_bytes)
+        deflated = is_frame_deflated(data_bytes)
+
+        # Feed the data into the reader
+        reader.feed_data(data_bytes)
+
+        # Parse and process frames
+        frame = parse_frame(masked, deflated)
+        result = process_frame(frame)
+
+        # This is basically not needed since we restart the 'reader = StreamReader()' each function execution.
+        # # After processing, reset the reader's buffer
+        # reader.buffer = b''
+
+        return result
 
 
 def create_websocket_frame(

atomicshop/wrappers/socketw/statistics_csv.py

@@ -6,7 +6,7 @@ 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,'
+    'request_time_sent,thread_id,tls,protocol,host,path,command,status_code,request_size_bytes,response_size_bytes,file_path,'
     'process_cmd,error')
 
 
@@ -30,6 +30,7 @@ class StatisticsCSVWriter:
 
     def write_row(
             self,
+            thread_id: str,
             host: str,
             tls_type: str,
             tls_version: str,
@@ -54,6 +55,7 @@ class StatisticsCSVWriter:
 
         escaped_line_string: str = csvs.escape_csv_line_to_string([
             request_time_sent,
+            thread_id,
             tls_info,
             protocol,
             host,
@@ -73,7 +75,8 @@ class StatisticsCSVWriter:
             self,
             error_message: str,
             host: str,
-            process_name: str
+            process_name: str,
+            thread_id: str = str()
     ):
         """
         Write the error message to the statistics CSV file.
@@ -82,10 +85,12 @@ class StatisticsCSVWriter:
         :param error_message: string, error message.
         :param host: string, host, the domain or IP address.
         :param process_name: process name, the command line of the process.
+        :param thread_id: integer, the id of the thread.
         :return:
         """
 
         self.write_row(
+            thread_id=thread_id,
             host=host,
             tls_type='',
             tls_version='',

atomicshop/wrappers/winregw/winreg_network.py

@@ -173,7 +173,7 @@ def get_default_dns_gateway() -> tuple[bool, list[str]]:
 
         if ' ' in interface_settings['NameServer']:
             interface_settings['NameServer'] = interface_settings['NameServer'].replace(' ', ',')
-        if ' ' in interface_settings['DhcpNameServer']:
+        if 'DhcpNameServer' in interface_settings and ' ' in interface_settings['DhcpNameServer']:
             interface_settings['DhcpNameServer'] = interface_settings['DhcpNameServer'].replace(' ', ',')
 
         if not default_dns_gateway_list:

{atomicshop-2.16.44.dist-info → atomicshop-2.16.45.dist-info}/METADATA

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

{atomicshop-2.16.44.dist-info → atomicshop-2.16.45.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=cTkolJcyCusHq9bBDXgphXYHAv5YCLiWysUXbZegGZc,124
+atomicshop/__init__.py,sha256=fBF5eT1cIzArZVWu2launQIsr0jJhGhMkV0tYXx0zf4,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
@@ -45,7 +45,7 @@ atomicshop/urls.py,sha256=aJ0NGS9qqaKeqjkkWBs80jaBBg6MYBiPuLIyPGxscVc,1557
 atomicshop/uuids.py,sha256=JSQdm3ZTJiwPQ1gYe6kU0TKS_7suwVrHc8JZDGYlydM,2214
 atomicshop/virtualization.py,sha256=LPP4vjE0Vr10R6DA4lqhfX_WaNdDGRAZUW0Am6VeGco,494
 atomicshop/web.py,sha256=GLdTXgMxg1_0UQaXC4bOvARVyuFg7SPIeJdsCHV8rNE,11662
-atomicshop/websocket_parse.py,sha256=PygRqEFnqEcPx3PNRtJoZcKN-mXvT_zighzTJR_B-Tc,14934
+atomicshop/websocket_parse.py,sha256=chqR3NSuW5Ndtclzj-46jCuQbyTh6umm1PBKvSkDzXw,16456
 atomicshop/a_installs/ubuntu/docker_rootless.py,sha256=9IPNtGZYjfy1_n6ZRt7gWz9KZgR6XCgevjqq02xk-o0,281
 atomicshop/a_installs/ubuntu/docker_sudo.py,sha256=JzayxeyKDtiuT4Icp2L2LyFRbx4wvpyN_bHLfZ-yX5E,281
 atomicshop/a_installs/ubuntu/elastic_search_and_kibana.py,sha256=yRB-l1zBxdiN6av-FwNkhcBlaeu4zrDPjQ0uPGgpK2I,244
@@ -76,7 +76,7 @@ atomicshop/addons/process_list/compiled/Win10x64/process_list.exp,sha256=cbvukIT
 atomicshop/addons/process_list/compiled/Win10x64/process_list.lib,sha256=T2Ncs0MwKlAaCq8UKFMvfQAfcJdDx-nWiHVBfglrLIU,2112
 atomicshop/archiver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/archiver/_search_in_zip.py,sha256=dd8qFSvIhcKmtnPj_uYNJFPmMwZp4tZys0kKgTw_ACw,8385
-atomicshop/archiver/search_in_archive.py,sha256=XAxa0QukkXZvPmKna8cpwBHLDEskRUtbgaW1eHvpn6w,10833
+atomicshop/archiver/search_in_archive.py,sha256=aj35JFNL4Gx1ZBfcnr5MpDhnfOWoOvmnt_ye1KhDQCI,12133
 atomicshop/archiver/sevenz_app_w.py,sha256=BWcJb4f7jZEiETDBKyNLE0f5YLFPQx6B91_ObEIXWf8,3007
 atomicshop/archiver/sevenzs.py,sha256=5i_C50-deC1Cz_GQdMGofV2jeMPbbGWAvih-QnA72cg,1370
 atomicshop/archiver/shutils.py,sha256=BomnK7zT-nQXA1z0i2R2aTv8eu88wPx7tf2HtOdbmEc,1280
@@ -86,7 +86,7 @@ atomicshop/basics/ansi_escape_codes.py,sha256=WtIkm-BjSZS5J5irDUdAMBNvdX-qXFZcTX
 atomicshop/basics/argparse_template.py,sha256=horwgSf3MX1ZgRnYxtmmQuz9OU_vKrKggF65gmjlmfg,5836
 atomicshop/basics/booleans.py,sha256=V36NaMf8AffhCom_ovQeOZlYcdtGyIcQwWKki6h7O0M,1745
 atomicshop/basics/bytes_arrays.py,sha256=tU7KF0UAFSErGNcan4Uz1GJxeIYVRuUu9sHVZHgyNnw,6542
-atomicshop/basics/classes.py,sha256=T0Bm13hKvkXG3med68ptL7XuoWiCi3TE-K5TMINDlrY,10655
+atomicshop/basics/classes.py,sha256=UayCzPs3eynI3wOzSu-2IJSmTwOB4HwPwgVI2F-7_lQ,12648
 atomicshop/basics/dicts.py,sha256=DeYHIh940pMMBrFhpXt4dsigFVYzTrlqWymNo4Pq_Js,14049
 atomicshop/basics/dicts_nested.py,sha256=StYxYnYPa0SEJr1lmEwAv5zfERWWqoULeyG8e0zRAwE,4107
 atomicshop/basics/enumerations.py,sha256=41VVQYh_vnVapggxKg2IRU5e_EiMpZzX1n1mtxvoSzM,1364
@@ -126,7 +126,7 @@ atomicshop/file_io/xmls.py,sha256=zh3SuK-dNaFq2NDNhx6ivcf4GYCfGM8M10PcEwDSpxk,21
 atomicshop/mitm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=DxHCgDtCbSQCIX80WK9hJhp3v37pMjmm-mr3y6tyJMY,17581
+atomicshop/mitm/connection_thread_worker.py,sha256=J2fYJZS1IuibvvNmeIsm4hkJMxokQFbBk9xwMGjT7YE,19958
 atomicshop/mitm/import_config.py,sha256=0Ij14aISTllTOiWYJpIUMOWobQqGofD6uafui5uWllE,9272
 atomicshop/mitm/initialize_engines.py,sha256=VyJE8QnzlgD3QbX5inz5o6rC3zQ3is9CeTL7-B10g1w,8292
 atomicshop/mitm/message.py,sha256=URR5JKSuAT8XmGIkyprEjlPW2GW4ef_gfUz_GgcFseE,2184
@@ -139,7 +139,7 @@ atomicshop/mitm/engines/create_module_template.py,sha256=tRjVSm1sD6FzML71Qbuwvit
 atomicshop/mitm/engines/create_module_template_example.py,sha256=X5xhvbV6-g9jU_bQVhf_crZmaH50LRWz3bS-faQ18ds,489
 atomicshop/mitm/engines/__parent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/engines/__parent/parser___parent.py,sha256=RK2wviepP0oeq7zuLpgkvqvTJtc0r0a7hDGWdV0dGc4,657
-atomicshop/mitm/engines/__parent/recorder___parent.py,sha256=xJ3YVa8XYwcKqCwUIEXf6_UGnCbpRsvoicUNe0WxMfs,3782
+atomicshop/mitm/engines/__parent/recorder___parent.py,sha256=mHQAvUgsRCy3pJR_ws4v_QBE9Ju5r7RmWhyJyvczyI0,3781
 atomicshop/mitm/engines/__parent/responder___parent.py,sha256=7WQeR3UmMnN74bDwn-0nz2OfhXJ3-ClXpNGUFZ7wJUE,12004
 atomicshop/mitm/engines/__reference_general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/engines/__reference_general/parser___reference_general.py,sha256=57MEPZMAjTO6xBDZ-yt6lgGJyqRrP0Do5Gk_cgCiPns,2998
@@ -312,11 +312,11 @@ atomicshop/wrappers/socketw/socket_client.py,sha256=zDX7M3KfUOn0tXR92gZ119HVFgA8
 atomicshop/wrappers/socketw/socket_server_tester.py,sha256=Qobmh4XV8ZxLUaw-eW4ESKAbeSLecCKn2OWFzMhadk0,6420
 atomicshop/wrappers/socketw/socket_wrapper.py,sha256=WtylpezgIIBuz-A6PfM0hO1sm9Exd4j3qhDXcFc74-E,35567
 atomicshop/wrappers/socketw/ssl_base.py,sha256=kmiif84kMhBr5yjQW17p935sfjR5JKG0LxIwBA4iVvU,2275
-atomicshop/wrappers/socketw/statistics_csv.py,sha256=w1AH-zf4mBuT4euf28UKij9ihM-b1BRU9Qfby0QDdqI,2957
+atomicshop/wrappers/socketw/statistics_csv.py,sha256=SDYI1cN0oaapvPeLxSXiJrelTy6xbZl-bopR0jAjVGE,3149
 atomicshop/wrappers/winregw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/wrappers/winregw/winreg_network.py,sha256=ChnVG8ZecKJ-DMF8nUHRiifWJq2M4slEwKat6FBfPfE,8685
-atomicshop-2.16.44.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.16.44.dist-info/METADATA,sha256=yeA-HD5CtX5FhTCrJG9ylhYHECkHvJL_ai4gaOnilY4,10500
-atomicshop-2.16.44.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-atomicshop-2.16.44.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.16.44.dist-info/RECORD,,
+atomicshop/wrappers/winregw/winreg_network.py,sha256=zZQfps-CdODQaTUADbHAwKHr5RUg7BLafnKWBbKaLN4,8728
+atomicshop-2.16.45.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.16.45.dist-info/METADATA,sha256=E-QukR4G1Pts-0XCHJeKddzx3V2jaC6C5eLog6UU0Kw,10500
+atomicshop-2.16.45.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-2.16.45.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.16.45.dist-info/RECORD,,