atomicshop 3.3.8__py3-none-any.whl → 3.10.0__py3-none-any.whl

atomicshop/wrappers/socketw/get_process.py

@@ -1,123 +0,0 @@
-# Needed to redirect output from console to logger on LOCALHOST process command line harvesting.
-import io
-from contextlib import redirect_stdout
-import logging
-
-from . import base
-from ...ssh_remote import SSHRemote
-from ...print_api import print_api
-
-import psutil
-
-
-class GetCommandLine:
-    def __init__(
-            self,
-            client_socket=None,
-            ssh_script_processor=None,
-            ssh_user: str = None,
-            ssh_pass: str = None,
-            logger: logging.Logger = None
-    ):
-        self.client_socket = client_socket
-        self.ssh_script_processor = ssh_script_processor
-        self.ssh_user: str = ssh_user
-        self.ssh_pass: str = ssh_pass
-        self.logger: logging.Logger = logger
-
-    def get_process_name(self, print_kwargs: dict = None):
-        # Get client ip and the source port.
-        client_ip, source_port = base.get_source_address_from_socket(self.client_socket)
-
-        # Put source port variable inside the string script.
-        updated_script_string = self.ssh_script_processor.put_variable_into_script_string(
-            source_port, print_kwargs=print_kwargs)
-
-        process_name = self.get_process_commandline(
-            client_ip=client_ip,
-            script_string=updated_script_string,
-            print_kwargs=print_kwargs)
-
-        return process_name
-
-    def get_process_commandline(
-            self,
-            client_ip: str,
-            script_string: str,
-            print_kwargs: dict = None
-    ):
-        execution_output = None
-        execution_error = None
-
-        # Checking if we're on localhost. If not, we'll execute SSH connection to get calling process name.
-        if client_ip not in base.THIS_DEVICE_IP_LIST:
-            # Tried using paramiko SSH concurrently within threads, but with bigger loads it just breaks.
-            # So, better using it separately for each thread.
-
-            print_api(f"Initializing SSH connection to [{client_ip}]", **print_kwargs)
-            # Initializing SSHRemote class.
-            current_ssh_client = SSHRemote(
-                ip_address=client_ip, username=self.ssh_user, password=self.ssh_pass, logger=self.logger)
-
-            execution_output, execution_error = current_ssh_client.connect_get_client_commandline(script_string)
-        # Else, if we're on localhost, then execute the script directly without SSH.
-        else:
-            print_api(f"Executing LOCALHOST command to get the calling process.", **print_kwargs)
-            # Getting the redirection from console print, since that what the 'script_string' does.
-            with io.StringIO() as buffer, redirect_stdout(buffer):
-                # Executing the script with print to console.
-                try:
-                    exec(script_string)
-                except ModuleNotFoundError as function_exception_object:
-                    execution_error = f"Module not installed: {function_exception_object}"
-                    print_api(
-                        execution_error, error_type=True, logger_method="error", traceback_string=True,
-                        **print_kwargs)
-                except psutil.AccessDenied:
-                    execution_error = f"Access Denied for 'psutil' to read system process command line. " \
-                                      f"Run script with Admin Rights."
-                    print_api(
-                        execution_error, error_type=True, logger_method="error", traceback_string=True,
-                        **print_kwargs)
-
-                if not execution_error:
-                    # Reading the buffer.
-                    execution_output = buffer.getvalue()
-
-        # This section is generic for both remote SSH and localhost executions of the script.
-        process_name = self.get_commandline_and_error(execution_output, execution_error, print_kwargs=print_kwargs)
-
-        return process_name
-
-    @staticmethod
-    def get_commandline_and_error(
-            execution_output,
-            execution_error,
-            print_kwargs: dict = None
-    ):
-        # If there was known error on localhost / known error on remote or any kind of error on remote, it was
-        # already logged, so we'll just put the error into 'process_name'.
-        if execution_error:
-            process_name = execution_error
-            print_api(
-                f"Error During Command Execution: {process_name}", error_type=True,
-                logger_method='error', **(print_kwargs or {}))
-        # If there wasn't any error of above types, then we can put the output from either local or remote script
-        # execution into 'process_name' and log it / output to console.
-        else:
-            # If the output that was returned is not empty.
-            if execution_output:
-                # Replacing '\r\n' escape lines with string, so that the line will not be escaped in logs.
-                if '\r\n' in execution_output:
-                    execution_output = execution_output.replace('\r\n', '')
-                elif '\n' in execution_output:
-                    execution_output = execution_output.replace('\n', '')
-
-                process_name = execution_output
-                print_api(f"Client Process Command Line: {process_name}", **(print_kwargs or {}))
-            # Else if the script output came back empty.
-            else:
-                process_name = "Client Process Command Line came back empty after script execution."
-                print_api(process_name, error_type=True, logger_method='error', **(print_kwargs or {}))
-
-        return process_name

atomicshop/wrappers/wslw.py

