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

atomicshop/basics/bytes_arrays.py

@@ -53,6 +53,30 @@ def convert_sequence_of_bytes_to_sequence_of_strings(byte_sequence: bytes) -> li
     return result
 
 
+def convert_sequence_of_bytes_to_exact_string(
+        byte_sequence: bytes,
+        add_space_between_bytes: bool = False,
+) -> str:
+    """
+    Convert sequence of bytes to exact string.
+    Example: b'\xc0\x00' -> 'c000'
+
+    :param byte_sequence: bytes, sequence of bytes.
+    :param add_space_between_bytes: bool, add space between bytes.
+        Example: b'\xc0\x00' -> 'c0 00'
+    :return: string.
+    """
+
+    # Convert to hex string and format
+    byte_list: list = []
+    for byte in byte_sequence:
+        byte_list.append(f'{byte:02x}')
+
+    result = ''.join(byte_list)
+
+    return result
+
+
 def find_position(target: bytes, file_path: str = None, file_bytes: bytes = None, chunk_size: int = None, starting_position: int = 0) -> int:
     """
     Find position of the target bytes string in the file.

atomicshop/dns.py

@@ -77,6 +77,17 @@ def get_default_dns_gateway() -> tuple[bool, list[str]]:
     return is_dynamic, dns_servers
 
 
+def get_default_dns_gateway_with_dns_resolver() -> list[str]:
+    """
+    Get the default DNS gateway from the system using dns.resolver.
+    :return: tuple(is dynamic boolean, list of DNS server IPv4s).
+    """
+
+    resolver = dns.resolver.Resolver()
+    dns_servers = list(resolver.nameservers)
+    return dns_servers
+
+
 def set_connection_dns_gateway_static(
         dns_servers: list[str],
         connection_name: str = None,

atomicshop/http_parse.py

@@ -2,7 +2,6 @@ from http.server import BaseHTTPRequestHandler
 from http.client import HTTPResponse
 import http
 from io import BytesIO
-import socket
 
 
 class HTTPRequestParse(BaseHTTPRequestHandler):
@@ -50,8 +49,8 @@ class HTTPRequestParse(BaseHTTPRequestHandler):
     """
 
     # noinspection PyMissingConstructor
-    def __init__(self, request_text):
-        self.request_text = request_text
+    def __init__(self, request_bytes: bytes):
+        self.request_bytes: bytes = request_bytes
 
         # noinspection PyTypeChecker
         self.rfile = None
@@ -107,7 +106,7 @@ class HTTPRequestParse(BaseHTTPRequestHandler):
         error: str = str()
         info: str = str()
 
-        self.rfile = BytesIO(self.request_text)
+        self.rfile = BytesIO(self.request_bytes)
         self.raw_requestline = self.rfile.readline()
         self.error_code = self.error_message = None
         self.parse_request()
@@ -152,6 +151,7 @@ class FakeSocket:
     def __init__(self, response_bytes):
         self._file = BytesIO(response_bytes)
 
