atomicshop 2.15.11__py3-none-any.whl → 3.10.5__py3-none-any.whl

atomicshop/certificates.py

@@ -5,9 +5,10 @@ https://oidref.com/1.3.6.1.5.5.7.3.1
 
 
 import ssl
+from typing import Literal, Any
 
 from .wrappers import cryptographyw
-from .print_api import print_api
+from .wrappers.pywin32w import cert_store
 
 
 # Valid for 3 years from now
@@ -16,72 +17,172 @@ from .print_api import print_api
 SECONDS_NOT_AFTER_3_YEARS = 3 * 365 * 24 * 60 * 60
 
 
-def is_certificate_in_store(certificate, issuer_only: bool = False, thumbprint_only: bool = False):
+def get_pem_certificate_from_string(certificate: str) -> str:
     """
-    The function will check if the certificate is installed in the Windows certificate store.
-
-    :param certificate: x509 object, certificate to check.
-    :param issuer_only: bool, if True, will check only by the certificate issuer common name is installed in the store.
-        The problem that the issuer common name is not unique, so it can be installed multiple times.
-    :param thumbprint_only: bool, if True, will check only by the certificate thumbprint is installed in the store.
-        The problem that searching by the thumbprint will not tell you if there are multiple certificates with the same
-        issuer name.
-    :return: bool, True if certificate is installed, False if not.
+    Some PEM certificates can contain a private key. This function will return only the certificate part.
+
+    :param certificate: string, PEM certificate.
+    :return: string, certificate part.
     """
 
-    # Make sure the certificate is x509.Certificate object.
-    certificate = cryptographyw.convert_object_to_x509(certificate)
-    # Get the certificate thumbprint.
-    thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(certificate)
-    issuer_common_name: str = cryptographyw.get_issuer_common_name_from_x509(certificate)
+    certificate_lines = certificate.split('\n')
+    certificate_part = ''
+    start = False
+    for line in certificate_lines:
+        if 'BEGIN CERTIFICATE' in line:
+            start = True
+        if start:
+            certificate_part += line + '\n'
+        if 'END CERTIFICATE' in line:
+            break
 
-    # for store in ["CA", "ROOT", "MY"]:
-    for cert, encoding, trust in ssl.enum_certificates("ROOT"):
-        store_certificate = cryptographyw.convert_object_to_x509(cert)
-        store_issuer_common_name: str = cryptographyw.get_issuer_common_name_from_x509(store_certificate)
-        store_thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(store_certificate)
-
-        if issuer_only:
-            if store_issuer_common_name == issuer_common_name:
-                return True, certificate
-        elif thumbprint_only:
-            if store_thumbprint == thumbprint:
-                return True, certificate
-        elif not issuer_only and not thumbprint_only:
-            if store_thumbprint == thumbprint and store_issuer_common_name == issuer_common_name:
-                return True, certificate
+    return certificate_part
 
 
-def get_certificates_by_issuer_name(issuer_name: str, print_kwargs: dict = None):
+def write_crt_certificate_file_in_pem_format_from_pem_file(
+        pem_file_path: str,
+        crt_file_path: str
+):
     """
-    The function will return all certificates with the specified issuer name.
+    The function will read the PEM certificate file and write it to the CRT file in PEM format.
+    The function is used to convert the PEM certificate file to the CRT file.
 
-    :param issuer_name: string, issuer name to search for.
-    :param print_kwargs: dict, that contains all the arguments for 'print_api' function.
+    Basically the point here is that the CRT file is the same as the PEM file, but the extension is different,
+    and it doesn't support integrated private key.
 
-    :return: list, of certificates with the specified issuer name.
+    :param pem_file_path: string, path to the PEM certificate file.
+    :param crt_file_path: string, path to the CRT certificate file.
     """
 
-    if not print_kwargs:
-        print_kwargs = {}
+    with open(pem_file_path, 'r') as f:
+        certificate_string = f.read()
 
