atomicshop 2.15.13__py3-none-any.whl → 2.16.0__py3-none-any.whl

atomicshop/script_as_string_processor.py

@@ -1,6 +1,7 @@
 """Loading resources using stdlib importlib.resources APIs (Python 3.7+)
 https://docs.python.org/3/library/importlib.html#module-importlib.resources"""
 import importlib.resources
+from typing import Literal
 
 from .print_api import print_api
 
@@ -13,7 +14,10 @@ class ScriptAsStringProcessor:
         self.exchange_input_variable_string: str = "exchange_input_variable"
         self.script_string: str = str()
 
-    def read_script_to_string(self, script_file_name: str):
+    def read_script_to_string(
+            self,
+            script_file_name: Literal['process_from_port', 'process_from_ipv4']
+    ):
         self.script_string = importlib.resources.read_text(
             f'{__package__}.{self.resources_directory_name}',
             f'{script_file_name}.py')

atomicshop/wrappers/cryptographyw.py

@@ -80,7 +80,7 @@ def convert_pem_to_x509_object(certificate: Union[str, bytes]) -> x509.Certifica
     return x509.load_pem_x509_certificate(certificate)
 
 
-def convert_der_to_x509_object(certificate: bytes):
+def convert_der_to_x509_object(certificate: bytes) -> x509.Certificate:
     """Convert DER certificate from socket to x509 object.
 
     :param certificate: bytes, certificate to convert.
@@ -151,8 +151,8 @@ def copy_extensions_from_old_cert_to_new_cert(
     builder = x509.CertificateBuilder()
     builder = builder.subject_name(certificate.subject)
     builder = builder.issuer_name(certificate.issuer)
-    builder = builder.not_valid_before(certificate.not_valid_before)
-    builder = builder.not_valid_after(certificate.not_valid_after)
+    builder = builder.not_valid_before(certificate.not_valid_before_utc)
+    builder = builder.not_valid_after(certificate.not_valid_after_utc)
     builder = builder.serial_number(certificate.serial_number)
 
     # We're using the new private key that we will sign with the new certificate later.

atomicshop/wrappers/psutilw/networks.py

@@ -1,5 +1,6 @@
 from typing import Union
 import shlex
+import socket
 
 import psutil
 
@@ -14,7 +15,10 @@ def get_process_using_port(port: int) -> Union[dict, None]:
         try:
             connections = proc.connections(kind='inet')
             for conn in connections:
-                if conn.laddr.port == port:
+                # if conn.laddr.port == port:
+                # Status LISTEN is for TCP sockets and NONE is for UDP sockets.
+                # Sometimes after socket close, the port will be in TIME_WAIT state.
+                if conn.laddr.port == port and (conn.status == 'LISTEN' or conn.status == 'NONE'):
                     cmdline = proc.info['cmdline']
                     if not cmdline:
                         cmdline = '<EMPTY: TRY RUNNING AS ADMIN>'
@@ -43,3 +47,23 @@ def get_processes_using_port_list(ports: list) -> Union[dict, None]:
             port_process_map[port] = process_info
 
     return port_process_map
+
+
+def get_default_connection_name() -> Union[dict, None]:
+    """
+    Function to get the default network interface.
+    :return: dict[interface_name: details] or None.
+    """
+    # Get all interfaces.
+    interfaces: dict = psutil.net_if_addrs()
+    default_ip_address: str = socket.gethostbyname(socket.gethostname())
+
+    for interface, details in interfaces.items():
+        for address in details:
+            # Check if the address is an IPv4 address (AF_INET) and not a loopback (127.0.0.1)
+            if address.family == socket.AF_INET and not address.address.startswith('127.'):
+                # Check if the address is the default IP address.
+                if address.address == default_ip_address:
+                    return {interface: details}
+
+    return None

atomicshop/wrappers/pywin32w/wmis/helpers.py

@@ -0,0 +1,127 @@
+import win32com.client
+
+
+class WmiMethodExecutionError(Exception):
+    pass
+
+
+class WmiMethodParameterError(Exception):
+    pass
+
+
+class EmptyValue:
+    pass
+
+
+def get_method(
+        wmi_object: win32com.client.CDispatch,
+        method_name: str
+):
+    """
+    Get the WMI method.
+
+    :param wmi_object: WMI object.
+    :param method_name: str, name of the method.
+    :return: WMI method object.
+    """
+
+    return wmi_object.Methods_(method_name)
+
+
+def get_method_parameter_instance(
+        method: win32com.client.CDispatch
+):
+    """
+    Get the WMI method parameter.
+
+    :param method: WMI method object.
+    :return: WMI method parameter object.
+    """
+
+    return method.inParameters.SpawnInstance_()
+
+
+def call_method(
+        wmi_object: win32com.client.CDispatch,
+        method_name: str,
+        value: any = EmptyValue
+):
+    """
+    Call the WMI method.
+
+    :param wmi_object: WMI object.
+    :param method_name: str, name of the method.
+    :param value: any, value to pass to the method.
+        Methods can receive a None value if they don't require any parameters.
+        If the method doesn't require any parameters, leave it as 'EmptyValue' class.
+    :return: WMI method object.
+    """
+
+    # Get the method instance out of the WMI object.
+    method = get_method(wmi_object, method_name)
+
+    # Check if the method requires any parameters.
+    if not method.InParameters and not isinstance(value, EmptyValue):
+        raise WmiMethodParameterError(f"Method '{method_name}' doesn't require any parameters.\nValue: {value}")
+    elif method.InParameters and isinstance(value, EmptyValue):
+        raise WmiMethodParameterError(f"Method '{method_name}' requires parameters.\nValue: {value}")
+
+    # If value was passed for the method to set.
+    if not isinstance(value, EmptyValue):
+        # Get the input parameters names that a method requires.
+        # The names are stored in a list of tuples where the first element is the name of the parameter and the second
+        # element is a boolean that indicates if the parameter is an array.
+        input_parameters_names = [
+            (input_parameter.Name, input_parameter.IsArray) for input_parameter in method.InParameters.Properties_]
+
+        # Check if the value and the input parameter is a list.
+        if not (isinstance(value, list) or value is None) and input_parameters_names[0][1]:
+            raise WmiMethodParameterError(f"Parameter '{input_parameters_names[0][0]}' must be a list.\nValue: {value}")
+        elif (isinstance(value, list) or value is None) and not input_parameters_names[0][1]:
+            raise WmiMethodParameterError(f"Parameter '{input_parameters_names[0][0]}' "
+                                          f"must be a single value.\nValue: {value}")
+
+        # Get generic parameter instance.
+        parameter_instance = get_method_parameter_instance(method)
+        # Set the attribute of the parameter name instance that we retrieved from above to the value.
+        # At this point only been using one parameter for a method, so maybe need to refactor this part if needed
+        # in the future for more than one parameter.
+        setattr(parameter_instance, input_parameters_names[0][0], value)
+
+        # Execute the method with the parameter instance.
+        result = wmi_object.ExecMethod_(method_name, parameter_instance)
+    else:
+        # Execute the method without any parameters.
+        result = wmi_object.ExecMethod_(method_name)
+
+    # Getting Result.
+    # Get the output parameters names that a method returns.
+    if method.OutParameters:
+        out_properties_names = [
+            (out_property.Name, out_property.IsArray) for out_property in method.OutParameters.Properties_]
+    else:
+        out_properties_names = []
+
+    # Get the results for each parameter the method returns.
+    results = []
+    for name, is_array in out_properties_names:
+        value = result.Properties_(name).Value
+        if is_array:
+            results.append(list(value or []))
+        else:
+            results.append(value)
+
+    # Check if the method executed successfully.
+    for result in results:
+        if result != 0:
+            raise WmiMethodExecutionError(f"Failed to execute method '{method_name}' with error code: {result}")
+
+
+"""
+# Setting SeDebugPrivilege
+import win32security, ntsecuritycon, win32con, win32api
+privs = ((win32security.LookupPrivilegeValue('',ntsecuritycon.SE_DEBUG_NAME), win32con.SE_PRIVILEGE_ENABLED),)
+hToken = win32security.OpenProcessToken(win32api.GetCurrentProcess(), win32security.TOKEN_ALL_ACCESS)
+win32security.AdjustTokenPrivileges(hToken, False, privs)
+win32api.CloseHandle(hToken)
+"""

atomicshop/wrappers/pywin32w/wmis/win32networkadapter.py

@@ -0,0 +1,167 @@
+from typing import Union
+
+import win32com.client
+
+from . import helpers
+from ...psutilw import networks
+from ....print_api import print_api
+
+
+class NetworkAdapterNotFoundError(Exception):
+    pass
+
+
+def list_network_adapters() -> list:
+    # Initialize the WMI client
+    wmi = win32com.client.Dispatch('WbemScripting.SWbemLocator')
+    wmi_service = wmi.ConnectServer('.', 'root\\cimv2')
+
+    # Query all network adapters
+    adapters = wmi_service.ExecQuery("SELECT * FROM Win32_NetworkAdapter")
+
+    # Print adapter descriptions
+    # for adapter in adapters:
+    #     print(f"Description: {adapter.Description}, IPEnabled: {adapter.IPEnabled}")
+    return list(adapters)
+
+
+def get_default_network_adapter():
+    """
+    Get the default network adapter.
+    :return:
+    """
+
+    default_connection_name_dict: dict = networks.get_default_connection_name()
+    # Get the first key from the dictionary.
+    default_connection_name: str = list(default_connection_name_dict.keys())[0]
+    adapters = list_network_adapters()
+
+    for adapter in adapters:
+        if default_connection_name == adapter.NetConnectionID:
+            return adapter
+
+    raise NetworkAdapterNotFoundError("Default network adapter not found.")
+
+
+def get_wmi_network_configuration(
+        use_default_interface: bool = False,
+        connection_name: str = None,
+        mac_address: str = None
+) -> tuple:
+    """
+    Get the WMI network configuration for a network adapter.
+    :param use_default_interface: bool, if True, the default network interface will be used.
+        This is the adapter that your internet is being used from.
+    :param connection_name: string, adapter name as shown in the network settings.
+    :param mac_address: string, MAC address of the adapter. Format: '00:00:00:00:00:00'.
+    :return: tuple(Win32_NetworkAdapterConfiguration, Win32_NetworkAdapter)
+    """
+
+    if use_default_interface and connection_name:
+        raise ValueError("Only one of 'use_default_interface' or 'connection_name' must be provided.")
+    elif not use_default_interface and not connection_name:
+        raise ValueError("Either 'use_default_interface' or 'connection_name' must be provided.")
+
+    adapters = list_network_adapters()
+
+    current_adapter = None
+    if use_default_interface:
+        default_connection_name_dict: dict = networks.get_default_connection_name()
+        # Get the first key from the dictionary.
+        connection_name: str = list(default_connection_name_dict.keys())[0]
+
+    if connection_name is None and mac_address is None:
+        raise ValueError("Either 'connection_name' or 'mac_address' must be provided.")
+    elif connection_name and mac_address:
+        raise ValueError("Only one of 'connection_name' or 'mac_address' must be provided.")
+
+    if connection_name:
+        for adapter in adapters:
+            if connection_name == adapter.NetConnectionID:
+                current_adapter = adapter
+                break
+
+        if not current_adapter:
+            raise NetworkAdapterNotFoundError(f"Adapter with connection name '{connection_name}' not found.")
+    elif mac_address:
+        for adapter in adapters:
+            if mac_address == adapter.MACAddress:
+                current_adapter = adapter
+                break
+
+        if current_adapter is None:
+            raise NetworkAdapterNotFoundError(f"Adapter with MAC address '{mac_address}' not found.")
+
+    # Initialize the WMI client
+    wmi = win32com.client.Dispatch('WbemScripting.SWbemLocator')
+    wmi_service = wmi.ConnectServer('.', 'root\\cimv2')
+
+    # Query the network adapter configurations
+    query = f"SELECT * FROM Win32_NetworkAdapterConfiguration WHERE Index='{current_adapter.DeviceID}'"
+    adapter_configs = wmi_service.ExecQuery(query)
+
+    # Check if the adapter exists
+    if len(adapter_configs) == 0:
+        raise NetworkAdapterNotFoundError(f"Adapter with connection name '{connection_name}' not found.")
+
+    return adapter_configs[0], current_adapter
+
+
+def set_dns_server(
+        dns_servers: Union[list[str], None],
+        use_default_interface: bool = False,
+        connection_name: str = None,
+        mac_address: str = None
+):
+    """
+    Set the DNS servers for a network adapter.
+    :param dns_servers: list of strings, DNS server IPv4 addresses.
+        None, if you want to remove the DNS servers and make the interface to obtain them automatically from DHCP.
+        list[str], if you want to set the DNS servers manually to the list of strings.
+    :param use_default_interface: bool, if True, the default network interface will be used.
+        This is the adapter that your internet is being used from.
+    :param connection_name: string, adapter name as shown in the network settings.
+    :param mac_address: string, MAC address of the adapter. Format: '00:00:00:00:00:00'.
+    :return:
+    """
+
+    adapter_config, current_adapter = get_wmi_network_configuration(
+        use_default_interface=use_default_interface, connection_name=connection_name, mac_address=mac_address)
+
+    print_api(f"Adapter [{current_adapter.Description}], Connection name [{current_adapter.NetConnectionID}]\n"
+              f"Setting DNS servers to {dns_servers}", color='blue')
+
+    # Set DNS servers
+    helpers.call_method(adapter_config, 'SetDNSServerSearchOrder', dns_servers)
+
+
+def is_adapter_dns_gateway_from_dhcp(
+        use_default_interface: bool = False,
+        connection_name: str = None,
+        mac_address: str = None
+) -> bool:
+    """
+    Check if the adapter is set to obtain the DNS servers automatically from DHCP.
+    :param use_default_interface: bool, if True, the default network interface will be used.
+        This is the adapter that your internet is being used from.
+    :param connection_name: string, adapter name as shown in the network settings.
+    :param mac_address: string, MAC address of the adapter. Format: '00:00:00:00:00:00'.
+    :return: bool, True if DHCP is enabled, False otherwise.
+    """
+
+    adapter_config, current_adapter = get_wmi_network_configuration(
+        use_default_interface=use_default_interface, connection_name=connection_name, mac_address=mac_address)
+
+    # If DHCP is not enabled.
+    if not adapter_config.DHCPEnabled:
+        # Then it is obvious that DNS Gateway is also Statis.
+        return False
+    # If DHCP is enabled.
+    else:
+        # Then we need to check if Default IP gateway is the same as DNS Gateway, if so.
+        if adapter_config.DefaultIPGateway == adapter_config.DNSServerSearchOrder:
+            # Then it is set dynamically from DHCP.
+            return True
+        else:
+            # If not, so it is static.
+            return False

atomicshop/wrappers/socketw/accepter.py

@@ -2,17 +2,12 @@ from . import exception_wrapper
 
 
 @exception_wrapper.connection_exception_decorator
-def accept_connection(socket_object, dns_domain, print_kwargs: dict = None):
+def accept_connection(socket_object, domain_from_dns_server, print_kwargs: dict = None):
     """
     Accept connection from client.
     This function is wrapped with exception wrapper.
     After you execute the function, you can get the error message if there was any with:
         error_message = accept_connection.message