+    # noinspection PyUnusedLocal
     def makefile(self, mode='rb', buffering=-1) -> BytesIO:
         """
         Mimics the socket's makefile method, returning the BytesIO object.

atomicshop/mitm/connection_thread_worker.py

@@ -100,15 +100,12 @@ def thread_worker_main(
             client_message.protocol = 'HTTP'
             client_message.request_raw_decoded = request_decoded
             print_api(request_parsing_info, logger=network_logger, logger_method='info')
-            network_logger.info(f"Method: {request_decoded.command}")
-            network_logger.info(f"Path: {request_decoded.path}")
-        # If there was error - the request is really HTTP, but there's a problem with its structure.
+            network_logger.info(f"Method: {request_decoded.command} | Path: {request_decoded.path}")
         else:
-            # client_message.error = request_parsing_error
-            print_api(request_parsing_error, logger=network_logger, logger_method='error', color='yellow')
             # It doesn't matter if we have HTTP Parsing error, since the request may not be really HTTP, so it is OK
             # not to log it into statistics.
             # statistics_error_list.append(error_message)
+            print_api(request_parsing_error, logger=network_logger, logger_method='error', color='yellow')
 
     def finish_thread():
         # At this stage there could be several times that the same socket was used to the service server - we need to
@@ -204,8 +201,6 @@ def thread_worker_main(
                 client_message.request_raw_bytes = client_received_raw_data
 
                 parse_http()
-                if client_message.protocol != 'HTTP':
-                    pass
 
                 # Custom parser, should parse HTTP body or the whole message if not HTTP.
                 parser_instance = parser(client_message)

atomicshop/mitm/mitm_main.py

@@ -19,6 +19,7 @@ from . import config_static, recs_files
 
 NETWORK_INTERFACE_IS_DYNAMIC: bool = bool()
 NETWORK_INTERFACE_IPV4_ADDRESS_LIST: list[str] = list()
+IS_SET_DNS_GATEWAY: bool = False
 # noinspection PyTypeChecker
 RECS_PROCESS_INSTANCE: multiprocessing.Process = None
 
@@ -36,7 +37,7 @@ except win_console.NotWindowsConsoleError:
 
 
 def exit_cleanup():
-    if permissions.is_admin():
+    if permissions.is_admin() and IS_SET_DNS_GATEWAY:
         is_dns_dynamic, current_dns_gateway = dns.get_default_dns_gateway()
         status_string = 'Dynamic' if is_dns_dynamic else 'Static'
         print_api.print_api(f'Current DNS Gateway: {status_string}, {current_dns_gateway}')
@@ -347,10 +348,14 @@ def mitm_server(config_file_path: str):
             dns_gateway_server_list = [base.DEFAULT_IPV4]
             set_dns_gateway = True
 
-        # Get current network interface state.
-        global NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST
-        NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST = dns.get_default_dns_gateway()
         if set_dns_gateway:
+            global IS_SET_DNS_GATEWAY
+            IS_SET_DNS_GATEWAY = True
+
+            # Get current network interface state.
+            global NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST
+            NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST = dns.get_default_dns_gateway()
+
             # Set the DNS gateway to the specified one only if the DNS gateway is dynamic, or it is static but different
             # from the one specified in the configuration file.
             if (NETWORK_INTERFACE_IS_DYNAMIC or (not NETWORK_INTERFACE_IS_DYNAMIC and

atomicshop/web.py

@@ -90,10 +90,13 @@ def get_page_bytes(
 
 
 def get_page_content(
-        url: str, get_method: str = 'urllib', path: str = None,
+        url: str,
+        get_method: str = 'urllib',
+        path: str = None,
         playwright_pdf_format: str = 'A4',
         playwright_html_txt_convert_to_bytes: bool = True,
-        print_kwargs: dict = None) -> any:
+        print_kwargs: dict = None
+) -> any:
     """
     Function returns the page content from the given URL.
 

atomicshop/websocket_parse.py