-    certificates_list = []
+    certificate_pem = get_pem_certificate_from_string(certificate_string)
+
+    with open(crt_file_path, 'w') as f:
+        f.write(certificate_pem)
+
+
+def is_certificate_in_store(
+        certificate: Any = None,
+        by_cert_issuer: bool = True,
+        by_cert_thumbprint: bool = True,
+        issuer_name: str = None,
+        store_location: str = "ROOT",
+        print_kwargs: dict = None
+) -> tuple[bool, list]:
+    """
+    The function will check if the CA certificate is installed in the Windows certificate Trusted Root store.
+    NO ADMIN RIGHTS NEEDED.
+
+    :param certificate: x509 object, certificate to check. You can search by certificate or by issuer name.
+        Supported types:
+            string that is path to file will be imported as bytes object abd converted to x509.Certificate
+                After check if it's PEM or DER format.
+            string that is PEM certificate will be converted to bytes, then x509.Certificate
+            bytes of PEM or DER will be converted to x509.Certificate.
+            x509.Certificate will be returned as is.
+    :param by_cert_issuer: bool, if True, will check only by the certificate issuer common name is installed in the store.
+        The problem if the search will be by issuer alone, that the issuer common name is not unique,
+        so it can be installed multiple times.
+    :param by_cert_thumbprint: bool, if True, will check only by the certificate thumbprint is installed in the store.
+        The problem that searching by the thumbprint alone will not tell you if there are multiple
+        certificates with the same issuer name.
+    :param issuer_name: string, issuer name to search for. You can search by certificate or by issuer name.
+    :param store_location: string, store location to search in. Default is "ROOT".
+    :param print_kwargs: dict, print_api kwargs.
+    :return: tuple(bool - True if certificate is installed and False if not, list of certificates found)
+    """
+
+    if not by_cert_issuer and not by_cert_thumbprint:
+        raise ValueError('At least one of the parameters "by_issuer" or "by_thumbprint" must be True.')
+
+    if not certificate and not issuer_name:
+        raise ValueError('At least one of the parameters "certificate" or "issuer_name" must be provided.')
+    elif certificate and issuer_name:
+        raise ValueError('Only one of the parameters "certificate" or "issuer_name" must be provided.')
+
+    if certificate:
+        # Make sure the certificate is x509.Certificate object.
+        certificate_x509 = cryptographyw.convert_object_to_x509(certificate, print_kwargs=print_kwargs)
+        # Get the certificate thumbprint.
+        provided_thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(certificate_x509)
+        provided_issuer_common_name: str = cryptographyw.get_issuer_common_name_from_x509(certificate_x509)
+    elif issuer_name:
+        provided_thumbprint = None
+        provided_issuer_common_name = issuer_name
+    else:
+        raise ValueError('At least one of the parameters "certificate" or "issuer_name" must be provided.')
 
-    for cert, encoding, trust in ssl.enum_certificates("ROOT"):
+    # Iterate over all certificates in the store specifically in the ROOT.
+    # for store in ["CA", "ROOT", "MY"]:
+    result_found_list: list = []
+    found: bool = False
+    for cert, encoding, trust in ssl.enum_certificates(store_location):
+        # Some certificates in the store can have zero or negative serial number.
+        # We will skip them, since they're deprecated by the cryptography library.
         store_certificate = cryptographyw.convert_object_to_x509(cert)
+        if not store_certificate:
+            continue
+
         store_issuer_common_name: str = cryptographyw.get_issuer_common_name_from_x509(store_certificate)
+        store_thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(store_certificate)
 
