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

atomicshop/mitm/initialize_mitm_server.py

@@ -1,240 +0,0 @@
-import os
-import threading
-
-# Importing atomicshop package to get the version of the package.
-import atomicshop
-
-from .import_config import ImportConfig
-from .initialize_engines import ModuleCategory
-from .connection_thread_worker import thread_worker_main
-from .. import filesystem, queues
-from ..python_functions import get_current_python_version_string, check_python_version_compliance
-from ..wrappers.socketw.socket_wrapper import SocketWrapper
-from ..wrappers.socketw.dns_server import DnsServer
-from ..basics import dicts_nested
-from ..wrappers.loggingw import loggingw
-from ..print_api import print_api
-
-
-def initialize_mitm_server(config_static):
-    # Main function should return integer with error code, 0 is successful.
-    # Since listening server is infinite, this will not be reached.
-    def output_statistics_csv_header():
-        # Since there is no implementation of header in logging file handler modules, we'll do it manually each time.
-        statistics_header: list = ['request_time_sent',
-                                   'host',
-                                   'path',
-                                   'command',
-                                   'status_code',
-                                   'request_size_bytes',
-                                   'response_size_bytes',
-                                   # 'request_hex',
-                                   # 'response_hex',
-                                   'file_path',
-                                   'process_cmd',
-                                   'error'
-                                   ]
-        statistics_logger.info(','.join(statistics_header))
-
-    # After modules import - we check for python version.
-    check_python_version_compliance(minimum_version='3.11')
-
-    # Preparing everything for the logging module.
-    # Log folder path is in the "config.ini" file, so we need to read it before setting loggers.
-    config_importer = ImportConfig(
-        file_name=config_static.CONFIG_INI_SERVER_FILE_NAME, directory_path=config_static.WORKING_DIRECTORY)
-    config_importer.open()
-    config = config_importer.config
-
-    # Create folders.
-    filesystem.create_directory(config['log']['logs_path'])
-    filesystem.create_directory(config['recorder']['recordings_path'])
-    if config['certificates']['sni_get_server_certificate_from_server_socket']:
-        filesystem.create_directory(
-            config['certificates']['sni_server_certificate_from_server_socket_download_directory'])
-
-    # Create a logger that will log messages to file, Initiate System logger.
-    system_logger = loggingw.get_logger_with_stream_handler_and_timedfilehandler(
-        "system", config['log']['logs_path'], disable_duplicate_ms=True)
-
-    # Writing first log.
-    system_logger.info("======================================")
-
-    if config_importer.admin_rights is not None:
-        if not config_importer.admin_rights:
-            system_logger.error("User continued with errors on Command Line harvesting for system processes.")
-
-    system_logger.info("Server Started.")
-    system_logger.info(f"Python Version: {get_current_python_version_string()}")
-    system_logger.info(f"Script Version: {config_static.SCRIPT_VERSION}")
-    system_logger.info(f"Atomic Workshop Version: {atomicshop.__version__}")
-    system_logger.info(f"Loaded config.ini: {config_importer.config_parser.file_path}")
-    system_logger.info(f"Log folder: {config['log']['logs_path']}")
-    system_logger.info(f"Recordings folder for Requests/Responses: {config['recorder']['recordings_path']}")
-    system_logger.info(f"Loaded system logger: {system_logger}")
-
-    system_logger.info(f"TCP Server Target IP: {config['dns']['target_tcp_server_ipv4']}")
-
-    # Some 'config.ini' settings logging ===========================================================================
-    if config['certificates']['default_server_certificate_usage']:
-        system_logger.info(
-            f"Default server certificate usage enabled, if no SNI available: "
-            f"{config_static.CONFIG_EXTENDED['certificates']['default_server_certificate_directory']}"
-            f"{os.sep}{config_static.CONFIG_EXTENDED['certificates']['default_server_certificate_name']}.pem")
-
-    if config['certificates']['sni_server_certificates_cache_directory']:
-        system_logger.info(
-            f"SNI function certificates creation enabled. Certificates cache: "
-            f"{config['certificates']['sni_server_certificates_cache_directory']}")
-    else:
-        system_logger.info(f"SNI function certificates creation disabled.")
-
-    if config['certificates']['custom_server_certificate_usage']:
-        system_logger.info(f"Custom server certificate usage is enabled.")
-        system_logger.info(f"Custom Certificate Path: {config['certificates']['custom_server_certificate_path']}")
-
-        # If 'custom_private_key_path' field was populated.
-        if config['certificates']['custom_private_key_path']:
-            system_logger.info(
-                f"Custom Certificate Private Key Path: {config['certificates']['custom_private_key_path']}")
-        else:
-            system_logger.info(f"Custom Certificate Private Key Path wasn't provided in [advanced] section. "
-                               f"Assuming the private key is inside the certificate file.")
-
-    # === Importing engine modules =================================================================================
-    system_logger.info("Importing engine modules.")
-
-    # Get full paths of all the 'engine_config.ini' files.
-    engine_config_path_list = filesystem.get_file_paths_from_directory(
-        directory_path=config_static.ENGINES_DIRECTORY_PATH,
-        file_name_check_pattern=config_static.ENGINE_CONFIG_FILE_NAME)
-
-    # Iterate through all the 'engine_config.ini' file paths.
-    domains_engine_list_full: list = list()
-    engines_list: list = list()
-    for engine_config_path in engine_config_path_list:
-        # Initialize engine.
-        current_module = ModuleCategory(config_static.WORKING_DIRECTORY)
-        current_module.fill_engine_fields_from_config(engine_config_path)
-        current_module.initialize_engine(logs_path=config['log']['logs_path'],
-                                         logger=system_logger)
-
-        # Extending the full engine domain list with this list.
-        domains_engine_list_full.extend(current_module.domain_list)
-        # Append the object to the engines list
-        engines_list.append(current_module)
-    # === EOF Importing engine modules =============================================================================
-    # ==== Initialize Reference Module =============================================================================
-    reference_module = ModuleCategory(config_static.WORKING_DIRECTORY)
-    reference_module.fill_engine_fields_from_general_reference(config_static.ENGINES_DIRECTORY_PATH)
-    reference_module.initialize_engine(logs_path=config['log']['logs_path'],
-                                       logger=system_logger, stdout=False, reference_general=True)
-    # === EOF Initialize Reference Module ==========================================================================
-    # === Engine logging ===========================================================================================
-    # Printing the parsers using "start=1" for index to start counting from "1" and not "0"
-    print_api(f"[*] Found Engines:", logger=system_logger)
-    for index, engine in enumerate(engines_list, start=1):
-        message = f"[*] {index}: {engine.engine_name} | {engine.domain_list}"
-        print_api(message, logger=system_logger)
-
-        message = (f"[*] Modules: {engine.parser_class_object.__name__}, "
-                   f"{engine.responder_class_object.__name__}, "
-                   f"{engine.recorder_class_object.__name__}")
-        print_api(message, logger=system_logger)
-
-    if config['dns']['enable_dns_server']:
-        print_api("DNS Server is enabled.", logger=system_logger)
-
-        # If engines were found and dns is set to route by the engine domains.
-        if engines_list and config['dns']['route_to_tcp_server_only_engine_domains']:
-            print_api("Engine domains will be routed by the DNS server to Built-in TCP Server.", logger=system_logger)
-        # If engines were found, but the dns isn't set to route to engines.
-        elif engines_list and not config['dns']['route_to_tcp_server_only_engine_domains']:
-            message = f"[*] Engine domains found, but the DNS routing is set not to use them for routing."
-            print_api(message, color="yellow", logger=system_logger)
-        elif not engines_list and config['dns']['route_to_tcp_server_only_engine_domains']:
-            raise ValueError("No engines were found, but the DNS routing is set to use them for routing.\n"
-                             "Please check your DNS configuration in the 'config.ini' file.")
-
-        if config['dns']['route_to_tcp_server_all_domains']:
-            print_api("All domains will be routed by the DNS server to Built-in TCP Server.", logger=system_logger)
-
-        if config['dns']['regular_resolving']:
-            print_api(
-                "Regular DNS resolving is enabled. Built-in TCP server will not be routed to",
-                logger=system_logger, color="yellow")
-    else:
-        print_api("DNS Server is disabled.", logger=system_logger, color="yellow")
-
-    if config['tcp']['enable_tcp_server']:
-        print_api("TCP Server is enabled.", logger=system_logger)
-
-        if engines_list and not config['tcp']['engines_usage']:
-            message = \
-                f"Engines found, but the TCP server is set not to use them for processing. General responses only."
-            print_api(message, color="yellow", logger=system_logger)
-        elif engines_list and config['tcp']['engines_usage']:
-            message = f"Engines found, and the TCP server is set to use them for processing."
-            print_api(message, logger=system_logger)
-        elif not engines_list and config['tcp']['engines_usage']:
-            raise ValueError("No engines were found, but the TCP server is set to use them for processing.\n"
-                             "Please check your TCP configuration in the 'config.ini' file.")
-    else:
-        print_api("TCP Server is disabled.", logger=system_logger, color="yellow")
-
-    # === EOF Engine Logging =======================================================================================
-
-    # Assigning all the engines domains to all time domains, that will be responsible for adding new domains.
-    config_static.CONFIG_EXTENDED['certificates']['domains_all_times'] = list(domains_engine_list_full)
-
-    # Creating Statistics logger.
-    statistics_logger = loggingw.get_logger_with_stream_handler_and_timedfilehandler(
-        logger_name="statistics", directory_path=config['log']['logs_path'],
-        file_extension=config_static.CSV_EXTENSION, formatter_message_only=True
-    )
-    output_statistics_csv_header()
-
-    network_logger_name = "network"
-    network_logger = loggingw.get_logger_with_stream_handler_and_timedfilehandler(
-        logger_name=network_logger_name, directory_path=config['log']['logs_path'], disable_duplicate_ms=True)
-    system_logger.info(f"Loaded network logger: {network_logger}")
-
-    # Initiate Listener logger, which is a child of network logger, so he uses the same settings and handlers
-    listener_logger = loggingw.get_logger_with_level(f'{network_logger_name}.listener')
-    system_logger.info(f"Loaded listener logger: {listener_logger}")
-
-    # Create request domain queue.
-    domain_queue = queues.NonBlockQueue()
-
-    # === Initialize DNS module ====================================================================================
-    if config['dns']['enable_dns_server']:
-        # before executing TCP sockets and after executing 'network' logger.
-        dns_server = DnsServer(config)
-        # Passing the engine domain list to DNS server to work with.
-        # 'list' function re-initializes the current list, or else it will be the same instance object.
-        dns_server.domain_list = list(domains_engine_list_full)
-
-        dns_server.request_domain_queue = domain_queue
-        # Initiate the thread.
-        threading.Thread(target=dns_server.start).start()
-
-    # === EOF Initialize DNS module ================================================================================
-    # === Initialize TCP Server ====================================================================================
-    if config['tcp']['enable_tcp_server']:
-        socket_wrapper = SocketWrapper(
-            config=dicts_nested.merge(config, config_static.CONFIG_EXTENDED), logger=listener_logger,
-            statistics_logger=statistics_logger)
-
-        socket_wrapper.create_tcp_listening_socket_list()
-
-        socket_wrapper.requested_domain_from_dns_server = domain_queue
-
-        # General exception handler will catch all the exceptions that occurred in the threads and write it to the log.
-        try:
-            socket_wrapper.loop_for_incoming_sockets(function_reference=thread_worker_main, reference_args=(
-                network_logger, statistics_logger, engines_list, reference_module, config,))
-        except Exception:
-            message = f"Unhandled Exception occurred in 'loop_for_incoming_sockets' function"
-            print_api(message, error_type=True, color="red", logger=network_logger, traceback_string=True, oneline=True)
-
-    # === EOF Initialize TCP Server ================================================================================