@@ -0,0 +1,176 @@
+from typing import Union
+import logging
+
+from websockets.server import ServerProtocol
+from websockets.client import ClientProtocol
+from websockets.extensions.permessage_deflate import ServerPerMessageDeflateFactory, ClientPerMessageDeflateFactory
+from websockets.http11 import Request, Response
+from websockets.frames import Frame, Opcode, Close
+from websockets.uri import parse_uri
+from websockets.exceptions import InvalidHeaderValue
+from websockets.protocol import OPEN
+
+
+class WebsocketRequestParse:
+    """
+    Parse the websocket request and return the data
+    """
+    def __init__(
+            self,
+            enable_logging: bool = False,
+    ):
+        """
+        Initialize the websocket parser.
+
+        :param enable_logging: bool: Enable logging for the websocket protocol.
+        """
+        # noinspection PyTypeChecker
+        self.request_bytes: bytes = None
+
+        # Set up extensions
+        permessage_deflate_factory = ServerPerMessageDeflateFactory()
+
+        # Create the protocol instance
+        self.protocol = ServerProtocol(
+            extensions=[permessage_deflate_factory],
+        )
+        # At this state the protocol.state is State.CONNECTING
+
+        if enable_logging:
+            logging.basicConfig(level=logging.DEBUG)
+            self.protocol.logger.setLevel(logging.DEBUG)
+
+    def parse(
+            self,
+            request_bytes: bytes
+    ) -> Union[str, bytes, Request]:
+        """
+        Parse the websocket request and return the data
+
+        :param request_bytes: bytes: The raw bytes of the websocket request.
+        :return: Request: The parsed request object.
+        """
+
+        self.protocol.receive_data(request_bytes)
+        events = self.protocol.events_received()
+        for event in events:
+            if isinstance(event, Request):
+                # Accept the handshake.
+                # After the response is sent, it means the handshake was successful, the protocol.state is State.OPEN
+                # Only after this state we can parse frames.
+                response = self.protocol.accept(event)
+                self.protocol.send_response(response)
+                return event
+            elif isinstance(event, Frame):
+                frame = event
+                if frame.opcode == Opcode.TEXT:
+                    message = frame.data.decode('utf-8')
+                    return message
+                elif frame.opcode == Opcode.BINARY:
+                    return frame.data
+
+                """
+                # Handle control frames, these are here for the future references.
+                elif frame.opcode == Opcode.CLOSE:
+                    close_info = Close.parse(frame.data)
+                    print(f"Connection closed by client: {close_info.code}, {close_info.reason}")
+                    # Send a close frame in response if not already sent
+                    if self.protocol.state == self.protocol.OPEN:
+                        self.protocol.send_close()
+                elif frame.opcode == Opcode.PING:
+                    # Respond to ping with pong
+                    self.protocol.send_pong(frame.data)
+                elif frame.opcode == Opcode.PONG:
+                    print("Received pong")
+                """
+
+
+class WebsocketResponseParse:
+    """
+    Parse the websocket response and return the data
+    """
+    def __init__(
+            self,
+            enable_logging: bool = False,
+    ):
+        """
+        Initialize the websocket parser.
+
+        :param enable_logging: bool: Enable logging for the websocket protocol.
+        """
+        # noinspection PyTypeChecker
+        self.response_bytes: bytes = None
+
+        # Set up extensions
+        permessage_deflate_factory = ClientPerMessageDeflateFactory()
+
+        # Parse the WebSocket URI.
+        # Since we're parsing the response, we don't need the URI, but the protocol object requires it.
+        # So we will just use a dummy URI.
+        wsuri = parse_uri('ws://example.com/websocket')
+
+        # Create the protocol instance
+        self.protocol = ClientProtocol(
+            wsuri,
+            extensions=[permessage_deflate_factory],
+        )
+
+        if enable_logging:
+            logging.basicConfig(level=logging.DEBUG)
+            # self.protocol.logger.setLevel(logging.DEBUG)
+            self.protocol.debug = True
+
+        # Perform the handshake and emulate the connection and request sending.
+        request = self.protocol.connect()
+        self.protocol.send_request(request)
+        _ = self.protocol.data_to_send()
+        # At this state the protocol.state is State.CONNECTING
+
+    def parse(
+            self,
+            response_bytes: bytes
+    ) -> Union[str, bytes, Response]:
+        """
+        Parse the websocket response and return the data
+
+        :param response_bytes: bytes: The raw bytes of the websocket response.
+        :return: The parsed response.
+        """
+
+        self.protocol.receive_data(response_bytes)
+        events = self.protocol.events_received()
+        for event in events:
+            if isinstance(event, Response):
+                # Accept the handshake.
+                # After the response is sent, it means the handshake was successful, the protocol.state is State.OPEN
+                # Only after this state we can parse frames.
+                try:
+                    self.protocol.process_response(event)
+                except InvalidHeaderValue as e:
+                    headers = event.headers
+                    self.protocol.extensions = self.protocol.process_extensions(headers)
+                    self.protocol.subprotocol = self.protocol.process_subprotocol(headers)
+                    self.protocol.state = OPEN
+                return event
+            elif isinstance(event, Frame):
+                frame = event
+                if frame.opcode == Opcode.TEXT:
+                    message = frame.data.decode('utf-8')
+                    return message
+                elif frame.opcode == Opcode.BINARY:
+                    return frame.data
+
+                """
+                # Handle control frames, these are here for the future references.
+                elif frame.opcode == Opcode.CLOSE:
+                    close_info = Close.parse(frame.data)
+                    print(f"Connection closed by client: {close_info.code}, {close_info.reason}")
+                    # Send a close frame in response if not already sent
+                    if self.protocol.state == self.protocol.OPEN:
+                        self.protocol.send_close()
+                elif frame.opcode == Opcode.PING:
+                    # Respond to ping with pong
+                    self.protocol.send_pong(frame.data)
+                elif frame.opcode == Opcode.PONG:
+                    print("Received pong")
+                """

atomicshop/wrappers/factw/install/install_after_restart.py

@@ -7,7 +7,12 @@ from .. import config_install
 
 def install_after_restart(
         installation_directory: str,
-        install_type: Union[None, Literal['backend', 'frontend', 'db']] = None
+        install_type: Union[
+            None,
+            Literal['backend', 'frontend', 'db']] = None,
+        log_level: Union[
+            None,
+            Literal['DEBUG', 'INFO', 'WARNING', 'ERROR']] = None
 ):
     """
     This function will continue the installation the FACT_core after the restart of the computer.
@@ -20,6 +25,9 @@ def install_after_restart(
         --backend: Distributed setup, Install the FACT_core backend.
         --frontend: Distributed setup, Install the FACT_core frontend.
         --db: Distributed setup, Install the FACT_core database.
+    :param log_level: string, the log level to use for the installation.
+        The same as using the '--log-level' parameter in the 'install.py' script.
+        The default is 'INFO' in the 'install.py' script.
     :return:
     """
 
@@ -28,8 +36,11 @@ def install_after_restart(
     if install_type:
         install_command = install_command + ' --' + install_type
 
+    if log_level:
+        install_command = install_command + ' --log-level ' + log_level
+
     # Install the FACT_core repo.
     process.execute_with_live_output(cmd=install_command, verbose=True)
     # Remove the FACT_core installation log.
-    working_directory_path: str = filesystem.get_working_directory()
+    # working_directory_path: str = filesystem.get_working_directory()
     # filesystem.remove_file(str(Path(working_directory_path, config_install.INSTALL_LOG_FILE_NAME)))