atomicshop 2.15.13__py3-none-any.whl → 2.16.1__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.15.13'
+__version__ = '2.16.1'

atomicshop/a_installs/ubuntu/pycharm.py

@@ -0,0 +1,7 @@
+import sys
+
+from atomicshop.wrappers.pycharmw import ubuntu
+
+
+if __name__ == '__main__':
+    sys.exit(ubuntu.install_main())

atomicshop/a_installs/win/pycharm.py

@@ -1,8 +1,8 @@
-from atomicshop.wrappers import pycharmw
+from atomicshop.wrappers.pycharmw import win
 
 
 def main():
-    pycharmw.download_install_main()
+    win.download_install_main()
 
 
 if __name__ == "__main__":

atomicshop/{addons/mains/install_wsl_ubuntu_lts_admin.py → a_installs/win/wsl_ubuntu_lts.py}

@@ -1,6 +1,7 @@
 from atomicshop.wrappers import wslw
 
 
+# Run as admin
 def main():
     wslw.install_wsl()
 

atomicshop/{addons/mains → a_mains}/FACT/update_extract.py

@@ -1,15 +1,16 @@
 import os
 
+from atomicshop import filesystem
 from atomicshop.wrappers.factw.fact_extractor import get_extractor
 from atomicshop.wrappers.factw import config_install
-from atomicshop import permissions, filesystem
+from atomicshop.permissions import ubuntu_permissions
 
 
 def main():
     get_extractor.get_extractor_script()
     fact_extractor_executable_path: str = (
             filesystem.get_working_directory() + os.sep + config_install.FACT_EXTRACTOR_FILE_NAME)
-    permissions.set_executable_permission(fact_extractor_executable_path)
+    ubuntu_permissions.set_executable(fact_extractor_executable_path)
 
 
 if __name__ == '__main__':

atomicshop/a_mains/dns_gateway_setting.py

@@ -0,0 +1,11 @@
+import sys
+
+from atomicshop import dns
+
+
+def main():
+    dns.default_dns_gateway_main()
+
+
+if __name__ == '__main__':
+    sys.exit(main())

atomicshop/basics/booleans.py

@@ -1,14 +1,23 @@
-def check_3_booleans_when_only_1_can_be_true(boolean1: tuple, boolean2: tuple, boolean3: tuple) -> None:
+def check_3_booleans_when_only_1_can_be_true(
+        boolean1: tuple,
+        boolean2: tuple,
+        boolean3: tuple
+) -> None:
     """
+    Check if only one boolean can be 'True' from 3 booleans
+
+    :param boolean1: tuple, (value, string name of the setting you want to print to the user to be aware of).
+    :param boolean2: tuple, (value, string name of the setting you want to print to the user to be aware of).
+    :param boolean3: tuple, (value, string name of the setting you want to print to the user to be aware of).
+    :return:
+
+    ------------------------------------------------
+
     Example:
         check_3_booleans_when_only_1_can_be_true(
             (self.config['section']['default_usage'], 'default_usage'),
             (self.config['section']['create_usage'], 'create_usage'),
             (self.config['section']['custom_usage'], 'custom_usage'))
-    :param boolean1: tuple, (value, string name of the setting you want to print to the user to be aware of).
-    :param boolean2: tuple, (value, string name of the setting you want to print to the user to be aware of).
-    :param boolean3: tuple, (value, string name of the setting you want to print to the user to be aware of).
-    :return:
     """
 
     check_if_3_booleans_are_false(boolean1, boolean2, boolean3)

atomicshop/dns.py

@@ -1,6 +1,10 @@
+import argparse
+
 import dns.resolver
 
 from .print_api import print_api
+from .permissions import permissions
+from .wrappers.pywin32w.wmis import win32networkadapter
 
 
 # Defining Dictionary of Numeric to String DNS Query Types.
@@ -59,3 +63,103 @@ def resolve_dns_localhost(domain_name: str, dns_servers_list: list = None, print
         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).
