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

atomicshop/diff_check.py

@@ -54,9 +54,9 @@ class DiffChecker:
             function input for that object. So, not always you know what your object type during class initialization.
         :param check_object_display_name: string, name of the object to display in the message.
             If not specified, the provided 'check_object' will be displayed.
-        :param aggregation: boolean, if True, the object will be aggregated with other objects in the list of objects.
-            Meaning, that the object will be checked against the existing objects in the list, and if it is not
-            in the list, it will be added to the list. If it is in the list, it will be ignored.
+        #:param aggregation: boolean, if True, the object will be aggregated with other objects in the list of objects.
+        #    Meaning, that the object will be checked against the existing objects in the list, and if it is not
+        #    in the list, it will be added to the list. If it is in the list, it will be ignored.
         :param input_file_path: string, full file path for storing input file for current state of objects,
             to check later if this state isn't updated. If this variable is left empty, all the content will be saved
             in memory and input file will not be used.

atomicshop/mitm/connection_thread_worker.py

@@ -143,6 +143,124 @@ def thread_worker_main(
 
         network_logger.info("Thread Finished. Will continue listening on the Main thread")
 
+    def process_client_raw_data_request() -> bool:
+        """
+        Process the client raw data request.
+
+        :return: True if the socket should be closed, False if not.
+        """
+
+        # If the message is empty, then the connection was closed already by the other side,
+        # so we can close the socket as well.
+        # If the received message from the client is not empty, then continue.
+        if not client_received_raw_data:
+            return True
+
+        # Putting the received message to the aggregating message class.
+        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)
+        parser_instance.parse()
+
+        # Converting body parsed to string on logging, since there is no strict rule for the parameter
+        # to be string.
+        parser_instance.logger.info(f"{str(client_message.request_body_parsed)[0: 100]}...")
+
+        return False
+
+    def create_responder_response():
+        # Since we're in response mode, we'll record the request anyway, after the responder did its job.
+        client_message.info = "In Server Response Mode"
+
+        # 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)
+
+        # Output first 100 characters of all the responses in the list.
+        for response_raw_bytes_single in client_message.response_list_of_raw_bytes:
+            responder.logger.info(f"{response_raw_bytes_single[0: 100]}...")
+
+    def create_client_socket():
+        # If there is a custom certificate for the client for this domain, then we'll use it.
+        # noinspection PyTypeChecker
+        custom_client_pem_certificate_path: str = None
+        for subdomain, pem_file_path in mtls_dict.items():
+            if subdomain == client_message.server_name:
+                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:
+            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.TCPServer.forwarding_dns_service_ipv4_list___only_for_localhost),
+                logger=network_logger,
+                custom_pem_client_certificate_file_path=custom_client_pem_certificate_path
+            )
+        # 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
+            )
+
+        return service_client_instance
+
+    def process_received_response_from_service_client():
+        if client_message.error is not None:
+            statistics_error_list.append(client_message.error)
+
+        # Since we need a list for raw bytes, we'll add the 'response_raw_bytes' to our list object.
+        # But we need to re-initiate it first.
+        client_message.response_list_of_raw_bytes = list()
+        # If there was error during send or receive from the service and response was None,
+        # It means that there was no response at all because of the error.
+        if client_message.error and response_raw_bytes is None:
+            client_message.response_list_of_raw_bytes.append(None)
+        # If there was no error, but response came empty, it means that the service has closed the
+        # socket after it received the request, without sending any data.
+        elif client_message.error is None and response_raw_bytes is None:
+            client_message.response_list_of_raw_bytes.append("")
+        else:
+            client_message.response_list_of_raw_bytes.append(response_raw_bytes)
+
+        client_message.response_list_of_raw_decoded = list()
+        # Make HTTP Response parsing only if there was response at all.
+        if response_raw_bytes:
+            response_raw_decoded, is_http_response, response_parsing_error = (
+                HTTPResponseParse(response_raw_bytes).parse())
+
+            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)
+
     # Building client message object before the loop only for any exception to occurs, since we write it to
     # recording file in its current state.
     client_message: ClientMessage = ClientMessage()