-        if store_issuer_common_name == issuer_name:
-            certificates_list.append(store_certificate)
+        if certificate:
+            if by_cert_issuer and not by_cert_thumbprint:
+                if store_issuer_common_name == provided_issuer_common_name:
+                    result_found_list.append(store_certificate)
+                    found = True
+            elif by_cert_thumbprint and not by_cert_issuer:
+                if store_thumbprint == provided_thumbprint:
+                    result_found_list.append(store_certificate)
+                    found = True
+            elif by_cert_issuer and by_cert_thumbprint:
+                if store_thumbprint == provided_thumbprint and store_issuer_common_name == provided_issuer_common_name:
+                    result_found_list.append(store_certificate)
+                    found = True
+        elif issuer_name:
+            if store_issuer_common_name == provided_issuer_common_name:
+                result_found_list.append(store_certificate)
+                found = True
+
+    return found, result_found_list
+
+
+def delete_certificate_by_issuer_name(
+        issuer_name: str,
+        store_location: Literal[
+            "ROOT",
+            "CA",
+            "MY"] = "ROOT",
+        print_kwargs: dict = None
+):
+    """
+    NEED ADMIN RIGHTS.
+    The function will remove all certificates with the specified issuer name.
+    There can be several certificates with this name.
 
-    if certificates_list:
-        for certificate_single in certificates_list:
-            issuer_name = cryptographyw.get_issuer_common_name_from_x509(certificate_single)
-            thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(certificate_single)
-            message = f'Issuer name: {issuer_name} | Thumbprint: {thumbprint}'
-            print_api(message, **print_kwargs)
-    else:
-        message = f'No certificates with issuer name: {issuer_name}'
-        print_api(message, **print_kwargs)
+    :param issuer_name: string, issuer name to search for.
+    :param store_location: string, store location to search in. Default is "ROOT".
+    :param print_kwargs: dict, print_api kwargs.
+    """
+
+    cert_store.delete_certificate_by_issuer_name(issuer_name, store_location, print_kwargs)
+
+
+def install_certificate_file(
+        file_path: str,
+        store_location: Literal[
+            "ROOT", "CA", "MY"] = "ROOT",
+        print_kwargs: dict = None
+):
+    """
+    The function will install the certificate from the file to the specified store location.
+    NEED ADMIN RIGHTS.
+
+    :param file_path: string, full file path to the certificate file.
+    :param store_location: string, store location to install the certificate. Default is "ROOT".
+    :param print_kwargs: dict, print_api kwargs.
+    """
 
-    return certificates_list
+    cert_store.install_certificate_file(file_path, store_location, print_kwargs)

atomicshop/config_init.py

@@ -2,13 +2,17 @@ import os
 
 from .file_io import tomls
 from . import filesystem
-from .print_api import print_api
+from . import print_api
 
 CONFIG_FILE_NAME = 'config.toml'
 CONFIG: dict = dict()
 
 
-def get_config(script_directory: str = None, config_file_name: str = CONFIG_FILE_NAME) -> dict:
+def get_config(
+        script_directory: str = None,
+        config_file_name: str = CONFIG_FILE_NAME,
+        print_kwargs: dict = None
+) -> dict:
     """
     Get the config file content.
 
@@ -16,6 +20,7 @@ def get_config(script_directory: str = None, config_file_name: str = CONFIG_FILE
         get the working directory instead.
     :param config_file_name: string, name of the config file. Default is 'config.toml' as specified in the constant:
         'CONFIG_FILE_NAME'.
+    :param print_kwargs: dict, additional arguments to pass to the print function. Default is None.
     :return: dict.
     """
 