-
-    :param socket_object:
-    :param dns_domain:
-    :param print_kwargs:
-    :return:
     """
 
     client_socket = None
@@ -33,8 +28,13 @@ def accept_connection(socket_object, dns_domain, print_kwargs: dict = None):
     return client_socket, client_address_tuple
 
 
-def accept_connection_with_error(socket_object, dns_domain, print_kwargs: dict = None):
-    client_socket, client_address_tuple = accept_connection(socket_object, dns_domain, print_kwargs=print_kwargs)
+def accept_connection_with_error(
+        socket_object,
+        domain_from_dns_server,
+        print_kwargs: dict = None
+):
+    client_socket, client_address_tuple = accept_connection(
+        socket_object, domain_from_dns_server, print_kwargs=print_kwargs)
     error_message = accept_connection.message
 
     return client_socket, client_address_tuple, error_message

atomicshop/wrappers/socketw/base.py

@@ -1,6 +1,11 @@
 import socket
 
 
+LOCALHOST_IPV4: str = '127.0.0.1'
+DEFAULT_IPV4: str = socket.gethostbyname(socket.gethostname())
+THIS_DEVICE_IP_LIST: list = [LOCALHOST_IPV4, DEFAULT_IPV4]
+
+
 def get_local_network_interfaces_ip_address(family_type: str = None, ip_only: bool = False) -> list:
     """
     Return list of IP addresses of local network interfaces.
@@ -57,3 +62,11 @@ def get_source_destination(socket_object):
 def set_socket_timeout(socket_object, seconds: int = 1):
     # Setting timeout on the socket before "accept()" drastically slows down connections.
     socket_object.settimeout(seconds)
+
+
+def get_default_ip_address() -> str:
+    """
+    Get the default IP address of the system.
+    :return: string.
+    """
+    return socket.gethostbyname(socket.gethostname())