atomicshop 2.16.46__py3-none-any.whl → 2.16.48__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.16.48'

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,111 @@ 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 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
+            )
+        # 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)
+
+        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()
@@ -191,6 +296,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 +323,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
-
-                parse_http()
-                if protocol != '':
-                    client_message.protocol = protocol
+            # 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 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)
+            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()
 
-                # 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 +358,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 +368,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 +392,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 +403,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/initialize_engines.py

@@ -5,12 +5,9 @@ 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):

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/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

@@ -163,7 +163,7 @@ 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')
                 return None, error_message
@@ -192,7 +192,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 +225,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()
 

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.16.48.dist-info}/METADATA

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

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

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=lwyRrx1298W0LP5WyV3pYJw7KJMlCtYSIh5JN2AhC58,124
+atomicshop/__init__.py,sha256=g4si8ZVmv-cmrXDPNTeEfgvWGFAXNNlfF5E-_j8xNMo,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
@@ -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,13 +126,13 @@ 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=vfFClzwDfaoT4zHCOfky4DnEDoSonp9N1MCj62dS9Nk,20451
 atomicshop/mitm/import_config.py,sha256=0Ij14aISTllTOiWYJpIUMOWobQqGofD6uafui5uWllE,9272
-atomicshop/mitm/initialize_engines.py,sha256=VyJE8QnzlgD3QbX5inz5o6rC3zQ3is9CeTL7-B10g1w,8292
+atomicshop/mitm/initialize_engines.py,sha256=Naseof9JGY7oxDz9ueOyW7-KYTu7QDlFxv2ABqq9DD4,8219
 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
@@ -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
@@ -305,18 +308,18 @@ atomicshop/wrappers/socketw/creator.py,sha256=3_OraDkw2DAWZfoSdY3svCGMOIxpjLEEY7
 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=9_VXXo8r4upP5v0Rhzx7dJIblM23_0Ggh2PfktYj-fE,20489
 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.16.48.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.16.48.dist-info/METADATA,sha256=zxLRU6GxTBO675CZCx48ARUCy2CYk9CTkD-0jhyE3AQ,10500
+atomicshop-2.16.48.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-2.16.48.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.16.48.dist-info/RECORD,,