atomicshop/monitor/checks/hash.py

@@ -1,44 +0,0 @@
-from ...print_api import print_api
-from .hash_checks import file, url
-
-
-def _execute_cycle(change_monitor_instance, print_kwargs: dict = None):
-    """
-    This function executes the cycle of the change monitor: hash.
-
-    :param change_monitor_instance: Instance of the ChangeMonitor class.
-
-    :return: List of dictionaries with the results of the cycle.
-    """
-
-    if print_kwargs is None:
-        print_kwargs = dict()
-
-    return_list = list()
-    # Loop through all the objects to check.
-    for check_object_index, check_object in enumerate(change_monitor_instance.check_object_list):
-        if change_monitor_instance.object_type == 'file':
-            # Get the hash of the object.
-            file.get_hash(change_monitor_instance, check_object_index, check_object, print_kwargs=print_kwargs)
-        elif 'url_' in change_monitor_instance.object_type:
-            # Get the hash of the object.
-            url.get_hash(change_monitor_instance, check_object_index, check_object, print_kwargs=print_kwargs)
-
-        if change_monitor_instance.first_cycle:
-            # Set the input file path.
-            change_monitor_instance._set_input_file_path(check_object_index=check_object_index)
-
-        # Check if the object was updated.
-        result, message = change_monitor_instance.diff_check_list[check_object_index].check_string(
-            print_kwargs=print_kwargs)
-
-        # If the object was updated, print the message in yellow color, otherwise print in green color.
-        if result:
-            print_api(message, color='yellow', **print_kwargs)
-            # create_message_file(message, self.__class__.__name__, logger=self.logger)
-
-            return_list.append(message)
-        else:
-            print_api(message, color='green', **print_kwargs)
-
-    return return_list