@@ -172,7 +290,7 @@ def thread_worker_main(
 
     # 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(
+    parser, responder, recorder, mtls_dict = assign_class_by_domain(
         engines_usage=config_static.TCPServer.engines_usage,
         engines_list=engines_list,
         message_domain_name=server_name,
@@ -191,6 +309,7 @@ def thread_worker_main(
         network_logger.info(f"Thread Created - Client [{client_ip}:{source_port}] | "
                             f"Destination service: [{server_name}:{destination_port}]")
 
+        end_socket: bool = False
         service_client = None
         # Loop while received message is not empty, if so, close socket, since other side already closed.
         # noinspection PyTypeChecker
@@ -217,79 +336,34 @@ def thread_worker_main(
             # Getting current time of message received from client.
             client_message.request_time_received = datetime.now()
 
-            network_logger.info(f"Initializing Receiver on cycle: {str(cycle_count+1)}")
-            # Getting message from the client over the socket using specific class.
-            client_received_raw_data = receiver.Receiver(
-                ssl_socket=client_socket, logger=network_logger).receive()
-
-            # If the message is empty, then the connection was closed already by the other side,
-            # so we can close the socket as well.
-            # If the received message from the client is not empty, then continue.
-            if client_received_raw_data:
-                # Putting the received message to the aggregating message class.
-                client_message.request_raw_bytes = client_received_raw_data
+            # Peek if there is some data in the socket.
+            # This is needed to check if the client just connects without sending data, if so we need to try and
+            # receive data from the server and send it to the client.
+            # We will do it only on the first cycle, after that the connection should work as usual.
+            # Sometimes the client will execute connection without sending data, just for the server to send response.
+            is_socket_ready: bool = True
+            if cycle_count == 0:
+                is_socket_ready = receiver.is_socket_ready_for_read(client_socket)
 
-                parse_http()
-                if protocol != '':
-                    client_message.protocol = protocol
+            if is_socket_ready:
+                network_logger.info(f"Initializing Receiver on cycle: {str(cycle_count+1)}")
+                # Getting message from the client over the socket using specific class.
+                client_received_raw_data = receiver.Receiver(
+                    ssl_socket=client_socket, logger=network_logger).receive()
 
-                # 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)
-                parser_instance.parse()
-
-                # Converting body parsed to string on logging, since there is no strict rule for the parameter
-                # to be string.
-                parser_instance.logger.info(f"{str(client_message.request_body_parsed)[0: 100]}...")
+                end_socket = process_client_raw_data_request()
 
+            if not end_socket:
                 # If we're in response mode, execute responder.
                 response_raw_bytes = None
                 if config_static.TCPServer.server_response_mode:
-                    # Since we're in response mode, we'll record the request anyway, after the responder did its job.
-                    client_message.info = "In Server Response Mode"
-
-                    # 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)
-
-                    # Output first 100 characters of all the responses in the list.
-                    for response_raw_bytes in client_message.response_list_of_raw_bytes:
-                        if response_raw_bytes:
-                            responder.logger.info(f"{response_raw_bytes[0: 100]}...")
-                        else:
-                            responder.logger.info(f"Response empty...")
+                    create_responder_response()
                 # Else, we're not in response mode, then execute client connect and record section.
                 else:
                     # If "service_client" object is not defined, we'll define it.
-                    # If it's defined, then it means there's still active "ssl_socket" with connection to the service
-                    # domain.
+                    # If it's defined, then there's still active "ssl_socket" with connection to the service domain.
                     if not service_client:
-                        # 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 = socket_client.SocketClient(
-                                service_name=client_message.server_name, service_port=client_message.destination_port,
-                                tls=is_tls,
-                                dns_servers_list=(
-                                    config_static.TCPServer.forwarding_dns_service_ipv4_list___only_for_localhost),
-                                logger=network_logger
-                            )
-                        # If we're not on localhost, then connect to domain directly.
-                        else:
-                            service_client = socket_client.SocketClient(
-                                service_name=client_message.server_name, service_port=client_message.destination_port,
-                                tls=is_tls, logger=network_logger)
+                        service_client = create_client_socket()
 
                     # Sending current client message and receiving a response.
                     # If there was an error it will be passed to "client_message" object class and if not, "None" will
@@ -297,40 +371,9 @@ def thread_worker_main(
                     # If there was connection error or socket close, then "ssl_socket" of the "service_client"
                     # will be empty.
                     response_raw_bytes, client_message.error, client_message.server_ip, service_ssl_socket = (
-                        service_client.send_receive_to_service(client_message.request_raw_bytes))
-
-                    if client_message.error is not None:
-                        statistics_error_list.append(client_message.error)
-
-                    # Since we need a list for raw bytes, we'll add the 'response_raw_bytes' to our list object.
-                    # But we need to re-initiate it first.
-                    client_message.response_list_of_raw_bytes = list()
-                    # If there was error during send or receive from the service and response was None,
-                    # It means that there was no response at all because of the error.
-                    if client_message.error and response_raw_bytes is None:
-                        client_message.response_list_of_raw_bytes.append(None)
-                    # If there was no error, but response came empty, it means that the service has closed the
-                    # socket after it received the request, without sending any data.
-                    elif client_message.error is None and response_raw_bytes is None:
-                        client_message.response_list_of_raw_bytes.append("")
-                    else:
-                        client_message.response_list_of_raw_bytes.append(response_raw_bytes)
-
-                    client_message.response_list_of_raw_decoded = list()
-                    # Make HTTP Response parsing only if there was response at all.
-                    if response_raw_bytes:
-                        response_raw_decoded, is_http_response, response_parsing_error = (
-                            HTTPResponseParse(response_raw_bytes).parse())
-
-                        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)
-
+                        service_client.send_receive_to_service(client_message.request_raw_bytes, (not is_socket_ready)))
 
+                    process_received_response_from_service_client()
 
                     # So if the socket was closed and there was an error we can break the loop
                     if not service_ssl_socket:
@@ -338,8 +381,8 @@ def thread_worker_main(
                         recorded = True
                         break
 
-                # If there is a response, then send it.
-                if response_raw_bytes:
+                # If there is a response(s), then send it.
+                if client_message.response_list_of_raw_bytes:
                     # Sending response/s to client no matter if in record mode or not.
                     network_logger.info(
                         f"Sending messages to client: {len(client_message.response_list_of_raw_bytes)}")
@@ -362,7 +405,10 @@ def thread_worker_main(
 
                 record_and_statistics_write()
                 recorded = True
-            else:
+
+            # If the message is empty, then the connection was closed already by the other side, also if there will
+            # be empty response from the server, so we can close the socket as well and exceptions will be raised.
+            if end_socket:
                 # If it's the first cycle we will record the message from the client if it came empty.
                 if cycle_count == 0:
                     record_and_statistics_write()
@@ -370,6 +416,7 @@ def thread_worker_main(
                 # In other cases, we'll just break the loop, since empty message means that the other side closed the
                 # connection.
                 recorded = True
+
                 break
 
         finish_thread()

atomicshop/mitm/engines/create_module_template.py

@@ -1,4 +1,5 @@
 import os
+import argparse
 from typing import Literal
 
 from ... import filesystem
@@ -19,11 +20,17 @@ SCRIPT_DIRECTORY: str = filesystem.get_file_directory(__file__)
 ENGINES_DIRECTORY_PATH: str = filesystem.get_working_directory() + os.sep + ENGINES_DIRECTORY_NAME
 
 
+def parse_arguments():
+    parser = argparse.ArgumentParser(description='Create a new engine module template.')
+    parser.add_argument('engine_name', type=str, help='The name of the new engine.')
+    return parser.parse_args()
+
+
 class CreateModuleTemplate:
-    def __init__(self, engine_name: str, domains: list):
+    def __init__(self):
         # === Get input variables. ===
-        self.engine_name: str = engine_name
-        self.domains: list = domains
+        self.engine_name: str = parse_arguments().engine_name
+        self.domains: list = ['example.com']
 
         # New engine's directory.
         self.new_engine_directory: str = ENGINES_DIRECTORY_PATH + os.sep + self.engine_name
@@ -66,10 +73,14 @@ class CreateModuleTemplate:
 
         # Add "" to each domain.
         domains_with_quotes: list = [f'"{domain}"' for domain in self.domains]
-        config_lines_list.append(f'domains = [{", ".join(domains_with_quotes)}]\n')
-        config_lines_list.append(f'parser_file = "{self.parser_file_name}"')
-        config_lines_list.append(f'responder_file = "{self.responder_file_name}"')
-        config_lines_list.append(f'recorder_file = "{self.recorder_file_name}"')
+        config_lines_list.append(f'"domains" = [{", ".join(domains_with_quotes)}]\n')
+        # config_lines_list.append(f'\n')
+        config_lines_list.append(f'"parser_file" = "{self.parser_file_name}"')
+        config_lines_list.append(f'"responder_file" = "{self.responder_file_name}"')
+        config_lines_list.append(f'"recorder_file" = "{self.recorder_file_name}"\n')
+        # config_lines_list.append(f'\n')
+        config_lines_list.append(f'[mtls]')
+        config_lines_list.append(f'# "subdomain.domain.com" = "file_name_in_current_dir.pem"')
 
         config_file_path = self.new_engine_directory + os.sep + CONFIG_FILE_NAME
 

atomicshop/mitm/initialize_engines.py

@@ -2,15 +2,11 @@ import os
 import sys
 from pathlib import Path
 
-from .. import filesystem
 from ..file_io import tomls
 from ..basics.classes import import_first_class_name_from_file_path
-from ..wrappers.loggingw import loggingw
 from .engines.__reference_general import parser___reference_general, responder___reference_general, \
     recorder___reference_general
 
-from . import config_static
-
 
 class ModuleCategory:
     def __init__(self, script_directory: str):
@@ -29,6 +25,8 @@ class ModuleCategory:
         # The instance of the recorder class that will be initiated once in the script start
         self.responder_instance = None
 
+        self.mtls: dict = dict()
+
     def fill_engine_fields_from_general_reference(self, engines_fullpath: str):
         # Reference module variables.
         self.engine_name = '__reference_general'
@@ -47,6 +45,7 @@ class ModuleCategory:
 
         # Getting the parameters from engine config file
         self.domain_list = configuration_data['domains']
+        self.mtls = configuration_data['mtls']
 
         # If there's module configuration file, but no domains in it, there's no point to continue.
         # Since, each engine is based on domains.
@@ -54,12 +53,12 @@ class ModuleCategory:
             raise ValueError(f"Engine Configuration file doesn't contain any domains: {engine_config_file_path}")
 
         # Full path to file
-        self.parser_file_path = filesystem.get_paths_from_directory(
-            engine_directory_path, get_file=True, file_name_check_pattern=configuration_data['parser_file'])[0].path
-        self.responder_file_path = filesystem.get_paths_from_directory(
-            engine_directory_path, get_file=True, file_name_check_pattern=configuration_data['responder_file'])[0].path
-        self.recorder_file_path = filesystem.get_paths_from_directory(
-            engine_directory_path, get_file=True, file_name_check_pattern=configuration_data['recorder_file'])[0].path
+        self.parser_file_path = f'{engine_directory_path}{os.sep}{configuration_data['parser_file']}'
+        self.responder_file_path = f'{engine_directory_path}{os.sep}{configuration_data['responder_file']}'
+        self.recorder_file_path = f'{engine_directory_path}{os.sep}{configuration_data['recorder_file']}'
+
+        for subdomain, file_name in self.mtls.items():
+            self.mtls[subdomain] = f'{engine_directory_path}{os.sep}{file_name}'
 
     def initialize_engine(self, logs_path: str, logger=None, reference_general: bool = False, **kwargs):
         # Initiating logger for each engine by its name
@@ -108,6 +107,7 @@ def assign_class_by_domain(
     function_parser = None
     function_responder = None
     function_recorder = None
+    mtls_data: dict = dict()
 
     # In case SNI came empty in the request from client, then there's no point in iterating through engine domains.
     if message_domain_name:
@@ -130,6 +130,8 @@ def assign_class_by_domain(
                     function_recorder = function_module.recorder_class_object
                     # Since the responder is being initiated only once, we're assigning only the instance
                     function_responder = function_module.responder_instance
+                    mtls_data = function_module.mtls
+
 
                     logger.info(f"Assigned Modules for [{message_domain_name}]: "
                                 f"{function_module.parser_class_object.__name__}, "
@@ -151,4 +153,4 @@ def assign_class_by_domain(
         function_responder = reference_module.responder_instance
 
     # Return all the initiated modules
-    return function_parser, function_responder, function_recorder
+    return function_parser, function_responder, function_recorder, mtls_data

atomicshop/mitm/recs_files.py

@@ -1,7 +1,6 @@
 import datetime
 import os
 import multiprocessing
-from pathlib import Path
 
 from ..archiver import zips
 from .. import filesystem

atomicshop/mitm/shared_functions.py

@@ -1,8 +1,6 @@
-import json
 import inspect
 
 from ..wrappers.loggingw import loggingw
-from ..basics import dicts
 
 from . import config_static
 

atomicshop/web_apis/google_llm.py

@@ -0,0 +1,42 @@
+import os
+
+import google.generativeai as genai
+
+
+class GoogleLLM:
+    def __init__(
+            self,
+            llm_api_key: str
+    ) -> None:
+        self.genai = genai
+
+        os.environ["API_KEY"] = llm_api_key
+        genai.configure(api_key=os.environ["API_KEY"])
+
+    def get_current_models(self) -> list[str]:
+        """ Function to get the current models available in the Gemini API """
+        result_list: list[str] = []
+        for model in self.genai.list_models():
+            result_list.append(model.name)
+
+        return result_list
+
+    def get_answer_online(
+            self,
+            search_query: str,
+            additional_llm_instructions: str,
+            number_of_top_links: int = 2,
+            number_of_characters_per_link: int = 15000,
+            temperature: float = 0,
+            max_output_tokens: int = 4096
+    ):
+        """
+        Function to get the answer to a question by searching Google Custom Console API and processing the content using Gemini API.
+        :param search_query:
+        :param additional_llm_instructions:
+        :param number_of_top_links:
+        :param number_of_characters_per_link:
+        :param temperature:
+        :param max_output_tokens:
+        :return:
+        """

atomicshop/wrappers/fibratusw/install.py

@@ -40,8 +40,7 @@ def install_fibratus(
         exclude_string='slim')
 
     # Install the MSI file
-    msiw.install_msi(
-        msi_path=fibratus_setup_file_path, exit_on_error=True, as_admin=True)
+    msiw.install_msi(msi_path=fibratus_setup_file_path)
 
     count = 0
     while count != WAIT_SECONDS_FOR_EXECUTABLE_TO_APPEAR_AFTER_INSTALLATION:

atomicshop/wrappers/socketw/certificator.py

@@ -154,13 +154,16 @@ class Certificator:
                     service_name=sni_received_parameters.destination_name,
                     service_port=base.get_destination_address_from_socket(sni_received_parameters.ssl_socket)[1],
                     tls=self.tls,
-                    dns_servers_list=self.forwarding_dns_service_ipv4_list___only_for_localhost)
+                    dns_servers_list=self.forwarding_dns_service_ipv4_list___only_for_localhost,
+                    logger=print_kwargs.get('logger') if print_kwargs else None
+                )
             # If we're not on localhost, then connect to domain directly.
             else:
                 service_client = socket_client.SocketClient(
                     service_name=sni_received_parameters.destination_name,
                     service_port=base.get_destination_address_from_socket(sni_received_parameters.ssl_socket)[1],
-                    tls=self.tls
+                    tls=self.tls,
+                    logger=print_kwargs.get('logger') if print_kwargs else None
                 )
 
             # If certificate from socket exists, then we don't need to get it from the socket and write to file.

atomicshop/wrappers/socketw/creator.py

@@ -37,11 +37,26 @@ def create_ssl_context_for_client():
     return ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
 
 
-def set_client_ssl_context_default_certs(ssl_context):
-    # "load_default_certs" method is telling the client to check the local certificate storage on the system for the
-    # needed certificate of the server. Without this line you will get an error from the server that the client
-    # is using self-signed certificate. Which is partly true, since you used the SLL wrapper,
-    # but didn't specify the certificate at all.
+def set_client_ssl_context_ca_default_certs(ssl_context):
+    """
+    "load_default_certs" method is telling the client to check the local certificate storage on the system for the
+    needed certificate of the server. Without this line you will get an error from the server that the client
+    is using self-signed certificate. Which is partly true, since you used the SLL wrapper,
+    but didn't specify the certificate at all.
+    -----------------------------------------
+    https://docs.python.org/3/library/ssl.html#ssl.SSLContext.load_default_certs
+    Load a set of default “certification authority” (CA) certificates from default locations.
+    On Windows it loads CA certs from the CA and ROOT system stores.
+    On all systems it calls SSLContext.set_default_verify_paths().
+    In the future the method may load CA certificates from other locations, too.
+
+    The purpose flag specifies what kind of CA certificates are loaded.
+    The default settings Purpose.SERVER_AUTH loads certificates, that are flagged and trusted for
+    TLS web server authentication (client side sockets). Purpose.CLIENT_AUTH loads CA certificates for
+    client certificate verification on the server side.
+    -----------------------------------------
+    """
+
     # The purpose of the certificate is to authenticate on the server
     # context.load_default_certs(Purpose.SERVER_AUTH)
     # You don't have to specify the purpose to connect, but if you get a purpose error, you know where to find it
@@ -187,10 +202,26 @@ def set_listen_on_socket(socket_object, **kwargs):
 # Socket Creator Presets
 
 def wrap_socket_with_ssl_context_client___default_certs___ignore_verification(
-        socket_object, server_hostname: str = None):
+        socket_object,
+        server_hostname: str = None,
+        custom_pem_client_certificate_file_path: str = None
+):
+    """
+    This function is a preset for wrapping the socket with SSL context for the client.
+    It sets the CA default certificates, and ignores the server's certificate verification.
+
+    :param socket_object: socket.socket object
+    :param server_hostname: string, hostname of the server. Default is None.
+    :param custom_pem_client_certificate_file_path: string, full file path for the client certificate PWM file.
+        Default is None.
+    """
     ssl_context: ssl.SSLContext = create_ssl_context_for_client()
-    set_client_ssl_context_default_certs(ssl_context)
+    set_client_ssl_context_ca_default_certs(ssl_context)
     set_client_ssl_context_certificate_verification_ignore(ssl_context)
+
+    if custom_pem_client_certificate_file_path:
+        ssl_context.load_cert_chain(certfile=custom_pem_client_certificate_file_path, keyfile=None)
+
     ssl_socket: ssl.SSLSocket = wrap_socket_with_ssl_context_client(
         socket_object, ssl_context, server_hostname=server_hostname)
 

atomicshop/wrappers/socketw/receiver.py

@@ -1,6 +1,7 @@
 import logging
 import socket
 import ssl
+import select
 from pathlib import Path
 
 from ...print_api import print_api
@@ -20,6 +21,24 @@ def peek_first_bytes(client_socket, bytes_amount: int = 1) -> bytes:
     return client_socket.recv(bytes_amount, socket.MSG_PEEK)
 
 
+def is_socket_ready_for_read(client_socket, timeout: int = 0) -> bool:
+    """
+    Check if socket is ready for read.
+
+    :param client_socket: Socket object.
+    :param timeout: Timeout in seconds. The default is no timeout.
+
+    :return: True if socket is ready for read, False otherwise.
+    """
+
+    # Use select to check if the socket is ready for reading.
+    # 'readable' returns a list of sockets that are ready for reading.
+    # Since we use only one socket, it will return a list with one element if the socket is ready for reading,
+    # or an empty list if the socket is not ready for reading.
+    readable, _, _ = select.select([client_socket], [], [], timeout)
+    return bool(readable)
+
+
 class Receiver:
     """ Receiver Class is responsible for receiving the message from socket and populate the message class """
     def __init__(

atomicshop/wrappers/socketw/sender.py

@@ -6,7 +6,7 @@ from ...print_api import print_api
 from ..loggingw import loggingw
 from ...basics import tracebacks
 
-from . import base, ssl_base
+from . import base
 
 
 class Sender:

atomicshop/wrappers/socketw/sni.py

@@ -254,15 +254,13 @@ class SNIHandler:
 
         # Try on general settings in the SNI function.
         try:
-            # Check if SNI was passed.
-            if self.sni_received_parameters.destination_name:
-                service_name_from_sni = self.sni_received_parameters.destination_name
-            # If no SNI was passed.
-            else:
+            # Check if SNI was passed. If no SNI was passed.
+            if not self.sni_received_parameters.destination_name:
                 # If DNS server is enabled we'll get the domain from dns server.
                 if self.domain_from_dns_server:
-                    service_name_from_sni = self.domain_from_dns_server
-                    message = f"SNI Handler: No SNI was passed, using domain from DNS Server: {service_name_from_sni}"
+                    self.sni_received_parameters.destination_name = self.domain_from_dns_server
+                    message = \
+                        f"SNI Handler: No SNI was passed, using domain from DNS Server: {self.domain_from_dns_server}"
                     print_api(message, **(print_kwargs or {}))
                 # If DNS server is disabled, the domain from dns server will be empty.
                 else:
@@ -271,7 +269,7 @@ class SNIHandler:
                     print_api(message, **(print_kwargs or {}))
 
             # Setting "server_hostname" as a domain.
-            self.sni_received_parameters.ssl_socket.server_hostname = service_name_from_sni
+            self.sni_received_parameters.ssl_socket.server_hostname = self.sni_received_parameters.destination_name
             message = \
                 f"SNI Handler: port {self.sni_received_parameters.ssl_socket.getsockname()[1]}: " \
                 f"Incoming connection for [{self.sni_received_parameters.ssl_socket.server_hostname}]"

atomicshop/wrappers/socketw/socket_client.py

@@ -16,7 +16,7 @@ from .sender import Sender
 from . import ssl_base
 from .. import cryptographyw
 from ..loggingw import loggingw
-from ...print_api import print_api
+from ... import print_api
 from ...file_io import file_io
 from ...basics import tracebacks
 
@@ -29,7 +29,8 @@ class SocketClient:
             tls: bool = False,
             connection_ip=None,
             dns_servers_list=None,
-            logger: logging.Logger = None
+            logger: logging.Logger = None,
+            custom_pem_client_certificate_file_path: str = None
     ):
         """
         If you have a certificate for domain, but not for the IPv4 address, the SSL Socket context can be created for
@@ -47,6 +48,8 @@ class SocketClient:
         :param dns_servers_list: (Optional) List object with dns IPv4 addresses that 'service_name' will be resolved
             with, using 'dnspython' module. 'connection_ip' will be populated with first resolved IP.
         :param logger: (Optional) Logger object. If not provided, the default logger will be used.
+        :param custom_pem_client_certificate_file_path: (Optional) If specified, the SSL Socket will be created with
+            custom client certificate. The path to the file with the certificate should be provided.
 
         If both 'connection_ip' and 'dns_servers_list' specified, ValueException with raise.
         """
@@ -55,6 +58,7 @@ class SocketClient:
         self.tls: bool = tls
         self.connection_ip = connection_ip
         self.dns_servers_list = dns_servers_list
+        self.custom_pem_client_certificate_file_path: str = custom_pem_client_certificate_file_path
 
         if logger:
             # Create child logger for the provided logger with the module's name.
@@ -79,13 +83,15 @@ class SocketClient:
     def create_service_socket(self):
         # If TLS is enabled.
         if not self.tls:
-            self.logger.info(f"Creating non-SSL socket to [{self.service_name}:{self.service_port}]")
+            log_message: str = f"Creating non-SSL socket to [{self.service_name}:{self.service_port}]"
+            print_api.print_api(log_message, logger=self.logger, logger_method='info')
             return creator.create_socket_ipv4_tcp()
         else:
-            self.logger.info(f"Creating SSL socket to [{self.service_name}:{self.service_port}]")
+            log_message: str = f"Creating SSL socket to [{self.service_name}:{self.service_port}]"
+            print_api.print_api(log_message, logger=self.logger, logger_method='info')
             socket_object = creator.create_socket_ipv4_tcp()
             return creator.wrap_socket_with_ssl_context_client___default_certs___ignore_verification(
-                socket_object, self.service_name)
+                socket_object, self.service_name, self.custom_pem_client_certificate_file_path)
 
     def service_connection(
             self
@@ -141,7 +147,7 @@ class SocketClient:
                 error_string = (
                     f"Socket Client Connect: {exception_type}: "
                     f"Domain {self.service_name} doesn't exist - Couldn't resolve with {self.dns_servers_list}.")
-                print_api(error_string, logger=self.logger, logger_method='error')
+                print_api.print_api(error_string, logger=self.logger, logger_method='error')
                 return None, error_string
 
         # If DNS was resolved correctly or DNS servers weren't specified - we can try connecting.
@@ -163,16 +169,16 @@ class SocketClient:
             error_string: str = f"Socket Client Connect: {destination}: {exception_type}"
 
             if exception_type in ['ConnectionRefusedError', 'ConnectionAbortedError', 'ConnectionResetError',
-                                  'ssl.SSLError', 'TimeoutError']:
+                                  'TimeoutError'] or 'ssl' in exception_type.lower():
                 error_message: str = f"{error_string}: {exception_error}"
-                print_api(error_message, logger=self.logger, logger_method='error')
+                print_api.print_api(error_message, logger=self.logger, logger_method='error')
                 return None, error_message
             elif exception_type == 'socket.gaierror':
                 custom_error_message: str = (
                     f"Couldn't resolve [{self.service_name}] to IP using default methods. "
                     f"Domain doesn't exist or there's no IP assigned to it.")
                 error_message: str = f"{error_string}: {custom_error_message}"
-                print_api(error_message, logger=self.logger, logger_method='error')
+                print_api.print_api(error_message, logger=self.logger, logger_method='error')
                 return None, error_message
             else:
                 raise e
@@ -192,7 +198,18 @@ class SocketClient:
         self.logger.info(f"Closed socket to service server [{self.service_name}:{self.service_port}]")
 
     # noinspection PyUnusedLocal
-    def send_receive_to_service(self, request_bytes: bytearray):
+    def send_receive_to_service(
+            self,
+            request_bytes: Union[bytearray, bytes],
+            skip_send: bool = False
+    ):
+        """
+        Function to send data to service server and receive response.
+
+        :param request_bytes: The data that will be sent to the service server.
+        :param skip_send: If True, the data will not be sent to the service server. After the connection is established,
+            the function will wait for the response only.
+        """
         # Define variables
         function_service_data = None
         error_message = None
@@ -214,18 +231,22 @@ class SocketClient:
             self.logger.info(
                 f"[{self.service_name}] resolves to ip: [{self.connection_ip}]. Pulled IP from the socket.")
 
-            # Send the data received from the client to the service over socket
-            error_on_send: str = Sender(
-                ssl_socket=self.socket_instance, class_message=request_bytes, logger=self.logger).send()
+            # noinspection PyTypeChecker
+            error_on_send: str = None
+            if not skip_send:
+                # Send the data received from the client to the service over socket
+                error_on_send = Sender(
+                    ssl_socket=self.socket_instance, class_message=request_bytes, logger=self.logger).send()
 
-            # If the socket disconnected on data send
-            if error_on_send:
-                error_message = f"Service socket closed on data send: {error_on_send}"
+                # If the socket disconnected on data send
+                if error_on_send:
+                    error_message = f"Service socket closed on data send: {error_on_send}"
+
+                    # We'll close the socket and nullify the object
+                    self.close_socket()
 
-                # We'll close the socket and nullify the object
-                self.close_socket()
             # Else if send was successful
-            else:
+            if not error_on_send:
                 function_service_data = Receiver(
                     ssl_socket=self.socket_instance, logger=self.logger).receive()
 
@@ -355,7 +376,7 @@ class SocketClient:
         server_socket_for_certificate, error_message = self.service_connection()
         # Get the DER byte certificate from the socket.
         certificate_from_socket_der_bytes = ssl_base.get_certificate_from_socket(server_socket_for_certificate)
-        print_api('Fetched certificate from socket.', logger=self.logger, **kwargs)
+        print_api.print_api('Fetched certificate from socket.', logger=self.logger, **kwargs)
         # Close the socket.
         self.close_socket()
 

atomicshop/wrappers/sysmonw.py

@@ -49,7 +49,7 @@ def is_sysmon_running():
     """
 
     process_list: list = process.get_running_processes_by_cmdline_pattern(
-        pattern=SYSMON_FILE_NAME, first=True, process_name_case_insensitive=True)
+        pattern=SYSMON_FILE_NAME, first=True, cmdline_case_insensitive=True)
 
     if process_list:
         return True

{atomicshop-2.16.46.dist-info → atomicshop-2.17.0.dist-info}/METADATA

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

{atomicshop-2.16.46.dist-info → atomicshop-2.17.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=lwyRrx1298W0LP5WyV3pYJw7KJMlCtYSIh5JN2AhC58,124
+atomicshop/__init__.py,sha256=JaX16ugkhtjjNo6Te9NZk6rsS2IsN9ETiFc6wSyNBes,123
 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
@@ -9,7 +9,7 @@ atomicshop/config_init.py,sha256=50kD2lXP8sgwPekcmAbfADcY46YvXkF-6XIdA7W_638,250
 atomicshop/console_output.py,sha256=AOSJjrRryE97PAGtgDL03IBtWSi02aNol8noDnW3k6M,4667
 atomicshop/console_user_response.py,sha256=31HIy9QGXa7f-GVR8MzJauQ79E_ZqAeagF3Ks4GGdDU,3234
 atomicshop/datetimes.py,sha256=IQZ66lmta-ZqxYbyHzm_9eugbJFSilXK1e0kfMgoXGg,18371
-atomicshop/diff_check.py,sha256=Q9RCqRa-jEgo7Fujx08_JTuZ6qcgttMI6aNYB6zN9Ik,27173
+atomicshop/diff_check.py,sha256=vxTDccVbGZHEge6Ja9_ArLWwslOUgIoJAdYPylh4cZg,27176
 atomicshop/dns.py,sha256=5Gimq_WY2arqg7BeGmR7P--fGfnH0Dsh8lrOt_H0jRY,6817
 atomicshop/domains.py,sha256=Rxu6JhhMqFZRcoFs69IoEd1PtYca0lMCG6F1AomP7z4,3197
 atomicshop/emails.py,sha256=I0KyODQpIMEsNRi9YWSOL8EUPBiWyon3HRdIuSj3AEU,1410
@@ -126,16 +126,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=ROAtbibSWSsF3BraUbhu-QO3MPIFqYY5KUKgsQbiSkk,7813
 atomicshop/mitm/config_toml_editor.py,sha256=2p1CMcktWRR_NW-SmyDwylu63ad5e0-w1QPMa8ZLDBw,1635
-atomicshop/mitm/connection_thread_worker.py,sha256=ZIlGoi-uN8YxT_-f6xYO9w2IbOAg0qBa7m4T87Uu58I,19769
+atomicshop/mitm/connection_thread_worker.py,sha256=EtEp6aymfQ-btZzeZDmxLJdIortB4Gf5MOaHwEFSShI,21095
 atomicshop/mitm/import_config.py,sha256=0Ij14aISTllTOiWYJpIUMOWobQqGofD6uafui5uWllE,9272
-atomicshop/mitm/initialize_engines.py,sha256=VyJE8QnzlgD3QbX5inz5o6rC3zQ3is9CeTL7-B10g1w,8292
+atomicshop/mitm/initialize_engines.py,sha256=NWz0yBErSrYBn0xWkJDBcHStBJ-kcsv9VtorcSP9x5M,8258
 atomicshop/mitm/message.py,sha256=URR5JKSuAT8XmGIkyprEjlPW2GW4ef_gfUz_GgcFseE,2184
 atomicshop/mitm/mitm_main.py,sha256=5c-9oxBiLueTbZr4Dyd4EEOorEUix5vSWxX9p5O1fBs,23375
-atomicshop/mitm/recs_files.py,sha256=mMyO1kPB-VkS_pbWCDhZHKdbWzlPbYSout61QuzHOao,3077
-atomicshop/mitm/shared_functions.py,sha256=l6oEyv4ug5D_03V3QLADYoocbcL2Ml_dYVW2WKM21l4,1818
+atomicshop/mitm/recs_files.py,sha256=gzFuTonqcXkMvhpOj1Nwse3E8umFGrKN2H5AleMjJ3w,3051
+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=tRjVSm1sD6FzML71Qbuwvita0qsusdFGm8NZLsZ-XMs,4853
+atomicshop/mitm/engines/create_module_template.py,sha256=TAzsA4eLD2wYr7auuL4Nf_71iXqn-BOBXlSkNVrnYD4,5336
 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
@@ -175,6 +175,9 @@ atomicshop/startup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 atomicshop/startup/win/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/startup/win/startup_folder.py,sha256=2RZEyF-Mf8eWPlt_-OaoGKKnMs6YhELEzJZ376EI0E0,1891
 atomicshop/startup/win/task_scheduler.py,sha256=qALe-8sfthYxsdCViH2r8OsH3x-WauDqteg5RzElPdk,4348
+atomicshop/web_apis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+atomicshop/web_apis/google_custom_search.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+atomicshop/web_apis/google_llm.py,sha256=WVLqyfZHFIGEncxdBvrHCv2FbvQw40z75uMGzq9lxB4,1291
 atomicshop/wrappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/_process_wrapper_curl.py,sha256=XkZZXYl7D0Q6UfdWqy-18AvpU0yVp9i2BVD2qRcXlkk,841
 atomicshop/wrappers/_process_wrapper_tar.py,sha256=WUMZFKNrlG4nJP9tWZ51W7BR1j_pIjsjgyAStmWjRGs,655
@@ -189,7 +192,7 @@ atomicshop/wrappers/olefilew.py,sha256=biD5m58rogifCYmYhJBrAFb9O_Bn_spLek_9HofLe
 atomicshop/wrappers/pipw.py,sha256=mu4jnHkSaYNfpBiLZKMZxEX_E2LqW5BVthMZkblPB_c,1317
 atomicshop/wrappers/process_wrapper_pbtk.py,sha256=ycPmBRnv627RWks6N8OhxJQe8Gu3h3Vwj-4HswPOw0k,599
 atomicshop/wrappers/pyopensslw.py,sha256=OBWxA6EJ2vU_Qlf4M8m6ilcG3hyYB4yB0EsXUf7NhEU,6804
-atomicshop/wrappers/sysmonw.py,sha256=MFF8ts0gHbXn2_QeH196UncOUtm4MnM2cQBzTOnfrnk,5351
+atomicshop/wrappers/sysmonw.py,sha256=CdawuWuy_uUi3ALCm6lKP7pSyKeTk1MXyzOaTMbBSO8,5346
 atomicshop/wrappers/ubuntu_terminal.py,sha256=3UJaje_Ke5G9xEyj3b37XZ_KjR_FSSnb4gupdCyI-jE,11965
 atomicshop/wrappers/wslw.py,sha256=2Z7X0j5M2hoRZjbHfm_vqwNXZeptsdkNCdhdcM_S9vo,6998
 atomicshop/wrappers/certauthw/certauth.py,sha256=hKedW0DOWlEigSNm8wu4SqHkCQsGJ1tJfH7s4nr3Bk0,12223
@@ -246,7 +249,7 @@ atomicshop/wrappers/factw/rest/router.py,sha256=fdGok5ESBxcZHIBgM93l4yTPRGoeooQN
 atomicshop/wrappers/factw/rest/statistics.py,sha256=vznwzKP1gEF7uXz3HsuV66BU9wrp73N_eFqpFpye9Qw,653
 atomicshop/wrappers/factw/rest/status.py,sha256=4O3xS1poafwyUiLDkhyx4oMMe4PBwABuRPpOMnMKgIU,641
 atomicshop/wrappers/fibratusw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/wrappers/fibratusw/install.py,sha256=PLVymDe0HuOvU0r2lje8BkQAgtiOWEeRO7n-1zKuL7A,3287
+atomicshop/wrappers/fibratusw/install.py,sha256=GnaAAqcXRhovxZ3x5uB9RAXTMCh5xd5k1niCKTzh4Z0,3242
 atomicshop/wrappers/loggingw/consts.py,sha256=JWiUJEydjhwatBxtIJsGTmDUSTLbmIRidtR6qRLMaIY,1608
 atomicshop/wrappers/loggingw/filters.py,sha256=48UVhJHemCS0agXmQP8dHvAHM8r9DFphJ1TNEBP3Dlg,3545
 atomicshop/wrappers/loggingw/formatters.py,sha256=ZY12IokVY1G_Wzn2Zlv9qjK-e8CtIK6yUgUfPHvH2BU,5802
@@ -300,23 +303,23 @@ atomicshop/wrappers/pywin32w/wmis/win32process.py,sha256=qMzXtJ5hBZ5ydAyqpDbSx0n
 atomicshop/wrappers/socketw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/socketw/accepter.py,sha256=hZZKVYlF3LOHQJsSIEKXZUf6QXXWm-AtqXZevvaYigE,1732
 atomicshop/wrappers/socketw/base.py,sha256=DV6BWao9kiLAWimhVDKGEi3ISVaWk5iPHXtBHrO3uwc,2264
-atomicshop/wrappers/socketw/certificator.py,sha256=3CpQKtcW68FSbH6LVSEZTqWBS6Yg_-3K0x4nFkId4UY,12236
-atomicshop/wrappers/socketw/creator.py,sha256=3_OraDkw2DAWZfoSdY3svCGMOIxpjLEEY7NxWd7M5P4,9873
+atomicshop/wrappers/socketw/certificator.py,sha256=mtWPJ_ew3OSwt0-1W4jaoco1VIY4NRCrMv3mDUxb_Cc,12418
+atomicshop/wrappers/socketw/creator.py,sha256=OLcd7FyUk_k8iyoL-xYnCnNmolPSgio6OeQXth7NdLg,11414
 atomicshop/wrappers/socketw/dns_server.py,sha256=RklzINNuoMQn4PGGQEI5hiAldprbVwwvikY6u9X-jTY,49067
 atomicshop/wrappers/socketw/exception_wrapper.py,sha256=B-X5SHLSUIWToihH2MKnOB1F4A81_X0DpLLfnYKYbEc,7067
 atomicshop/wrappers/socketw/get_process.py,sha256=aJC-_qFUv3NgWCSUzDI72E4z8_-VTZE9NVZ0CwUoNlM,5698
-atomicshop/wrappers/socketw/receiver.py,sha256=XVvWOoeCo3vA0O5p19ryi-hcDIyx382WNG7WzMNVeYk,9322
-atomicshop/wrappers/socketw/sender.py,sha256=vjgU1TaADJjaYiZOkLzfxcdCbmkvjhEhVjSV5mmIbw8,4969
-atomicshop/wrappers/socketw/sni.py,sha256=J1kPnQ77XwKN1pO5aOI1c_VfhuivCm95OOaQxMpPuZ0,17627
-atomicshop/wrappers/socketw/socket_client.py,sha256=zDX7M3KfUOn0tXR92gZ119HVFgA8N_0ppQxfxVqNvKc,19867
+atomicshop/wrappers/socketw/receiver.py,sha256=-QtKK0T_lmoAIypTYaIKOD3pgB1npWGPxcVEN37y_gk,10060
+atomicshop/wrappers/socketw/sender.py,sha256=gwSzF51QD5paeeFav6fpbQpO8KgBO5lNztHYQyN5id0,4959
+atomicshop/wrappers/socketw/sni.py,sha256=Nc8WMZZR21o5GXILQLVWbf7OzNPXAfE8trJY153e9Qk,17591
+atomicshop/wrappers/socketw/socket_client.py,sha256=YUlwbasxYQqz1xUlPWxwEnSDSCYKGdxWb2CFAogefr8,21131
 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=SDYI1cN0oaapvPeLxSXiJrelTy6xbZl-bopR0jAjVGE,3149
 atomicshop/wrappers/winregw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/winregw/winreg_network.py,sha256=zZQfps-CdODQaTUADbHAwKHr5RUg7BLafnKWBbKaLN4,8728
-atomicshop-2.16.46.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.16.46.dist-info/METADATA,sha256=omUbYa_iNUdkQVw-R3HI2c0QglteZBXwvixzYRx2jD4,10500
-atomicshop-2.16.46.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-atomicshop-2.16.46.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.16.46.dist-info/RECORD,,
+atomicshop-2.17.0.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.17.0.dist-info/METADATA,sha256=MG763mizxXrtHLWqgLymqhAomm0BYskwwRsHU-mvJpY,10499
+atomicshop-2.17.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-2.17.0.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.17.0.dist-info/RECORD,,