+    """
+
+    resolver = dns.resolver.Resolver()
+    dns_servers = list(resolver.nameservers)
+
+    is_dynamic = win32networkadapter.is_adapter_dns_gateway_from_dhcp(use_default_interface=True)
+    return is_dynamic, dns_servers
+
+
+def set_connection_dns_gateway_static(
+        dns_servers: list[str],
+        connection_name: str = None,
+        use_default_connection: bool = False
+) -> None:
+    """
+    Set the DNS servers for a network adapter.
+    :param connection_name: string, adapter name as shown in the network settings.
+    :param dns_servers: list of strings, DNS server IPv4 addresses.
+    :param use_default_connection: bool, if True, the default network interface will be used. This is the connection
+        that you internet is being used from.
+    :return: None
+    """
+
+    win32networkadapter.set_dns_server(
+        connection_name=connection_name, dns_servers=dns_servers, use_default_interface=use_default_connection)
+
+
+def set_connection_dns_gateway_dynamic(
+        connection_name: str = None,
+        use_default_connection: bool = False
+) -> None:
+    """
+    Set the DNS servers for a network adapter to obtain them automatically from DHCP.
+    :param connection_name: string, adapter name as shown in the network settings.
+    :param use_default_connection: bool, if True, the default network interface will be used. This is the connection
+        that you internet is being used from.
+    :return: None
+    """
+
+    win32networkadapter.set_dns_server(
+        connection_name=connection_name, dns_servers=None, use_default_interface=use_default_connection)
+
+
+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_connection_group = argparse_obj.add_mutually_exclusive_group()
+    arg_connection_group.add_argument(
+        '-cn', '--connection_name', type=str, help='Connection name as shown in the network settings.')
+    arg_connection_group.add_argument(
+        '-cd', '--connection_default', action='store_true', help='Use the default connection.')
+
+    args = argparse_obj.parse_args()
+
+    if (args.set or args.dynamic) and not (args.connection_name or args.connection_default):
+        print_api("Please provide the connection name [-cn] or use the default connection [-cd].", color='red')
+        return 1
+
+    if args.set or args.dynamic:
+        if not permissions.is_admin():
+            print_api("You need to run this script as an administrator", color='red')
+            return 1
+
+    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(f'DNS Gateway: {is_dynamic_string} - {dns_servers}', color='blue')
+    elif args.set:
+        # dns_servers_list: list = args.dns_servers.split(',')
+        set_connection_dns_gateway_static(
+            dns_servers=args.set, connection_name=args.connection_name,
+            use_default_connection=args.connection_default)
+    elif args.dynamic:
+        set_connection_dns_gateway_dynamic(
+            connection_name=args.connection_name, use_default_connection=args.connection_default)

atomicshop/file_io/docxs.py

@@ -26,6 +26,14 @@ def get_hyperlinks(docx_path):
         if not paragraph.hyperlinks:
             continue
         for hyperlink in paragraph.hyperlinks:
+            # Hyperlinks are stored in docx (document.xml) without the fragment part.
+            # Fragment is the anchor of the link, for example: 'https://www.example.com#anchor'.
+            # So the hyperlink.address is stored as 'https://www.example.com'.
+            # And the fragment is stored in the hyperlink.fragment as 'anchor'.
+            # For the full hyperlink, we need to concatenate the address and the fragment.
+            # If there is no anchor in the link the fragment will be empty string ('').
+            if hyperlink.fragment:
+                hyperlinks.append(hyperlink.address + "#" + hyperlink.fragment)
             hyperlinks.append(hyperlink.address)
 
     return hyperlinks

atomicshop/file_io/tomls.py

@@ -10,6 +10,10 @@ except ModuleNotFoundError:
 from . import file_io
 
 
+class TomlValueNotImplementedError(Exception):
+    pass
+
+
 @file_io.read_file_decorator
 def read_toml_file(file_path: str,
                    file_mode: str = 'rb',
@@ -84,3 +88,132 @@ def dumps(toml_dict: dict):
         toml_string += process_item(key, value)
 
     return toml_string
+
+
+def update_toml_file_with_new_config(
+        main_config_file_path: str,
+        changes_config_file_path: str = None,
+        changes_dict: dict = None,
+        new_config_file_path: str = None
+) -> None:
+    """
+    Update the old toml config file with the new values from the new toml config file.
+    This will update only the changed values.
+    If the values from the changes file aren't present in the main config file, they will not be added.
+
+    :param main_config_file_path: string, path to the main config file that you want to use as the main reference.
+        If you provide the 'new_config_file_path', then changes to the 'main_config_file_path' will be written there.
+    :param changes_config_file_path: string, the config file path that have the changes.
+        Only changed values will be updated to the 'main_config_file_path'.
+    :param changes_dict: dict, the dictionary with the changes.
+        Instead of providing the 'changes_config_file_path', you can provide only the dictionary with the changes.
+    :param new_config_file_path: string, path to the new config file.
+        If provided, the changes will be written to this file.
+        If not, the changes will be written to the 'main_config_file_path'.
+    """
+
+    # Sync the config files.
+    with open(main_config_file_path, 'r') as file:
+        main_config_file_text_lines: list = file.readlines()
+
+    main_config_file_text_lines_backup: list = list(main_config_file_text_lines)
+
+    # Read the new config file.
+    main_config_file_dict: dict = read_toml_file(main_config_file_path)
+
+    if changes_dict:
+        changes_config_file_dict = changes_dict
+    else:
+        changes_config_file_dict: dict = read_toml_file(changes_config_file_path)
+
+    # Update the config text lines.
+    for category, settings in main_config_file_dict.items():
+        if category not in changes_config_file_dict:
+            continue
+
+        for key, value in settings.items():
+            # If the key is in the old config file, use the old value.
+            if key not in changes_config_file_dict[category]:
+                continue
+
+            if main_config_file_dict[category][key] != changes_config_file_dict[category][key]:
+                # Get the line of the current category line.
+                current_category_line_index_in_text = None
+                for current_category_line_index_in_text, line in enumerate(main_config_file_text_lines):
+                    if f"[{category}]" in line:
+                        break
+
+                # current_category_line_index_in_text = main_config_file_text_lines.index(f"[{category}]\n")
+                current_category_index_in_main_config_dict = list(main_config_file_dict.keys()).index(category)
+
+                try:
+                    next_category_name = list(
+                        main_config_file_dict.keys())[current_category_index_in_main_config_dict + 1]
+                except IndexError:
+                    next_category_name = list(main_config_file_dict.keys())[-1]
+
+                next_category_line_index_in_text = None
+                for next_category_line_index_in_text, line in enumerate(main_config_file_text_lines):
+                    if f"[{next_category_name}]" in line:
+                        break
+
+                # In case the current and the next categories are the same and the last in the file.
+                if next_category_line_index_in_text == current_category_line_index_in_text:
+                    next_category_line_index_in_text = len(main_config_file_text_lines)
+
+                string_to_check_list: list = list()
+                if isinstance(value, bool):
+                    string_to_check_list.append(f"{key} = {str(value).lower()}")
+                elif isinstance(value, int):
+                    string_to_check_list.append(f"{key} = {value}")
+                elif isinstance(value, str):
+                    string_to_check_list.append(f"{key} = '{value}'")
+                    string_to_check_list.append(f'{key} = "{value}"')
+                else:
+                    raise TomlValueNotImplementedError(f"Value type '{type(value)}' not implemented.")
+
+                # next_category_line_index_in_text = main_config_file_text_lines.index(f"[{next_category_name}]\n")
+                # Find the index of this line in the text file between current category line and
+                # the next category line.
+                line_index = None
+                found_line = False
+                for line_index in range(current_category_line_index_in_text, next_category_line_index_in_text):
+                    if found_line:
+                        line_index = line_index - 1
+                        break
+                    for string_to_check in string_to_check_list:
+                        if string_to_check in main_config_file_text_lines[line_index]:
+                            found_line = True
+                            break
+
+                if found_line:
+                    # If there are comments, get only them from the line. Comment will also get the '\n' character.
+                    # noinspection PyUnboundLocalVariable
+                    comment = main_config_file_text_lines[line_index].replace(string_to_check, '')
+
+                    object_type = type(changes_config_file_dict[category][key])
+                    if object_type == bool:
+                        value_string_to_set = str(changes_config_file_dict[category][key]).lower()
+                    elif object_type == str:
+                        value_string_to_set = f"'{changes_config_file_dict[category][key]}'"
+                    elif object_type == int:
+                        value_string_to_set = str(changes_config_file_dict[category][key])
+
+                    # noinspection PyUnboundLocalVariable
+                    line_to_set = f"{key} = {value_string_to_set}{comment}"
+                    # Replace the line with the old value.
+                    main_config_file_text_lines[line_index] = line_to_set
+
+                    main_config_file_dict[category][key] = changes_config_file_dict[category][key]
+
+    if new_config_file_path:
+        file_path_to_write = new_config_file_path
+    else:
+        file_path_to_write = main_config_file_path
+
+    if not main_config_file_text_lines == main_config_file_text_lines_backup:
+        # Write the final config file.
+        with open(file_path_to_write, 'w') as file:
+            file.writelines(main_config_file_text_lines)
+    else:
+        print("No changes to the config file.")

atomicshop/filesystem.py

@@ -240,7 +240,7 @@ def check_absolute_path___add_full(filesystem_path: str, full_path_to_add: str)
     """
 
     if not check_absolute_path(filesystem_path):