atomicshop/monitor/checks/hash_checks/file.py

@@ -1,55 +0,0 @@
-from .... import filesystem, hashing
-
-
-def get_hash(change_monitor_instance, check_object_index: int, check_object: str, print_kwargs: dict = None):
-    """
-    The function will get the hash of the URL content.
-
-    :param change_monitor_instance: Instance of the ChangeMonitor class.
-    :param check_object_index: integer, index of the object in the 'check_object_list' list.
-    :param check_object: string, full URL to a web page.
-    :param print_kwargs: dict, that contains all the arguments for 'print_api' function.
-    """
-
-    # If this is the first cycle, we need to set several things.
-    if change_monitor_instance.first_cycle:
-        original_name: str = str()
-
-        # If 'generate_input_file_name' is True, or 'store_original_object' is True, we need to create a
-        # filename without extension.
-        if change_monitor_instance.store_original_object or change_monitor_instance.generate_input_file_name:
-            # Get the last directory from the url.
-            original_name = filesystem.get_file_name(check_object)
-            # Make characters lower case.
-            original_name = original_name.lower()
-
-        # If 'store_original_object' is True, then we need to create a filepath to store.
-        if change_monitor_instance.original_object_directory:
-            # Add extension to the file name.
-            original_file_name = original_name
-
-            # Make path for original object.
-            change_monitor_instance.original_object_file_path = filesystem.add_object_to_path(
-                change_monitor_instance.original_object_directory, original_file_name)
-
-        if change_monitor_instance.generate_input_file_name:
-            # Remove dots from the file name.
-            original_name_no_dots = original_name.replace('.', '-')
-            # Make path for 'input_file_name'.
-            change_monitor_instance.input_file_name = f'{original_name_no_dots}.txt'
-
-        # Change settings for the DiffChecker object.
-        change_monitor_instance.diff_check_list[check_object_index].return_first_cycle = False
-
-        change_monitor_instance.diff_check_list[check_object_index].check_object_display_name = \
-            f'{original_name}|{change_monitor_instance.object_type}'
-
-    # Copy the file to the original object directory.
-    if change_monitor_instance.original_object_file_path:
-        filesystem.copy_file(check_object, change_monitor_instance.original_object_file_path)
-
-    # Get hash of the file.
-    hash_string = hashing.hash_file(check_object)
-
-    # Set the hash string to the 'check_object' variable.
-    change_monitor_instance.diff_check_list[check_object_index].check_object = hash_string

