404

[ Avaa Bypassed ]




Upload:

Command:

botdev@3.145.67.115: ~ $
import subprocess
from ..logger import logger
from .. import exceptions
import requests
from ..enums import KillswitchStatusEnum, ProtocolEnum, ConnectionTypeEnum
from ..constants import FLAT_SUPPORTED_PROTOCOLS
import re
from .environment import ExecutionEnvironment


class Utilities:

    @staticmethod
    def ensure_connectivity():
        utils = Utilities()

        utils.ensure_internet_connection_is_available()

    @staticmethod
    def ensure_internet_connection_is_available():
        logger.info("Checking for internet connectivity")
        if ExecutionEnvironment().settings.killswitch != KillswitchStatusEnum.DISABLED:
            logger.info("Skipping as killswitch is enabled")
            return

        # 192.0.2.1 is used because is a valid IP that won't be in use,
        # since it is reserved for documentation purposes:
        # https://www.rfc-editor.org/rfc/rfc5737.html
        result = subprocess.run(["ip", "route", "get", "192.0.2.1"], check=False, capture_output=True)
        if result.returncode != 0:
            raise exceptions.NetworkConnectionError(
                "No internet connection. "
                "Please make sure you are connected and retry."
            )

    @staticmethod
    def ensure_servername_is_valid(servername):
        """Check if the provided servername is in a valid format.

        Args:
            servername (string): the servername [SE-PT#1]
        Returns:
            bool
        """
        logger.info("Validating servername")
        if not isinstance(servername, str):
            err_msg = "Incorrect object type, "\
                "str is expected but got {} instead".format(type(servername))
            logger.error(
                "[!] TypeError: {}. Raising Exception.".format(err_msg)
            )
            raise TypeError(err_msg)

        re_compile = re.compile(r"^(\w\w)(-\w+)?#(\w+-)?(\w+)$")

        if not re_compile.search(servername):
            raise exceptions.UnexpectedServername(
                "Unexpected servername {}".format(
                    servername
                )
            )

    @staticmethod
    def ensure_ip_is_valid(ipaddr):
        """Check if the provided IP is valid IPv4.

        Args:
            ipaddr (string): IPv4

        Returns:
            bool
        """
        if not isinstance(ipaddr, str):
            raise ValueError("Invalid object type")

        valid_ip_re = re.compile(
            r'^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.'
            r'(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.'
            r'(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.'
            r'(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)'
            r'(/(3[0-2]|[12][0-9]|[1-9]))?$'  # Matches CIDR
        )

        if not valid_ip_re.match(ipaddr):
            raise Exception(
                "Invalid IP address \"{}\"".format(
                    ipaddr
                )
            )

    @staticmethod
    def is_protocol_valid(protocol):
        logger.info("Checking if protocol is valid")
        try:
            protocol = ProtocolEnum(protocol)
        except (TypeError, ValueError):
            return False

        if protocol in FLAT_SUPPORTED_PROTOCOLS:
            return True

        return False

    @staticmethod
    def ensure_protocol_is_valid(protocol):
        """Check if provided protocol is a valid protocol.

        Args:
            protocol (ProtocolEnum)

        Returns:
            bool
        """
        logger.info("Ensuring provided protocol is valid")
        if not Utilities.is_protocol_valid(protocol):
            raise Exception(
                "Invalid protocol \"{}\"".format(
                    protocol
                )
            )

    @staticmethod
    def parse_user_input(user_input):
        connection_type = user_input.get("connection_type")
        connection_type_extra_arg = user_input.get("connection_type_extra_arg")
        protocol = user_input.get("protocol")

        utils = Utilities
        if connection_type == ConnectionTypeEnum.COUNTRY:
            from .country import Country
            country = Country()
            country.ensure_country_code_exists(connection_type_extra_arg)
        if connection_type == ConnectionTypeEnum.SERVERNAME:
            utils.ensure_servername_is_valid(
                connection_type_extra_arg
            )

        connection_type = connection_type
        connection_type_extra_arg = connection_type_extra_arg

        if connection_type not in [
            ConnectionTypeEnum.SERVERNAME, ConnectionTypeEnum.COUNTRY
        ]:
            connection_type_extra_arg = connection_type

        if not utils.is_protocol_valid(protocol):
            protocol = ProtocolEnum(
                ExecutionEnvironment().settings.protocol
            )
        else:
            protocol = ProtocolEnum(protocol)

        return connection_type, connection_type_extra_arg, protocol

    @staticmethod
    def post_setup_connection_save_metadata(
        connection_metadata, servername,
        protocol, physical_server
    ):
        connection_metadata.save_servername(servername)
        connection_metadata.save_protocol(protocol)
        connection_metadata.save_display_server_ip(physical_server.exit_ip)
        connection_metadata.save_server_ip(physical_server.entry_ip)

Filemanager

Name Type Size Permission Actions
__pycache__ Folder 0755
accounting Folder 0755
client_config Folder 0755
connection_backend Folder 0755
dbus Folder 0755
keyring Folder 0755
killswitch Folder 0755
location Folder 0755
metadata Folder 0755
notification Folder 0755
report Folder 0755
servers Folder 0755
session Folder 0755
streaming Folder 0755
user_settings Folder 0755
vpn Folder 0755
__init__.py File 966 B 0644
country.py File 2.95 KB 0644
environment.py File 4.42 KB 0644
status.py File 2.77 KB 0644
subprocess_wrapper.py File 4.1 KB 0644
utilities.py File 5.2 KB 0644
utils.py File 961 B 0644