-        return f'{full_path_to_add}{os.sep}{remove_first_separator(filesystem_path)}'
+        return f'{full_path_to_add}{os.sep}{remove_last_separator(filesystem_path)}'
     else:
         return filesystem_path
 
@@ -815,10 +815,11 @@ def remove_last_separator(directory_path: str) -> str:
     return directory_path.removesuffix(os.sep)
 
 
-def remove_first_separator(filesystem_path: str) -> str:
+def remove_last_separator(filesystem_path: str) -> str:
     """
-    The function removes the first character in 'filesystem_path' if it is a separator returning the processed string.
-    If the first character is not a separator, nothing is happening.
+    The function removes the last character in 'filesystem_path' if it is a system separator ('/' or '\')
+    returning the processed string.
+    If the character is not a separator, nothing happens.
 
     :param filesystem_path:
     :return:

atomicshop/get_process_list.py

@@ -1,6 +1,6 @@
 from typing import Union, Literal
 
-from .wrappers.pywin32w import wmi_win32process
+from .wrappers.pywin32w.wmis import win32process
 from .wrappers.psutilw import psutilw
 from .basics import dicts
 from . import get_process_name_cmd_dll
@@ -36,7 +36,7 @@ class GetProcessList:
             self.process_polling_instance = psutilw.PsutilProcesses()
             self.connected = True
         elif self.get_method == 'pywin32':
-            self.process_polling_instance = wmi_win32process.Pywin32Processes()
+            self.process_polling_instance = win32process.Pywin32Processes()
         elif self.get_method == 'process_dll':
             self.process_polling_instance = get_process_name_cmd_dll.ProcessNameCmdline()
 
@@ -130,4 +130,4 @@ test = get_process_list.get_processes()
 
     # globals need to be specified, otherwise the setup_code won't work with passed variables.
     times = timeit.timeit(setup=setup_code, stmt=test_code, number=times_to_test, globals=locals())
-    print(f'Execution time: {times}')
+    print(f'Execution time: {times}')

atomicshop/mitm/config_static.py

@@ -0,0 +1,195 @@
+import os
+from dataclasses import dataclass
+
+from . import import_config
+
+
+SCRIPT_VERSION: str = '1.7.0'
+
+
+# CONFIG = None
+LIST_OF_BOOLEANS: list = [
+    ('dns', 'enable'),
+    ('dns', 'offline_mode'),
+    ('dns', 'resolve_to_tcp_server_only_engine_domains'),
+    ('dns', 'resolve_to_tcp_server_all_domains'),
+    ('dns', 'resolve_regular'),
+    ('dns', 'set_default_dns_gateway_to_localhost'),
+    ('dns', 'set_default_dns_gateway_to_default_interface_ipv4'),
+    ('tcp', 'enable'),
+    ('tcp', 'engines_usage'),
+    ('tcp', 'server_response_mode'),
+    ('certificates', 'default_server_certificate_usage'),
+    ('certificates', 'sni_add_new_domains_to_default_server_certificate'),
+    ('certificates', 'custom_server_certificate_usage'),
+    ('certificates', 'sni_create_server_certificate_for_each_domain'),
+    ('certificates', 'sni_get_server_certificate_from_server_socket'),
+    ('skip_extensions', 'tls_web_client_authentication'),
+    ('skip_extensions', 'crl_distribution_points'),
+    ('skip_extensions', 'authority_information_access'),
+    ('process_name', 'get_process_name')
+]
+
+
+TOML_TO_STATIC_CATEGORIES: dict = {
+    'dns': 'DNSServer',
+    'tcp': 'TCPServer',
+    'log': 'Log',
+    'recorder': 'Recorder',
+    'certificates': 'Certificates',
+    'skip_extensions': 'SkipExtensions',
+    'process_name': 'ProcessName'
+}
+
+
+class MainConfig:
+    SCRIPT_DIRECTORY: str = None
+
+    ENGINES_DIRECTORY_PATH: str = None
+    ENGINES_DIRECTORY_NAME: str = "engines"
+    ENGINE_CONFIG_FILE_NAME: str = "engine_config.toml"
+
+    # Certificates.
+    default_server_certificate_name: str = 'default'
+    ca_certificate_name: str = 'ElaborateCA'
+    # CA Certificate name and file name without extension.
+    ca_certificate_filepath: str = None
+    # Default server certificate file name and path.
+    default_server_certificate_filename = f'{default_server_certificate_name}.pem'
+    default_server_certificate_filepath: str = None
+
+    @classmethod
+    def update(cls):
+        # This runs after the dataclass is initialized
+        cls.ENGINES_DIRECTORY_PATH = cls.SCRIPT_DIRECTORY + os.sep + cls.ENGINES_DIRECTORY_NAME
+        cls.ca_certificate_filepath = f'{cls.SCRIPT_DIRECTORY}{os.sep}{cls.ca_certificate_name}.pem'
+        cls.default_server_certificate_filepath = \
+            f'{cls.SCRIPT_DIRECTORY}{os.sep}{cls.default_server_certificate_filename}'
+
+
+@dataclass
+class DNSServer:
+    enable: bool
+    offline_mode: bool
+
+    listening_interface: str
+    listening_port: int
+    forwarding_dns_service_ipv4: str
+    cache_timeout_minutes: int
+
+    resolve_to_tcp_server_only_engine_domains: bool
+    resolve_to_tcp_server_all_domains: bool
+    resolve_regular: bool
+    target_tcp_server_ipv4: str
+
+    set_default_dns_gateway: str
+    set_default_dns_gateway_to_localhost: bool
+    set_default_dns_gateway_to_default_interface_ipv4: bool
+
+
+@dataclass
+class TCPServer:
+    enable: bool
+
+    engines_usage: bool
+    server_response_mode: bool
+
+    listening_interface: str
+    listening_port_list: list[int]
+
+    forwarding_dns_service_ipv4_list___only_for_localhost: list[str]
+
+
+@dataclass
+class Log:
+    logs_path: str
+
+
+@dataclass
+class Recorder:
+    recordings_path: str
+
+
+@dataclass
+class Certificates:
+    default_server_certificate_usage: bool
+    sni_add_new_domains_to_default_server_certificate: bool
+
+    custom_server_certificate_usage: bool
+    custom_server_certificate_path: str
+    custom_private_key_path: str
+
+    sni_create_server_certificate_for_each_domain: bool
+    sni_server_certificates_cache_directory: str
+    sni_get_server_certificate_from_server_socket: bool
+    sni_server_certificate_from_server_socket_download_directory: str
+
+    domains_all_times: list[str]
+
+
+@dataclass
+class SkipExtensions:
+    tls_web_client_authentication: bool
+    crl_distribution_points: bool
+    authority_information_access: bool
+
+    SKIP_EXTENSION_ID_LIST: list
+
+
+@dataclass
+class ProcessName:
+    get_process_name: bool
+    ssh_user: str
+    ssh_pass: str
+
+    ssh_script_to_execute = 'process_from_port'
+
+
+def load_config(config_toml_file_path: str):
+    # global CONFIG
+
+    script_path = os.path.dirname(config_toml_file_path)
+    MainConfig.SCRIPT_DIRECTORY = script_path
+    MainConfig.update()
+
+    # Load the configuration file.
+    result = import_config.import_config_file(config_toml_file_path)
+    return result
+
+
+# ============ Server Tester Specific ===============
+CONFIG_INI_TESTER_FILE_NAME: str = 'config_tester.ini'
+
+"""
+config.ini:
+target_domain_or_ip: the domain or ip that the requests will be sent to. Better use domains, for better testing
+    simulation.
+target_port: the port that requests will be sent to.
+request_type: type of each request: json / string / binary.
+    json format that contain a key with hex string of the request that will be converted to bytes.
+    string that will contain a request and will be converted to bytes.
+    binary file that will contain all request data - will be converted to bytes.
+request_json_hex_key_list: this key stores raw request in hex format, since there can be characters that can't be 
+    decoded to string / unicode.
+    'request_raw_hex' key is the default key in recorded files from mitm server, you may add keys for your custom
+     JSON files.
+requests_directory: the directory that requests are will be taken from. Can be relative folder that will be in
+    current working directory.
+
+parallel_connections_bool: boolean, sets if sockets should be initialized in threads (in parallel) or one after another.
+    Use all the connections / cycles in parallel when 'True'. New sockets will be created for each request.
+    Reuse the same socket / connection for all the requests when 'False'.
+interval_between_requests_defaults_seconds: default interval in seconds between request sends.
+interval_between_request_custom_list_seconds: list of intervals in seconds. If this configuration will not be empty,
+    this should be a list. Each interval in the list will follow the interval between requests and 
+    'interval_between_requests_defaults_seconds' will not be used. It will be used only if number of requests
+    is less than then number of intervals in 'interval_between_request_custom_list_seconds'. The missing intervals
+    will be filled by default values from 'interval_between_requests_defaults_seconds'.
+    Example: you have 10 requests.
+        interval_between_requests_defaults_seconds = 5
+        interval_between_request_custom_list_seconds = 7, 10, 8, 4, 15
+    The rest will be filled from defaults: 7, 10, 8, 4, 15, 5, 5, 5, 5
+send_request_batch_cycles: how many batch cycles to send of the same 10 requests (or any other number of requests that
+    you might have in the requests folder.
+interval_between_batch_cycles_seconds: interval in seconds between each batch.
+"""

atomicshop/mitm/config_toml_editor.py

@@ -0,0 +1,55 @@
+from dataclasses import dataclass
+
+from ..file_io import tomls
+
+
+class CategoryNotFoundInConfigError(Exception):
+    pass
+
+
+@dataclass
+class PropertyUpdate:
+    """
+    :param category: str, Category in the config file.
+    :param category_property: str, Property in the category.
+    :param value: str, Value to set to the property.
+    """
+    category: str
+    category_property: str
+    value: any
+
+
+def update_properties(
+        property_update_list: list[PropertyUpdate],
+        config_file_path: str
+) -> None:
+    """
+    Edit a property in the config file.
+
+    :param property_update_list: list of PropertyUpdate objects.
+    :param config_file_path: str, Path to the config file.
+
+    -----------
+
+    Config Example:
+    [category]
+    category_property = value
+    """
+
+    toml_config = tomls.read_toml_file(config_file_path)
+
+    for property_update in property_update_list:
+        if property_update.category not in toml_config:
+            raise CategoryNotFoundInConfigError(f"Category '{property_update.category}' not found in the config file.")
+
+    changes_dict: dict = dict()
+    for property_update in property_update_list:
+        if property_update.category in changes_dict:
+            changes_dict[property_update.category].update({property_update.category_property: property_update.value})
+        else:
+            changes_dict[property_update.category] = {property_update.category_property: property_update.value}
+
+    tomls.update_toml_file_with_new_config(
+        main_config_file_path=config_file_path,
+        changes_dict=changes_dict
+    )