@@ -25,7 +30,7 @@ def get_config(script_directory: str = None, config_file_name: str = CONFIG_FILE
     if not script_directory:
         script_directory = filesystem.get_working_directory()
 
-    CONFIG = tomls.read_toml_file(f'{script_directory}{os.sep}{config_file_name}')
+    CONFIG = tomls.read_toml_file(f'{script_directory}{os.sep}{config_file_name}', **(print_kwargs or {}))
     return CONFIG
 
 
@@ -45,7 +50,7 @@ def write_config(
         'CONFIG_FILE_NAME'.
     :param print_message: boolean, if True, the function will print the message about the created config file.
         Also, it will wait for the user to press Enter to exit the script.
-        If False, the function will not print anything and will not exit..
+        If False, the function will not print anything and will not exit.
     :return:
     """
 
@@ -62,7 +67,7 @@ def write_config(
         tomls.write_toml_file(config, f'{script_directory}{os.sep}{config_file_name}')
 
         if print_message:
-            print_api(f"Created config file: {config_file_path}", color="yellow")
-            print_api(f"You need to fill it with details.", color="yellow")
+            print_api.print_api(f"Created config file: {config_file_path}", color="yellow")
+            print_api.print_api(f"You need to fill it with details.", color="yellow")
             input("Press Enter to exit.")
             exit()

atomicshop/console_user_response.py

@@ -1,11 +1,12 @@
-# v1.0.2 - 26.03.2023 20:40
 import sys
 
 
-def query_positive_negative(question_string: str,
-                            add_first_values_to_question: bool = True,
-                            positive_answers: list = None,
-                            negative_answers: list = None) -> bool:
+def query_positive_negative(
+        question_string: str,
+        add_first_values_to_question: bool = True,
+        positive_answers: list = None,
+        negative_answers: list = None
+) -> bool:
     """
     Ask for "yes" / "no" input to a question that is passed as a "question_string".
     Returns 'True' for 'positive' answers and 'False' for 'negative' answers.
@@ -31,10 +32,8 @@ def query_positive_negative(question_string: str,
     if add_first_values_to_question:
         question_string = f'{question_string} [{positive_answers[0]}/{negative_answers[0]}]'
 
-    # Defining variable as False for While loop to run
-    right_answer = False
     # As long as "right_answer" is False the loop will execute again
-    while not right_answer:
+    while True:
         # Print the passed question
         print(question_string)
         # Get the input from the console in lowercase
@@ -42,22 +41,16 @@ def query_positive_negative(question_string: str,
 
         # If the gathered value is in "Yes" answers array
         if choice in positive_answers:
-            # "right_answer" variable is True, so the loop will not execute again
-            right_answer = True
             # Function will return True
             return True
         # Else If the gathered value is in "No" answers array
         elif choice in negative_answers:
-            # "right_answer" variable is True, so the loop will not execute again
-            right_answer = True
             # Function will return False
             return False
         # If the gathered input is not in the arrays
         else:
             # Then output to console the message
             print("Please respond with either:", positive_answers, negative_answers)
-            # "right_answer" variable stays False, so the loop will execute again
-            right_answer = False
 
 
 def do_you_want_to_continue_yn(message: str) -> None:

atomicshop/consoles.py

@@ -0,0 +1,9 @@
+import msvcrt
+
+
+# === WINDOWS ONLY FUNCTIONS ===========================================================================================
+def wait_any_key(prompt="Press any key to continue..."):
+    print(prompt, end="", flush=True)
+    msvcrt.getch()  # waits for one key press (no Enter needed)
+    print()         # move to next line
+# === EOF WINDOWS ONLY FUNCTIONS =======================================================================================

atomicshop/datetimes.py

@@ -74,7 +74,7 @@ def get_datetime_from_complex_string_by_pattern(
         complex_string: str,
         date_pattern: str
 ) -> tuple[
-    Union[datetime, None],
+    Union[datetime.datetime, None],
     Union[str, None],
     Union[float, None]
 ]:

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/dns.py

@@ -1,6 +1,14 @@
+import socket
+import argparse
+
+# noinspection PyPackageRequirements
 import dns.resolver
 
-from .print_api import print_api
+from . import print_api
+from . import networks
+from .permissions import permissions
+from .wrappers.pywin32w.wmis import win32networkadapter
+from .wrappers import netshw
 
 
 # Defining Dictionary of Numeric to String DNS Query Types.
@@ -52,10 +60,127 @@ def resolve_dns_localhost(domain_name: str, dns_servers_list: list = None, print
         # Get only the first entry of the list of IPs [0]
         connection_ip = function_server_address[0].to_text()
         message = f"Resolved to [{connection_ip}]"
-        print_api(message, **print_kwargs)
+        print_api.print_api(message, **print_kwargs)
     except dns.resolver.NXDOMAIN:
         message = f"Domain {domain_name} doesn't exist - Couldn't resolve with {dns_servers_list}."
-        print_api(message, **print_kwargs, error_type=True, logger_method='error')
+        print_api.print_api(message, **print_kwargs, error_type=True, logger_method='error')
         pass
 
     return connection_ip
+
+
+def get_default_dns_gateway() -> tuple[bool, list[str]]:
+    """
+    Get the default DNS gateway from the system.
+    :return: tuple(is dynamic boolean, list of DNS server IPv4s).
+    """
+
+    interfaces_with_dns_settings: list[dict] = netshw.get_netsh_ipv4()
+
+    default_interface_ipv4 = socket.gethostbyname(socket.gethostname())
+    is_dynamic, dns_servers = None, None
+    for interface in interfaces_with_dns_settings:
+        if default_interface_ipv4 in interface['ip_addresses']:
+            is_dynamic = interface['dns_mode']
+            dns_servers = interface['dns_servers']
+            break
+
+    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_interface_dns_gateway_static(
+        interface_name: str,
+        dns_servers: list[str]
+) -> None:
+    """
+    Set the DNS servers for a network adapter.
+    :param interface_name: string, adapter name as shown in the network settings.
+    :param dns_servers: list of strings, DNS server IPv4 addresses.
+    :return: None
+    """
+
+    win32networkadapter.set_dns_server(interface_name=interface_name, dns_servers=dns_servers)
+
+
+def set_interface_dns_gateway_dynamic(
+        interface_name: str = None
+) -> None:
+    """
+    Set the DNS servers for a network adapter to obtain them automatically from DHCP.
+    :param interface_name: string, adapter name as shown in the network settings.
+    :return: None
+    """
+
+    win32networkadapter.set_dns_server(
+        interface_name=interface_name, dns_servers=None)
+
+
+def default_dns_gateway_main() -> int:
+    """
+    Main function for the default DNS gateway manipulations.
+    :return: None
+    """
+
+    argparse_obj = argparse.ArgumentParser(description="Get/Set the DNS gateway for the network adapter.")
+    arg_action_group = argparse_obj.add_mutually_exclusive_group(required=True)
+    arg_action_group.add_argument(
+        '-g', '--get', action='store_true', help='Get the default DNS gateway for the system.')
+    arg_action_group.add_argument(
+        '-s', '--set', type=str, nargs='+',
+        help='Set static DNS gateway for the system, provide values with spaces between each value.\n'
+             '   Example: -s 8.8.8.8 1.1.1.1.')
+    arg_action_group.add_argument(
+        '-d', '--dynamic', action='store_true',
+        help='Set the DNS gateway to obtain automatically from DHCP.')
+
+    arg_interface_group = argparse_obj.add_mutually_exclusive_group()
+    arg_interface_group.add_argument(
+        '-in', '--interface_name', type=str, help='Network Interface name as shown in the network settings.')
+    arg_interface_group.add_argument(
+        '-id', '--interface_default', action='store_true', help='Use the default network interface.')
+
+    args = argparse_obj.parse_args()
+
+    if (args.set or args.dynamic) and not (args.interface_name or args.interface_default):
+        print_api.print_api(
+            "Please provide the interface name [-in] or use the default interface [-id].", color='red')
+        return 1
+
+    if args.set or args.dynamic:
+        if not permissions.is_admin():
+            print_api.print_api("You need to run this script as an administrator", color='red')
+            return 1
+
+    def get_interface_name() -> str:
+        if args.interface_default:
+            return networks.get_default_interface_name()
+        else:
+            return args.interface_name
+
+    if args.get:
+        is_dynamic, dns_servers = get_default_dns_gateway()
+
+        if is_dynamic:
+            is_dynamic_string = 'Dynamic'
+        else:
+            is_dynamic_string = 'Static'
+        print_api.print_api(f'DNS Gateway: {is_dynamic_string} - {dns_servers}', color='blue')
+    elif args.set:
+        # dns_servers_list: list = args.dns_servers.split(',')
+        set_interface_dns_gateway_static(
+            dns_servers=args.set, interface_name=get_interface_name())
+    elif args.dynamic:
+        set_interface_dns_gateway_dynamic(interface_name=get_interface_name())
+
+    return 0

atomicshop/etws/_pywintrace_fix.py

@@ -0,0 +1,17 @@
+"""
+Need to fix the
+etw.etw
+file, in the
+EventConsumer._unpackSimpleType
+function.
+"""
+"""
+data = formatted_data.value
+# Convert the formatted data if necessary
+if isinstance(data, str):
+    if data.endswith(' '):
+        data = data[:-1]
+else:
+    if out_type in tdh.TDH_CONVERTER_LOOKUP and type(data) != tdh.TDH_CONVERTER_LOOKUP[out_type]:
+        data = tdh.TDH_CONVERTER_LOOKUP[out_type](data)
+"""