atomicshop/monitor/checks/hash_checks/url.py

@@ -1,62 +0,0 @@
-from .... import filesystem, hashing, urls
-
-
-def get_hash(change_monitor_instance, check_object_index: int, check_object: str, print_kwargs: dict = None):
-    """
-    The function will get the hash of the URL content.
-
-    :param change_monitor_instance: Instance of the ChangeMonitor class.
-    :param check_object_index: integer, index of the object in the 'check_object_list' list.
-    :param check_object: string, full URL to a web page.
-    :param print_kwargs: dict, that contains all the arguments for 'print_api' function.
-    """
-    # Extract the method name from the object type.
-    get_method = change_monitor_instance.object_type.split('_', 1)[1]
-
-    # If this is the first cycle, we need to set several things.
-    if change_monitor_instance.first_cycle:
-        original_name: str = str()
-
-        # If 'generate_input_file_name' is True, or 'store_original_object' is True, we need to create a
-        # filename without extension.
-        if change_monitor_instance.store_original_object or change_monitor_instance.generate_input_file_name:
-            # Get the last directory from the url.
-            original_name = urls.url_parser(check_object)['directories'][-1]
-            # Make characters lower case.
-            original_name = original_name.lower()
-
-        # If 'store_original_object' is True, then we need to create a filepath to store.
-        extension = None
-        if change_monitor_instance.original_object_directory:
-            # Add extension to the file name.
-            if 'playwright' in get_method:
-                extension = get_method.split('_')[1]
-            elif get_method == 'urllib':
-                extension = 'html'
-            original_file_name = f'{original_name}.{extension}'
-
-            # Make path for original object.
-            change_monitor_instance.original_object_file_path = filesystem.add_object_to_path(
-                change_monitor_instance.original_object_directory, original_file_name)
-
-        if change_monitor_instance.generate_input_file_name:
-            # Make path for 'input_file_name'.
-            change_monitor_instance.input_file_name = f'{original_name}.txt'
-
-        # Change settings for the DiffChecker object.
-        change_monitor_instance.diff_check_list[check_object_index].return_first_cycle = False
-
-        change_monitor_instance.diff_check_list[check_object_index].check_object_display_name = \
-            f'{original_name}|{change_monitor_instance.object_type}'
-
-    # Get hash of the url. The hash will be different between direct hash of the URL content and the
-    # hash of the file that was downloaded from the URL. Since the file has headers and other information
-    # that is not part of the URL content. The Original downloaded file is for reference only to see
-    # what was the content of the URL at the time of the download.
-    hash_string = hashing.hash_url(
-        check_object, get_method=get_method, path=change_monitor_instance.original_object_file_path,
-        print_kwargs=print_kwargs
-    )
-
-    # Set the hash string to the 'check_object' variable.
-    change_monitor_instance.diff_check_list[check_object_index].check_object = hash_string

