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

atomicshop/mitm/connection_thread_worker.py

@@ -4,14 +4,13 @@ import queue
 import socket
 
 from ..wrappers.socketw import receiver, sender, socket_client, base
-from .. import websocket_parse
+from .. import websocket_parse, ip_addresses
 from ..http_parse import HTTPRequestParse, HTTPResponseParse
 from ..basics import threads, tracebacks
 from ..print_api import print_api
 
 from .message import ClientMessage
-from .initialize_engines import assign_class_by_domain
-from . import config_static
+from . import config_static, initialize_engines
 
 
 def thread_worker_main(
@@ -218,30 +217,45 @@ def thread_worker_main(
                 custom_client_pem_certificate_path = pem_file_path
                 break
 
-        # If we're on localhost, then use external services list in order to resolve the domain:
-        # config['tcp']['forwarding_dns_service_ipv4_list___only_for_localhost']
-        if client_message.client_ip in base.THIS_DEVICE_IP_LIST:
+        # Check if the destination service is an ip address or a domain name.
+        if ip_addresses.is_ip_address(client_message.server_name, ip_type='ipv4'):
+            # If it's an ip address, connect to the ip address directly.
             service_client_instance = socket_client.SocketClient(
                 service_name=client_message.server_name,
+                connection_ip=client_message.server_name,
                 service_port=client_message.destination_port,
                 tls=is_tls,
-                dns_servers_list=[config_static.DNSServer.forwarding_dns_service_ipv4],
                 logger=network_logger,
                 custom_pem_client_certificate_file_path=custom_client_pem_certificate_path,
                 enable_sslkeylogfile_env_to_client_ssl_context=(
                     config_static.Certificates.enable_sslkeylogfile_env_to_client_ssl_context)
             )
-        # If we're not on localhost, then connect to domain directly.
+        # If it's a domain name, then we'll use the DNS to resolve it.
         else:
-            service_client_instance = socket_client.SocketClient(
-                service_name=client_message.server_name,
-                service_port=client_message.destination_port,
-                tls=is_tls,
-                logger=network_logger,
-                custom_pem_client_certificate_file_path=custom_client_pem_certificate_path,
-                enable_sslkeylogfile_env_to_client_ssl_context=(
-                    config_static.Certificates.enable_sslkeylogfile_env_to_client_ssl_context)
-            )
+            # If we're on localhost, then use external services list in order to resolve the domain:
+            # config['tcp']['forwarding_dns_service_ipv4_list___only_for_localhost']
+            if client_message.client_ip in base.THIS_DEVICE_IP_LIST:
+                service_client_instance = socket_client.SocketClient(
+                    service_name=client_message.server_name,
+                    service_port=client_message.destination_port,
+                    tls=is_tls,
+                    dns_servers_list=[config_static.DNSServer.forwarding_dns_service_ipv4],
+                    logger=network_logger,
+                    custom_pem_client_certificate_file_path=custom_client_pem_certificate_path,
+                    enable_sslkeylogfile_env_to_client_ssl_context=(
+                        config_static.Certificates.enable_sslkeylogfile_env_to_client_ssl_context)
+                )
+            # If we're not on localhost, then connect to domain directly.
+            else:
+                service_client_instance = socket_client.SocketClient(
+                    service_name=client_message.server_name,
+                    service_port=client_message.destination_port,
+                    tls=is_tls,
+                    logger=network_logger,
+                    custom_pem_client_certificate_file_path=custom_client_pem_certificate_path,
+                    enable_sslkeylogfile_env_to_client_ssl_context=(
+                        config_static.Certificates.enable_sslkeylogfile_env_to_client_ssl_context)
+                )
 
         return service_client_instance
 
@@ -336,6 +350,7 @@ def thread_worker_main(
                 raise ValueError(f"Unknown side of the socket: {receiving_socket}")
 
             while True:
+                is_socket_closed: bool = False
                 # pass the socket connect to responder.
                 if side == 'Service' and client_connection_message:
                     client_message = client_connection_message
@@ -343,6 +358,8 @@ def thread_worker_main(
                     bytes_to_send_list: list[bytes] = create_responder_response(client_message)
                     print_api(f"Got responses from connect responder, count: [{len(bytes_to_send_list)}]", logger=network_logger,
                               logger_method='info')
+
+                    received_raw_data = None
                 else:
                     client_message.reinitialize_dynamic_vars()
 
@@ -362,12 +379,6 @@ def thread_worker_main(
                     #               logger_method='info')
                     # else:
 
-                    # TODO
-                    # if config_static.MainConfig.offline:
-                    #     if side == 'Client':
-                    #         # If we're in offline mode, then we'll use the offline queue to put the data for the service socket.
-                    #         offline_client_service_queue.put()
-
                     network_logger.info(
                         f"Initializing Receiver for {side} cycle: {str(current_count)}")
 
@@ -395,15 +406,22 @@ def thread_worker_main(
                     # the close on the opposite socket.
                     record_and_statistics_write(client_message)
 
-                    if is_socket_closed:
-                        exception_or_close_in_receiving_thread = True
-                        finish_thread()
-                        return
+                    # if is_socket_closed:
+                    #     exception_or_close_in_receiving_thread = True
+                    #     finish_thread()
+                    #     return
 
                     # Now send it to requester/responder.
                     if side == 'Client':
                         # Send to requester.
                         bytes_to_send_list: list[bytes] = create_requester_request(client_message)
+
+                        # If we're in offline mode, then we'll put the request to the responder right away.
+                        if config_static.MainConfig.offline:
+                            print_api("Offline Mode, sending to responder directly.", logger=network_logger,
+                                      logger_method='info')
+                            process_client_raw_data(bytes_to_send_list[0], error_message, client_message)
+                            bytes_to_send_list = create_responder_response(client_message)
                     elif side == 'Service':
                         bytes_to_send_list: list[bytes] = create_responder_response(client_message)
                         print_api(f"Got responses from responder, count: [{len(bytes_to_send_list)}]",
@@ -418,7 +436,8 @@ def thread_worker_main(
                     client_connection_message = None
                     continue
 
-                is_socket_closed: bool = False
+                # is_socket_closed: bool = False
+                error_on_send: str = str()
                 for bytes_to_send_single in bytes_to_send_list:
                     client_message.reinitialize_dynamic_vars()
                     client_message.timestamp = datetime.now()
@@ -428,11 +447,28 @@ def thread_worker_main(
                     else:
                         client_message.response_raw_bytes = bytes_to_send_single
 
-                    record_and_statistics_write(client_message)
+                    # This records the requester or responder output, only if it is not the same as the original
+                    # message.
+                    if bytes_to_send_single != received_raw_data:
+                        if side == 'Client':
+                            client_message.action = 'client_requester'
+
+                            if config_static.MainConfig.offline:
+                                client_message.action = 'client_responder_offline'
+                        elif side == 'Service':
+                            client_message.action = 'service_responder'
+                        record_and_statistics_write(client_message)
 
-                    error_on_send: str = sender.Sender(
-                        ssl_socket=sending_socket, class_message=bytes_to_send_single,
-                        logger=network_logger).send()
+                    # If we're in offline mode, it means we're in the client thread, and we'll send the
+                    # bytes back to the client socket.
+                    if config_static.MainConfig.offline:
+                        error_on_send: str = sender.Sender(
+                            ssl_socket=receiving_socket, class_message=bytes_to_send_single,
+                            logger=network_logger).send()
+                    else:
+                        error_on_send: str = sender.Sender(
+                            ssl_socket=sending_socket, class_message=bytes_to_send_single,
+                            logger=network_logger).send()
 
                     if error_on_send:
                         client_message.reinitialize_dynamic_vars()
@@ -445,11 +481,11 @@ def thread_worker_main(
 
                         record_and_statistics_write(client_message)
 
-                    # If the socket was closed on message receive, then we'll break the loop only after send.
-                    if is_socket_closed or error_on_send:
-                        exception_or_close_in_receiving_thread = True
-                        finish_thread()
-                        return
+                # If the socket was closed on message receive, then we'll break the loop only after send.
+                if is_socket_closed or error_on_send:
+                    exception_or_close_in_receiving_thread = True
+                    finish_thread()
+                    return
 
                 # For next iteration to start in case this iteration was responsible to process connection message, we need to set it to None.
                 client_connection_message = None
@@ -524,12 +560,9 @@ def thread_worker_main(
     # websocket_unmasked_frame_parser = websocket_parse.WebsocketFrameParser()
     websocket_frame_parser = websocket_parse.WebsocketFrameParser()
 
-    # Offline queue between client and service threads.
-    offline_client_service_queue: queue.Queue = queue.Queue()
-
     # 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.
-    found_domain_module = assign_class_by_domain(
+    found_domain_module = initialize_engines.assign_class_by_domain(
         engines_list=engines_list,
         message_domain_name=server_name,
         reference_module=reference_module
@@ -556,8 +589,15 @@ def thread_worker_main(
     try:
         engine_name: str = recorder.engine_name
         client_ip, source_port = client_socket.getpeername()
-        client_name = socket.gethostbyaddr(client_ip)[0]
-        destination_port = client_socket.getsockname()[1]
+        client_name: str = socket.gethostbyaddr(client_ip)[0]
+        destination_port: int = client_socket.getsockname()[1]
+        destination_port_str: str = str(destination_port)
+
+        # If the destination port is in the on_port_connect dictionary, then we'll get the port from there.
+        if destination_port_str in found_domain_module.on_port_connect:
+            on_port_connect_value = found_domain_module.on_port_connect[destination_port_str]
+            _, destination_port_str = initialize_engines.get_ipv4_from_engine_on_connect_port(on_port_connect_value)
+            destination_port: int = int(destination_port_str)
 
         if config_static.MainConfig.offline:
             # If in offline mode, then we'll get the TCP server's input address.
@@ -599,20 +639,25 @@ def thread_worker_main(
             client_thread = threading.Thread(
                 target=receive_send_start,
                 args=(client_socket, service_socket_instance, client_exception_queue, None),
-                name=f"Thread-{thread_id}-Client")
-            client_thread.daemon = True
+                name=f"Thread-{thread_id}-Client",
+                daemon=True)
             client_thread.start()
 
             service_exception_queue: queue.Queue = queue.Queue()
-            service_thread = threading.Thread(
-                target=receive_send_start,
-                args=(service_socket_instance, client_socket, service_exception_queue, client_message_connection),
-                name=f"Thread-{thread_id}-Service")
-            service_thread.daemon = True
-            service_thread.start()
+            if not config_static.MainConfig.offline:
+                service_thread = threading.Thread(
+                    target=receive_send_start,
+                    args=(service_socket_instance, client_socket, service_exception_queue, client_message_connection),
+                    name=f"Thread-{thread_id}-Service",
+                    daemon=True)
+                service_thread.start()
 
             client_thread.join()
-            service_thread.join()
+            # If we're in offline mode, then there is no service thread.
+            if not config_static.MainConfig.offline:
+                # If we're not in offline mode, then we'll wait for the service thread to finish.
+                # noinspection PyUnboundLocalVariable
+                service_thread.join()
 
             # If there was an exception in any of the threads, then we'll raise it here.
             if not client_exception_queue.empty():

atomicshop/mitm/engines/create_module_template.py

@@ -81,9 +81,12 @@ class CreateModuleTemplate:
         config_lines_list.append('[engine]')
         config_lines_list.append(f'domains = [{", ".join(domains_with_quotes)}]')
         config_lines_list.append('localhost = 1\n')
-        # config_lines_list.append(f'\n')
+        config_lines_list.append('[on_port_connect]')
+        config_lines_list.append('#5000 = "31.31.31.31"')
+        config_lines_list.append('#5000 = "C:\\test\\address.txt"\n')
         config_lines_list.append('[mtls]')
         config_lines_list.append('# "subdomain.domain.com" = "file_name_in_current_dir.pem"\n')
+        # config_lines_list.append(f'\n')
 
         config_file_path = self.new_engine_directory + os.sep + CONFIG_FILE_NAME
 

atomicshop/mitm/initialize_engines.py

@@ -1,6 +1,7 @@
 import os
 from pathlib import Path
 
+from .. import ip_addresses
 from ..file_io import tomls
 from ..basics.classes import import_first_class_name_from_file_path
 from .engines.__reference_general import parser___reference_general, requester___reference_general, \
@@ -14,7 +15,10 @@ class ModuleCategory:
 
         self.domain_list: list = list()
         self.domain_target_dict: dict = dict()
+        self.port_target_dict: dict = dict()
+
         self.is_localhost: bool = bool()
+        self.on_port_connect: dict = dict()
         self.mtls: dict = dict()
 
         self.parser_file_path: str = str()
@@ -48,6 +52,9 @@ class ModuleCategory:
         self.domain_list = configuration_data['engine']['domains']
         self.is_localhost = bool(configuration_data['engine']['localhost'])
 
+        if 'on_port_connect' in configuration_data:
+            self.on_port_connect = configuration_data['on_port_connect']
+
         if 'mtls' in configuration_data:
             self.mtls = configuration_data['mtls']
 
@@ -75,6 +82,9 @@ class ModuleCategory:
 
             self.domain_target_dict[domain] = {'ip': None, 'port': port}
 
+        for port, value in self.on_port_connect.items():
+            self.port_target_dict[port] = {'ip': None, 'port': int(port)}
+
         for subdomain, file_name in self.mtls.items():
             self.mtls[subdomain] = f'{engine_directory_path}{os.sep}{file_name}'
 
@@ -100,6 +110,47 @@ class ModuleCategory:
         return 0, ''
 
 
+def get_ipv4_from_engine_on_connect_port(
+        address_or_file_path: str
+) -> tuple[str, str] | None:
+    """
+    Function to get the IPv4 address from the engine on connect port.
+
+    :param address_or_file_path: string, "ip_address:port" or file path that was set in the engine on_port_connect.
+    :return: string, IPv4 address that was parsed from the 'ip_port_address'.
+
+    """
+
+    def get_ip_port_from_address(ip_port_address: str) -> tuple[str, str] | None:
+        """
+        Function to get the IP address and port from the address string.
+        If the address is a file path, it will return an empty string.
+        """
+        if ':' in ip_port_address:
+            ipv4_to_connect, port_to_connect = ip_port_address.split(':')
+            if ip_addresses.is_ip_address(ipv4_to_connect, ip_type='ipv4'):
+                return ipv4_to_connect, port_to_connect
+            else:
+                return None
+        else:
+            return None
+
+    # Try to get it as IP address.
+    ip_port_address_from_config = get_ip_port_from_address(address_or_file_path)
+
+    # If it is not an IP address, try to read it as a text file.
+    if not ip_port_address_from_config:
+        if os.path.isfile(address_or_file_path):
+            with open(address_or_file_path, 'r', encoding='utf-8') as file:
+                first_line = file.readline().strip()
+
+            ip_port_address_from_config = get_ip_port_from_address(first_line)
+        else:
+            return None
+
+    return ip_port_address_from_config
+
+
 def assign_class_by_domain(
         engines_list: list,
         message_domain_name: str,
@@ -133,6 +184,22 @@ def assign_class_by_domain(
                     # If the domain was found in the current list of class domains, we can stop the loop
                     break
 
+                # If the module wasn't found by the domain, check it by the port.
+                if not module:
+                    # Get the list of all the ip addresses in the on_port_connect dict.
+                    list_of_ip_addresses_per_port: list[str] = []
+                    for port, value in function_module.on_port_connect.items():
+                        ipv4_to_connect, _ = get_ipv4_from_engine_on_connect_port(value)
+                        list_of_ip_addresses_per_port.append(ipv4_to_connect)
+
+                    # Checking if the message domain name is in the list of ip addresses per port.
+                    if any(x in message_domain_name for x in list_of_ip_addresses_per_port):
+                        # Assigning module by current engine of the port
+                        module = function_module
+
+                        # If the port was found in the current list of class ports, we can stop the loop
+                        break
+
     # If none of the domains were found in the engine domains list, then we'll assign reference module.
     # It's enough to check only parser, since responder and recorder also will be empty.
     # This section is also relevant if SNI came empty in the request from the client and no domain was passed by the

atomicshop/mitm/mitm_main.py

@@ -196,6 +196,11 @@ def startup_output(system_logger, script_version: str):
         for domain, ip_port in engine.domain_target_dict.items():
             dns_targets.append(ip_port['ip'])
         print_api.print_api(f"[*] DNS Targets: {dns_targets}", logger=system_logger)
+
+        if engine.on_port_connect:
+            print_api.print_api(f"[*] Connect Ports to IPs: {list(engine.on_port_connect.values())}", logger=system_logger)
+            print_api.print_api(f"[*] Connect Ports to IPs Targets: {list(engine.port_target_dict.values())}", logger=system_logger)
+
         # print_api.print_api(f"[*] TCP Listening Interfaces: {engine.tcp_listening_address_list}", logger=system_logger)
 
     if config_static.DNSServer.enable:
@@ -235,13 +240,15 @@ def get_ipv4s_for_tcp_server():
 
     # Create a list of all the domains in all the engines.
     domains_to_create_ips_for: list[str] = list()
+    ports_to_create_ips_for: list[str] = list()
     for engine in config_static.ENGINES_LIST:
         domains_to_create_ips_for += list(engine.domain_target_dict.keys())
+        ports_to_create_ips_for += list(engine.on_port_connect.keys())
 
     engine_ips: list[str] = list()
     # Check if we need the localhost ips (12.0.0.1) or external local ips (192.168.0.100).
     if config_static.ENGINES_LIST[0].is_localhost:
-        create_ips: int = len(domains_to_create_ips_for)
+        create_ips: int = len(domains_to_create_ips_for) + len(ports_to_create_ips_for)
 
         # Generate the list of localhost ips.
         for i in range(create_ips):
@@ -288,7 +295,10 @@ def get_ipv4s_for_tcp_server():
             # If the domain is in the list of domains to create IPs for, add the IP to the engine.
             if domain in domains_to_create_ips_for:
                 engine.domain_target_dict[domain]['ip'] = engine_ips.pop(0)
-
+        for port in engine.on_port_connect.keys():
+            # If the port is in the list of ports to create IPs for, add the IP to the engine.
+            if port in ports_to_create_ips_for:
+                engine.port_target_dict[port]['ip'] = engine_ips.pop(0)
 
 def mitm_server(config_file_path: str, script_version: str):
     on_exit.register_exit_handler(exit_cleanup, at_exit=False, kill_signal=False)

atomicshop/wrappers/dockerw/dockerw.py

@@ -190,7 +190,7 @@ def stop_remove_containers_by_image_name(image_name: str):
             container_instance.stop()
         print_api(f"Removing container: [{container_instance.name}]. Short ID: [{container_instance.short_id}]")
         container_instance.remove()
-        print_api(f"Container removed: [{container_instance.name}]. Short ID: [{container_instance.short_id}]", color='green')
+        print_api(f"Container removed: [{container_instance.name}]. Short ID: [{container_instance.short_id}]", color='blue')
 
 
     client = docker.from_env()

atomicshop/wrappers/socketw/socket_wrapper.py

@@ -1,3 +1,4 @@
+import os.path
 import threading
 import select
 from typing import Literal, Union
@@ -427,8 +428,11 @@ class SocketWrapper:
         # If engines were passed, we will use the listening addresses from the engines.
         if not self.no_engine_usage_enable:
             for engine in self.engines_list:
+                # Combine the domain and port dicts.
+                connection_dict: dict = {**engine.domain_target_dict, **engine.port_target_dict}
+
                 # Start all the regular listening interfaces.
-                for domain, ip_port_dict in engine.domain_target_dict.items():
+                for domain_or_port, ip_port_dict in connection_dict.items():
                     ip_address: str = ip_port_dict['ip']
                     port = int(ip_port_dict['port'])
                     socket_by_port = self.create_socket_ipv4_tcp(ip_address, port)
@@ -511,10 +515,28 @@ class SocketWrapper:
 
                 domain_from_engine = None
                 for engine in self.engines_list:
+                    # Get the domain to connect on this process in case on no SNI provided.
                     for domain, ip_port_dict in engine.domain_target_dict.items():
                         if ip_port_dict['ip'] == listening_ip:
                             domain_from_engine = domain
                             break
+                    # If there was no domain found, try to find the IP address for port.
+                    if not domain_from_engine:
+                        for port, file_or_ip in engine.port_target_dict.items():
+                            if file_or_ip['ip'] == listening_ip:
+                                # Get the value from the 'on_port_connect' dictionary.
+                                address_or_file_path: str = engine.on_port_connect[str(listening_port)]
+                                ip_port_address_from_config: tuple = initialize_engines.get_ipv4_from_engine_on_connect_port(
+                                    address_or_file_path)
+                                if not ip_port_address_from_config:
+                                    raise ValueError(
+                                        f"Invalid IP address or file path in 'on_port_connect' for port "
+                                        f"{listening_port}: {address_or_file_path}"
+                                    )
+
+                                domain_from_engine = ip_port_address_from_config[0]
+
+                                break
 
                     self.logger.info(f"Requested domain setting: {domain_from_engine}")
 
@@ -598,6 +620,9 @@ class SocketWrapper:
                                 print_kwargs={'logger': self.logger}
                             )
 
+                        # Get the real tls version after connection is wrapped.
+                        tls_version = ssl_client_socket.version()
+
                         # If the 'domain_from_dns_server' is empty, it means that the 'engine_name' is not set.
                         # In this case we will set the 'engine_name' to from the SNI.
                         if engine_name == '':
@@ -697,8 +722,18 @@ def get_engine_name(domain: str, engine_list: list):
     :return: string, engine name.
     """
 
+    engine_name: str = ''
     for engine in engine_list:
+        # Get engine name by domain.
         if domain in engine.domain_target_dict:
-            return engine.engine_name
+            engine_name = engine.engine_name
+
+        # If didn't find by domain, try to find by port.
+        if engine_name == '':
+            for port, ip_port_to_connect_value in engine.on_port_connect.items():
+                ipv4_to_connect, _ = initialize_engines.get_ipv4_from_engine_on_connect_port(ip_port_to_connect_value)
+                if ipv4_to_connect == domain:
+                    engine_name = engine.engine_name
+                    break
 
-    return ''
+    return engine_name

atomicshop/wrappers/socketw/ssl_base.py

@@ -34,12 +34,9 @@ def is_tls(client_socket) -> Optional[Tuple[str, str]]:
 
     first_bytes = receiver.peek_first_bytes(client_socket, bytes_amount=3)
 
-    # Ensure we got enough data.
-    if len(first_bytes) < 3:
-        return None
-
-    # Extract the content type and version
-    content_type, version_major, version_minor = first_bytes
+    # Sometimes only one byte is available, so we need to handle that case.
+    # convert to a tuple of ints, add three Nones, and keep only the first 3 items.
+    content_type, version_major, version_minor = (tuple(first_bytes) + (None, None, None))[:3]
 
     # Map TLS content types to their string representation.
     content_type_map = {
@@ -52,19 +49,19 @@ def is_tls(client_socket) -> Optional[Tuple[str, str]]:
 
     # Map TLS version bytes to their string representation.
     version_map = {
-        (0x03, 0x00): "SSL 3.0",
-        (0x03, 0x01): "TLS 1.0",
-        (0x03, 0x02): "TLS 1.1",
-        (0x03, 0x03): "TLS 1.2/1.3"
+        (0x03, 0x00): "SSLv3.0",
+        (0x03, 0x01): "TLSv1.0",
+        (0x03, 0x02): "TLSv1.1",
+        (0x03, 0x03): "TLSv1.2/1.3"
         # Remember, you can't definitively differentiate 1.2 and 1.3 just from these bytes
     }
 
     # Get the tuple of the type and version as strings.
-    tls_content_and_version_tuple: tuple = \
+    tls_content_and_version_tuple: tuple[str, str] = \
         content_type_map.get(content_type), version_map.get((version_major, version_minor))
 
     # If both parts of the tuple are not None, return the protocol type.
-    if tls_content_and_version_tuple[0] and tls_content_and_version_tuple[1]:
+    if tls_content_and_version_tuple[0]:
         return tls_content_and_version_tuple
     else:
         return None

{atomicshop-3.1.13.dist-info → atomicshop-3.2.0.dist-info}/METADATA

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

{atomicshop-3.1.13.dist-info → atomicshop-3.2.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=m7-cUoalFlb_P0L7dq5ZKqms-k_BdzctCtwbbLtMGyQ,123
+atomicshop/__init__.py,sha256=ia_QL-nkKuszLHN2XwNJas4i3cauADZSyyLAKJGWcD0,122
 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
@@ -136,16 +136,16 @@ atomicshop/file_io/xmls.py,sha256=zh3SuK-dNaFq2NDNhx6ivcf4GYCfGM8M10PcEwDSpxk,21
 atomicshop/mitm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/config_static.py,sha256=N3D06C_wUytwm80PQCL90ZGHLMHeQlCcI2XQQU2FZ1I,8145
 atomicshop/mitm/config_toml_editor.py,sha256=2p1CMcktWRR_NW-SmyDwylu63ad5e0-w1QPMa8ZLDBw,1635
-atomicshop/mitm/connection_thread_worker.py,sha256=r3yKhT96oh_vyFIi858gYrpFyqIpoDwxIMAOo2S8Jl4,29385
+atomicshop/mitm/connection_thread_worker.py,sha256=E_DNvP4lbbcoeFziiG10Aa7bg7Ka09wdwV_uqaRm5rU,32554
 atomicshop/mitm/import_config.py,sha256=gCH1hV-CxBAdwjeFJu1I5ntbm5hqzcB0y0vzRPkzra0,16936
-atomicshop/mitm/initialize_engines.py,sha256=Pj9k3iLdoE0KAl3QWG1Z10LHUHY8WQivSPFnQLhCWrc,7385
+atomicshop/mitm/initialize_engines.py,sha256=N4JVoC7PXN8GxUBXvNCXS-ZA5ag6rXqYXyZ3EyHOcLM,10318
 atomicshop/mitm/message.py,sha256=CDhhm4BTuZE7oNZCjvIZ4BuPOW4MuIzQLOg91hJaxDI,3065
-atomicshop/mitm/mitm_main.py,sha256=cfQLaPaUZgluatlZDRiToi14ekZbPT2KM4-AiivTs3w,30055
+atomicshop/mitm/mitm_main.py,sha256=at9uxnXF_4b273HRXt9UGkERkHantRTOAvRtlYYI68E,30774
 atomicshop/mitm/recs_files.py,sha256=ZAAD0twun-FtmbSniXe3XQhIlawvANNB_HxwbHj7kwI,3151
 atomicshop/mitm/shared_functions.py,sha256=0lzeyINd44sVEfFbahJxQmz6KAMWbYrW5ou3UYfItvw,1777
 atomicshop/mitm/statistic_analyzer.py,sha256=5_sAYGX2Xunzo_pS2W5WijNCwr_BlGJbbOO462y_wN4,27533
 atomicshop/mitm/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/mitm/engines/create_module_template.py,sha256=Qu7ca72BsbcPrtonJM1ok7pGlwu0u6gEDap1ht6vMw0,5577
+atomicshop/mitm/engines/create_module_template.py,sha256=_1aoB-ety98szV__2jnn6cohxmrClU5mOnf6u-nq_Zc,5762
 atomicshop/mitm/engines/create_module_template_main_example.py,sha256=LeQ44Rp2Gi_KbIDY_4OMS0odkSK3zFZWra_oAka5eJY,243
 atomicshop/mitm/engines/__parent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/engines/__parent/parser___parent.py,sha256=HHaCXhScl3OlPjz6eUxsDpJaZyk6BNuDMc9xCkeo2Ws,661
@@ -224,7 +224,7 @@ atomicshop/wrappers/ctyping/msi_windows_installer/cabs.py,sha256=htzwb2ROYI8yyc8
 atomicshop/wrappers/ctyping/msi_windows_installer/extract_msi_main.py,sha256=AEkjnqEhfCbCUcYaulv3uba5hZjTB03xm-puAINsZGM,5488
 atomicshop/wrappers/ctyping/msi_windows_installer/tables.py,sha256=tHsu0YfBgzuIk9L-PyqLgU_IzyVbCfy8L1EqelNnvWk,17674
 atomicshop/wrappers/dockerw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/wrappers/dockerw/dockerw.py,sha256=DIhn3RTG3m7bJ-NTevoF1s1EeGHgi2y-m07oY5xJ_ls,10640
+atomicshop/wrappers/dockerw/dockerw.py,sha256=GgPSvXxJj15kZ-LPiaHLl8aekof53sSP_U-vUMUe7_8,10639
 atomicshop/wrappers/dockerw/install_docker.py,sha256=7NTMxCPBesr0QcqB0RZ5YU0I8FDPtNux_mYAX28wI0I,9982
 atomicshop/wrappers/elasticsearchw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/elasticsearchw/config_basic.py,sha256=fDujtrjEjbWiYh_WQ3OcYp_8mXhXPYeKLy4wSPL5qM0,1177
@@ -331,14 +331,14 @@ atomicshop/wrappers/socketw/sender.py,sha256=aX_K8l_rHjd5AWb8bi5mt8-YTkMYVRDB6Dn
 atomicshop/wrappers/socketw/sni.py,sha256=q-F-R1KtE94g8WGrR3QHgi-otXZJUPBprEwQqnY80_A,17639
 atomicshop/wrappers/socketw/socket_client.py,sha256=AQKjm_GZLH2PO7gkFbwzIbXzUXxRFvBTc6onrgapFqs,22048
 atomicshop/wrappers/socketw/socket_server_tester.py,sha256=Qobmh4XV8ZxLUaw-eW4ESKAbeSLecCKn2OWFzMhadk0,6420
-atomicshop/wrappers/socketw/socket_wrapper.py,sha256=3sEz1VUar1JJU8KxocrOT09-vIh5hLpE29aTZH9TNC8,41117
-atomicshop/wrappers/socketw/ssl_base.py,sha256=kmiif84kMhBr5yjQW17p935sfjR5JKG0LxIwBA4iVvU,2275
+atomicshop/wrappers/socketw/socket_wrapper.py,sha256=_q_QDdyQjSmc0Q0WbMDQDajqDx0_AO3IqlL78Pk4nkE,43179
+atomicshop/wrappers/socketw/ssl_base.py,sha256=62-hPm7zla1rh3m_WvDnXqKH-sDUTdiRptD8STCkgdk,2313
 atomicshop/wrappers/socketw/statistics_csv.py,sha256=WcNyaqEZ82S5-f3kzqi1nllNT2Nd2P_zg8HqCc7vW4s,4120
 atomicshop/wrappers/winregw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/winregw/winreg_installed_software.py,sha256=Qzmyktvob1qp6Tjk2DjLfAqr_yXV0sgWzdMW_9kwNjY,2345
 atomicshop/wrappers/winregw/winreg_network.py,sha256=ih0BVNwByLvf9F_Lac4EdmDYYJA3PzMvmG0PieDZrsE,9905
-atomicshop-3.1.13.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-3.1.13.dist-info/METADATA,sha256=5LMH6VMuu4OhGpNqI2y4YObNGBe0k0ZU-GeGaqZl-xM,10671
-atomicshop-3.1.13.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-atomicshop-3.1.13.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-3.1.13.dist-info/RECORD,,
+atomicshop-3.2.0.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-3.2.0.dist-info/METADATA,sha256=VKefd8URMpY8zVcDX7iiRnpIcssdPlobeUlqhIyA7HQ,10670
+atomicshop-3.2.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-3.2.0.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-3.2.0.dist-info/RECORD,,