\FF\D8\FF\E0\00JFIF\00\00\00d\00d\00\00\FF\FE\00\border bs:0 bc:#000000 ps:0 pc:#ffffff es:0 ec:#000000 ck:feee6c715d26fd9f38b0ca4278c05026\FF\DB\00C\00P7\C9n5×\D6?\BDê\9Ds\EBp\9F[`8m\B7)o\B5\E8\E6I\99\FE3]]A2\BA\8Cw\D6E\93\\DEv\C8\009\F2\F1NI?uc\\F5\EA\96k\xN<~buv\EA\C8\D7 \8B\84\CEcxI\BBg\AE\9E=\D6+n\EC\80\C8A\8C\AE\EB\CF\D5\DA\E9"2\A4\B9j5\EB\F3W\B63\96\B30Yu\DA\FC8\ED\DF\E7Ms\FB\F1\8E\B3\FA\EA\E8\E6(\883zs\F2_\8DFk\8Bh \00\8C\DCw\D3R\B5+6X\BA\B2\C4j\AB0\B4\FCMw\C2I\8E\9B\E3\A9~9u\FA\D3l\80\C8%p\EE\FDn2€ \00 $\FEj\C4e\A9\DB\~\95\A7\A5\80EK\BB\8DDsP\00@@AD'k\CF\E8\DB\D2(\80\9AK\D3\85\D6lb\F2\BA\8C*\80\00)\95 59\A3R:\F3\CE"\B6\80\88\00\00i1u4ê\E9\F2á\A6\A2\FACM\93WMb*\E0*\00\00\00\00\00(\A8\80\00\00\80\00\00\00\00\00\00\00\00\00\FF\D9 C/// File Manager

File Manager

Path: /opt/imunify360/venv/lib/python3.11/site-packages/defence360agent/utils/

Viewing File: 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