atomicshop/pbtkmultifile_argparse.py

@@ -1,88 +0,0 @@
-# v1.0.1 - 26.03.2023 23:50
-import sys
-import argparse
-from argparse import RawTextHelpFormatter
-
-
-class ArgparseWrapper:
-    """
-    # Usage in the main:
-    args = ArgparseWrapper().parser_arguments
-    # Defining variables to each argument
-    input_path: str = args.input
-    output_path: str = args.output
-    """
-
-    def __init__(self):
-        self.application_short: str = 'pbtkMultiFile'
-        self.application_full: str = 'pbtk Multi File wrapper'
-        self.version: str = '1.0.0'
-        self.description: str = 'Find ".proto" files in directory of binaries.'
-        self.description_full: str = f'{self.application_full} v{self.version}\n' \
-                                     f'Description: {self.description}'
-        self.usage_variable: str = "%(prog)s [-h] -in folder_with_binary_files -out full_path_to_output_files\n" \
-                                   "Input or Output path shouldn't end with separator. Example: '\\'."
-        self.parser_arguments = None
-
-        # Execute argparse.
-        self.define_argparse()
-
-    # Function to define argument parser
-    def define_argparse(self):
-        # Create the parser
-        # formatter_class=RawTextHelpFormatter: shows raw text and not the default argparse text parsing.
-        parser = argparse.ArgumentParser(description=self.description_full,
-                                         usage=self.usage_variable,
-                                         formatter_class=RawTextHelpFormatter)
-
-        # Add arguments
-        parser.add_argument('-in', '--input',
-                            action='store', type=str, metavar='PATH_TO_FOLDER_WITH_BINARY_FILES',
-                            required=True,
-                            help='Provide full path to folder that contains binary files.')
-        parser.add_argument('-out', '--output', action='store', type=str, metavar='PATH_TO_SAVE_EXPORTED_FILES',
-                            required=True,
-                            help='Provide full path where you want to store exported file.')
-
-        # A problem before executing 'parse_args()'.
-        # If we get directory path as argument, on windows we can get a path that ends with backslash:
-        # C:\Users\user\documents\
-        # This is the default behaviour of windows when copying path of only the directory.
-        # When the path contains spaces, we need to pass it with double quotes:
-        # "C:\Users\user\documents\some folder name\another\"
-        # When python receives the arguments from CMD they get already parsed, meaning python can do nothing about it.
-        # From input:
-        # python_script.py -in "C:\some folder name\another\" -out "C:\some folder name\another1\"
-        # You will get output:
-        # ['python_script.py',
-        #   '-in',
-        #   'C:\some folder name\another" -out C:\some',
-        #   'folder',
-        #   'name\another1"]
-        # 'parse_args()' gets its input from 'sys.argv'. Meaning, you will need to do some manipulations on that
-        # Before executing the argparse argument parsing.
-        # Probably the fix should be individual for each case.
-        # The simplest solution though is to tell the user not to use backslash in the end of directory in case
-        # of exception.
-
-        try:
-            # Execute parse_args()
-            parsed_arguments = parser.parse_args()
-        # The only thing that you can catch on without modifying Argparse code is 'SystemExit' exception.
-        # You can also provide just 'except' without anything, which isn't the best practice.
-        # Another fix would be to use
-        # argparse.ArgumentParser(exit_on_error=False)
-        # But as of python 3.10.8 it is not working yet.
-        except SystemExit as exception_object:
-            print('======================================')
-            print('[*] Info: Error in provided arguments.')
-            print('[*] Tip: Check if you have backslash "\\" in the end of folder path, if so remove it.')
-            print('======================================')
-            sys.exit()
-
-        # if the folder path argument in the middle will have backslash "\" it will cause an exception.
-        # If the backslash will be in the end, it will not cause exception, but the string will end with double quotes.
-        parsed_arguments.input = parsed_arguments.input.replace('"', '')
-        parsed_arguments.output = parsed_arguments.output.replace('"', '')
-
-        self.parser_arguments = parsed_arguments