@@ -1,192 +0,0 @@
-import sys
-from pathlib import Path
-
-from ..import process, permissions, virtualization
-from ..permissions import permissions
-from ..print_api import print_api
-
-
-def is_installed():
-    # Command to check the status of the WSL feature
-    command = "Get-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux"
-
-    # Check if WSL is enabled
-    if "Enabled" in process.run_powershell_command(command):
-        return True
-    else:
-        return False
-
-
-def get_installed_distros() -> list:
-    """
-    Get a list of installed WSL distros.
-    :return: list, list of installed WSL distros.
-    """
-    return process.execute_with_live_output("wsl --list --quiet")
-
-
-def get_available_distros_to_install() -> list:
-    """
-    Get a list of available WSL distros to install.
-    :return: list, list of available WSL distros to install.
-    """
-    return process.execute_with_live_output("wsl --list --online")
-
-
-def is_ubuntu_installed(version: str = "22.04") -> bool:
-    """
-    Check if specific version of Ubuntu is installed on WSL.
-    :param version: string, Ubuntu version to check for. Default is 22.04.
-    :return: bool, True if Ubuntu is installed, False otherwise.
-    """
-
-    if not version:
-        version = str()
-
-    installed_distros_list = get_installed_distros()
-
-    if f'Ubuntu-{version}' in installed_distros_list:
-        return True
-    elif 'Ubuntu' in installed_distros_list:
-        # Command to get Ubuntu version
-        command = f"wsl -d Ubuntu lsb_release -a"
-
-        # Execute the command
-        result = process.execute_with_live_output(command)
-
-        is_version_installed: bool = False
-        # Parse the output for the version number
-        for line in result:
-            if "Release" in line and version in line:
-                is_version_installed = True
-                break
-
-        return is_version_installed
-    else:
-        return False
-
-
-def install_wsl_manual(
-        directory_path: str, enable_virtual_machine_platform: bool = True, set_default_version_2: bool = True):
-    # noinspection GrazieInspection
-    """
-        Install WSL on Windows 10.
-        :param directory_path: string, directory path to save Ubuntu package.
-        :param enable_virtual_machine_platform: bool, True to enable Virtual Machine Platform feature.
-        :param set_default_version_2: bool, True to set WSL version 2 as default.
-
-        Main.py example:
-            import sys
-            from atomicshop.wrappers import wslw
-
-
-            def main():
-                if len(sys.argv) < 2:
-                    print("Usage: python main.py <directory_path_to_save_Ubuntu_package>")
-                    sys.exit(1)
-
-                wslw.install_wsl(directory_path=sys.argv[1])
-
-
-            if __name__ == '__main__':
-                main()
-        """
-
-    # Check for admin privileges
-    if not permissions.is_admin():
-        sys.exit("Script must be run as administrator")
-
-    # Check if WSL is already installed
-    if is_installed():
-        print_api("WSL is already installed", color='green')
-    else:
-        # Enable WSL
-        print_api("Enabling Windows Subsystem for Linux...")
-        process.run_powershell_command(
-            "Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux -NoRestart")
-
-        # # Check if the system needs a reboot
-        # if "RestartNeeded : True" in process.run_powershell_command(
-        #         "Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux"):
-        #     print_api("Please restart your computer to complete the installation of WSL and rerun the script.")
-        #     sys.exit(0)
-
-    # Enable Virtual Machine Platform is needed for WSL 2.
-    if enable_virtual_machine_platform:
-        # Check if Hyper-V is enabled
-        if "Enabled" in process.run_powershell_command(
-                "Get-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V"):
-            print_api("Hyper-V is enabled")
-        else:
-            # Command to enable Virtual Machine Platform
-            command = "Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V -All -NoRestart"
-
-            print_api("Enabling Virtual Machine Platform...")
-            process.run_powershell_command(command)
-
-    # Set WSL version 2 as default.
-    if set_default_version_2:
-        print_api("Setting WSL version 2 as default...")
-        process.execute_with_live_output("wsl --set-default-version 2")
-
-    # Check if Ubuntu is already installed. If so, exit with a message.
-    if is_ubuntu_installed():
-        print_api("Ubuntu is already installed", color='green')
-        sys.exit(0)
-
-    # Before you install Ubuntu, you need to set the WSL to version 2.
-    # You can do it after you install, but if so, you will need to set the Ubuntu to version 2 either.
-    # Download and Install Ubuntu.
-    print_api("Installing Ubuntu for WSL...")
-    package_file_path: str = str(Path(directory_path, "Ubuntu.appx"))
-    process.run_powershell_command(
-        f"Invoke-WebRequest -Uri https://aka.ms/wslubuntu2204 -OutFile {package_file_path} -UseBasicParsing")
-    process.run_powershell_command(f"Add-AppxPackage {package_file_path}")
-
-    print_api("Ubuntu installation is complete. You can now launch Ubuntu from the Start Menu.")
-    print_api("Please restart your computer to complete the installation.")
-
-
-def install_wsl(distro: str = "Ubuntu-22.04"):
-    # noinspection GrazieInspection
-    """
-        Install WSL and Ubuntu.
-        :param distro: string, distro to install. Default is Ubuntu-22.04.
-        :return:
-
-        Main.py example:
-            from atomicshop.wrappers import wslw
-
-
-            def main():
-                wslw.install_wsl()
-
-
-            if __name__ == '__main__':
-                main()
-        """
-
-    # Check for admin privileges
-    if not permissions.is_admin():
-        print_api("Script must be run as administrator", color='red')
-        sys.exit(1)
-
-    # Check if virtualization is enabled.
-    if not virtualization.is_enabled():
-        print_api("Virtualization is not enabled in the bios. Please enable it and rerun the script.", color='red')
-        sys.exit(1)
-
-    # Check if WSL and Ubuntu is already installed
-    wsl_installed: bool = is_installed()
-    ubuntu_installed: bool = is_ubuntu_installed()
-
-    if wsl_installed and ubuntu_installed:
-        print_api("WSL and Ubuntu is already installed", color='green')
-        sys.exit(0)
-    elif wsl_installed and not ubuntu_installed:
-        print_api("WSL is already installed, installing Ubuntu")
-    elif not wsl_installed:
-        print_api("WSL is not installed, installing WSL and Ubuntu")
-
-    command = f"wsl --install -d {distro}"
-    process.execute_with_live_output(command, verbose=True)

atomicshop-3.3.8.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-pywintrace = atomicshop.a_installs.pywintrace:main