atomicshop/permissions.py

@@ -1,110 +0,0 @@
-import os
-import stat
-import ctypes
-import contextlib
-import subprocess
-
-# Import pwd only on linux.
-if os.name == 'posix':
-    import pwd
-
-
-def is_admin() -> bool:
-    """
-    Function checks on Windows or POSIX OSes if the script is executed under Administrative Privileges.
-    :return: True / False.
-    """
-
-    if os.name == 'nt':
-        if ctypes.windll.shell32.IsUserAnAdmin() == 0:
-            result = False
-        else:
-            result = True
-    else:
-        if 'SUDO_USER' in os.environ and os.geteuid() == 0:
-            result = True
-        else:
-            result = False
-
-    return result
-
-
-def get_ubuntu_sudo_executer_username() -> str:
-    """
-    Function gets the username of the user who executed the script with sudo.
-    :return: str, username.
-    """
-
-    if 'SUDO_USER' in os.environ:
-        return os.environ['SUDO_USER']
-    else:
-        return ''
-
-
-def set_executable_permission(file_path: str):
-    """
-    Function sets the executable permission on a file.
-    Equivalent to: chmod +x <file_path>
-
-    :param file_path: str, path to the file.
-    :return:
-    """
-
-    # os.chmod(file_path, os.stat(file_path).st_mode | 0o111)
-    os.chmod(file_path, os.stat(file_path).st_mode | stat.S_IXUSR)
-
-
-def is_executable_permission(file_path: str) -> bool:
-    """
-    Function checks if the file has the executable permission.
-    Equivalent to: stat -c "%a %n" <file_path>
-
-    :param file_path: str, path to the file.
-    :return: bool, True / False.
-    """
-
-    return bool(os.stat(file_path).st_mode & stat.S_IXUSR)
-
-
-def run_as_root(command):
-    subprocess.check_call(['sudo'] + command)
-
-
-@contextlib.contextmanager
-def temporary_regular_permissions():
-    """
-    This function is used to temporarily change the effective user and group ID to the original user's.
-    This is used to run commands with the original user's permissions.
-    If you executed a script with 'sudo' and wanted certain action to execute as regular user and not root.
-
-    Example:
-        with temporary_regular_permissions():
-            # Do something with regular permissions.
-            pass
-
-    :return:
-    """
-    # Save the current effective user and group ID
-    original_euid, original_egid = os.geteuid(), os.getegid()
-
-    try:
-        # Get the original user's UID and GID
-        orig_uid = int(os.environ.get('SUDO_UID', os.getuid()))
-        orig_gid = int(os.environ.get('SUDO_GID', os.getgid()))
-
-        # Set the effective user and group ID to the original user's
-        os.setegid(orig_gid)
-        os.seteuid(orig_uid)
-
-        # Provide the context to do something with these permissions
-        yield
-    finally:
-        # Revert to the original effective user and group ID
-        os.seteuid(original_euid)
-        os.setegid(original_egid)
-
-
-def expand_user_path(user_name, path):
-    pwnam = pwd.getpwnam(user_name)
-    home_dir = pwnam.pw_dir
-    return path.replace("~", home_dir)