cloudcheck 8.4.3__cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl

cloudcheck/providers/base.py

@@ -0,0 +1,269 @@
+import ipaddress
+import os
+import traceback
+import subprocess
+import time
+from pathlib import Path
+from typing import Dict, List, Union
+from pydantic import BaseModel, field_validator, computed_field
+
+from ..helpers import defrag_cidrs, parse_v2fly_domain_file, request
+
+
+v2fly_repo_pulled = False
+
+
+class BaseProvider(BaseModel):
+    """
+    Base class for all cloud providers.
+
+    Each provider inherits from this class and overrides any of the default values.
+    They can also override the update_cidrs() method to fetch cidrs from a different source.
+    """
+
+    # these values are static and always loaded from the class definition
+    regexes: Dict[str, List[str]] = {}
+    tags: List[str] = []  # Tags for the provider (e.g. "cdn", "waf", etc.)
+    org_ids: List[str] = []  # ASN Organization IDs (e.g. GOGL-ARIN)
+    v2fly_company: str = ""  # Company name for v2fly domain fetching
+
+    # these values are dynamic and set by the update() method
+    last_updated: float = time.time()
+
+    # these we allow static values but they are later merged with dynamic values
+    asns: List[int] = []
+    cidrs: List[str] = []
+    domains: List[str] = []
+
+    @field_validator("cidrs")
+    @classmethod
+    def validate_cidrs(cls, value):
+        ips = []
+        for v in value:
+            try:
+                ips.append(ipaddress.ip_network(v, strict=False))
+            except ValueError:
+                print(f"Invalid CIDR: from {cls.__name__}: {v}")
+                continue
+        ips = [str(ip) for ip in defrag_cidrs(ips)]
+        return sorted(ips)
+
+    @field_validator("domains")
+    @classmethod
+    def validate_domains(cls, value):
+        return sorted(list(set([d.lower().strip(".") for d in value])))
+
+    @computed_field(return_type=str)
+    @property
+    def name(self):
+        return self.__class__.__name__
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        print(f"Initializing {self.name}")
+        self._cidrs = []
+        self._cache_dir = Path.home() / ".cache" / "cloudcheck"
+        self._repo_url = "https://github.com/v2fly/domain-list-community.git"
+        self._asndb_url = os.getenv("ASNDB_URL", "https://asndb.api.bbot.io/v1")
+        self._bbot_io_api_key = os.getenv("BBOT_IO_API_KEY")
+
+    def update(self):
+        print(f"Updating {self.name}")
+        errors = []
+        errors.extend(self.update_domains())
+        errors.extend(self.update_cidrs())
+        return errors
+
+    def update_domains(self):
+        # update dynamic domains
+        errors = []
+        if self.v2fly_company:
+            domains, errors = self.fetch_v2fly_domains()
+            if domains:
+                self.domains = sorted(list(set(self.domains + domains)))
+            else:
+                errors.append(
+                    f"No v2fly domains were found for {self.name} (company name: {self.v2fly_company})"
+                )
+        return errors
+
+    def update_cidrs(self):
+        cidrs = set()
+        errors = []
+
+        # query by direct ASNs
+        if self.asns:
+            _cidrs, _errors = self.fetch_asns()
+            print(f"Got {len(_cidrs)} ASN cidrs for {self.name}'s ASNs {self.asns}")
+            if not _cidrs:
+                errors.append(
+                    f"No ASN cidrs were found for {self.name}'s ASNs {self.asns}"
+                )
+            errors.extend(_errors)
+            cidrs.update(_cidrs)
+
+        # query by org IDs
+        if self.org_ids:
+            _cidrs, _asns, _errors = self.fetch_org_ids()
+            _asns = _asns.copy()
+            _asns.update(self.asns)
+            self.asns = list(sorted(_asns))
+            print(
+                f"Got {len(_cidrs)} org id cidrs for {self.name}'s org ids {self.org_ids}"
+            )
+            if not _cidrs:
+                errors.append(
+                    f"No cidrs were found for {self.name}'s org ids {self.org_ids}"
+                )
+            errors.extend(_errors)
+            cidrs.update(_cidrs)
+
+        # fetch any dynamically-updated lists of CIDRs
+        try:
+            dynamic_cidrs = self.fetch_cidrs()
+            print(f"Got {len(dynamic_cidrs)} dynamic cidrs for {self.name}")
+            cidrs.update(dynamic_cidrs)
+        except Exception as e:
+            errors.append(
+                f"Failed to fetch dynamic cidrs for {self.name}: {e}:\n{traceback.format_exc()}"
+            )
+
+        # finally, put in any manually-specified CIDRs
+        print(f"Adding {len(self.cidrs)} manually-specified cidrs for {self.name}")
+        if self.cidrs:
+            cidrs.update(self.cidrs)
+
+        print(f"Total {len(cidrs)} cidrs for {self.name}")
+
+        try:
+            self.cidrs = self.validate_cidrs(cidrs)
+        except Exception as e:
+            errors.append(
+                f"Error validating ASN cidrs for {self.name}: {e}:\n{traceback.format_exc()}"
+            )
+
+        self.last_updated = time.time()
+
+        return errors
+
+    def fetch_org_ids(
+        self,
+    ) -> List[Union[ipaddress.IPv4Network, ipaddress.IPv6Network]]:
+        """Takes org_ids and populates the .asns and .cidrs attributes."""
+        errors = []
+        cidrs = set()
+        print(f"Fetching {len(self.org_ids)} org ids for {self.name}")
+        asns = set()
+        for org_id in self.org_ids:
+            print(f"Fetching cidrs for {org_id} from asndb")
+            try:
+                url = f"{self._asndb_url}/org/{org_id}"
+                print(f"Fetching {url}")
+                res = self.request(url, include_api_key=True)
+                print(f"{url} -> {res}: {res.text}")
+                j = res.json()
+            except Exception as e:
+                errors.append(
+                    f"Failed to fetch cidrs for {org_id} from asndb: {e}:\n{traceback.format_exc()}"
+                )
+                continue
+            _asns = j.get("asns", [])
+            for asn in _asns:
+                asns.add(asn)
+                asn_cidrs, _errors = self.fetch_asn(asn)
+                errors.extend(_errors)
+                cidrs.update(asn_cidrs)
+        return cidrs, asns, errors
+
+    def fetch_asns(self) -> List[Union[ipaddress.IPv4Network, ipaddress.IPv6Network]]:
+        """Fetch CIDRs for a given list of ASNs from ASNDB."""
+        cidrs = []
+        errors = []
+        print(f"Fetching {len(self.asns)} ASNs for {self.name}")
+        for asn in self.asns:
+            asn_cidrs, _errors = self.fetch_asn(asn)
+            errors.extend(_errors)
+            cidrs.update(asn_cidrs)
+        return cidrs, errors
+
+    def fetch_asn(
+        self, asn: int
+    ) -> List[Union[ipaddress.IPv4Network, ipaddress.IPv6Network]]:
+        """Fetch CIDRs for a given ASN from ASNDB."""
+        cidrs = []
+        errors = []
+        url = f"{self._asndb_url}/asn/{asn}"
+        print(f"Fetching {url}")
+        try:
+            res = self.request(url, include_api_key=True)
+            print(f"{url} -> {res.text}")
+            j = res.json()
+            cidrs = j.get("subnets", [])
+        except Exception as e:
+            errors.append(
+                f"Failed to fetch cidrs for {asn} from asndb: {e}:\n{traceback.format_exc()}"
+            )
+        print(f"Got {len(cidrs)} cidrs for {asn}")
+        return cidrs, errors
+
+    def fetch_v2fly_domains(self) -> List[str]:
+        """Fetch domains from the v2fly community repository."""
+        if not self.v2fly_company:
+            return [], []
+
+        errors = []
+        repo_path, _success = self._ensure_v2fly_repo_cached()
+        company_file = repo_path / "data" / self.v2fly_company
+        try:
+            domains = parse_v2fly_domain_file(company_file)
+        except Exception as e:
+            errors.append(
+                f"Failed to parse {self.v2fly_company} domains: {e}:\n{traceback.format_exc()}"
+            )
+        return sorted(list(domains)), errors
+
+    def fetch_cidrs(self) -> List[str]:
+        """Fetch CIDRs from a custom source."""
+        return []
+
+    def fetch_domains(self) -> List[str]:
+        """Fetch domains from a custom source."""
+        return []
+
+    def _ensure_v2fly_repo_cached(self) -> Path:
+        """Ensure the community repo is cloned and up-to-date."""
+        global v2fly_repo_pulled
+        errors = []
+        repo_dir = self._cache_dir / "domain-list-community"
+        if not repo_dir.exists():
+            self._cache_dir.mkdir(parents=True, exist_ok=True)
+            try:
+                subprocess.run(
+                    ["git", "clone", "--depth", "1", self._repo_url, str(repo_dir)],
+                    check=True,
+                    capture_output=True,
+                )
+                v2fly_repo_pulled = True
+            except subprocess.CalledProcessError as e:
+                errors.append(
+                    f"Failed to clone v2fly repo: {e}:\n{traceback.format_exc()}"
+                )
+        elif not v2fly_repo_pulled:
+            try:
+                subprocess.run(
+                    ["git", "pull"], cwd=repo_dir, check=True, capture_output=True
+                )
+            except subprocess.CalledProcessError as e:
+                errors.append(
+                    f"Failed to pull v2fly repo: {e}:\n{traceback.format_exc()}"
+                )
+        return repo_dir, errors
+
+    def request(self, *args, **kwargs):
+        return request(*args, **kwargs)
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(name='{self.name}')"

cloudcheck/providers/cisco.py

@@ -0,0 +1,39 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Cisco(BaseProvider):
+    v2fly_company: str = "cisco"
+    tags: List[str] = ["cloud"]
+    # {"org_id": "CISCO-25-ARIN", "org_name": "Cisco Systems Inc.", "country": "US", "asns": [25949]}
+    # {"org_id": "CISCO-32-ARIN", "org_name": "Cisco Systems, Inc.", "country": "US", "asns": [63096]}
+    # {"org_id": "CISCOR-ARIN", "org_name": "CIS Corporation", "country": "US", "asns": [3792]}
+    # {"org_id": "CISL-7-ARIN", "org_name": "Cisco Systems Ironport Division", "country": "US", "asns": [16417,30214,30215,30238,40427]}
+    # {"org_id": "CS-2787-ARIN", "org_name": "Cisco Systems Inc", "country": "US", "asns": [398699]}
+    # {"org_id": "CS-2821-ARIN", "org_name": "Cisco IoT", "country": "US", "asns": [36180,393544]}
+    # {"org_id": "CS-2825-ARIN", "org_name": "Cisco Systems, Inc.", "country": "US", "asns": [396922]}
+    # {"org_id": "CS-2831-ARIN", "org_name": "CISCO SYSTEMS, INC.", "country": "US", "asns": [109,2051,3943,22183,23460,26092,36519,40590,54140,399780]}
+    # {"org_id": "CS-691-ARIN", "org_name": "Cisco Systems Cloud Division", "country": "US", "asns": [1343,32644]}
+    # {"org_id": "CS-985-ARIN", "org_name": "Cisco Systems, Inc.", "country": "US", "asns": [55219]}
+    # {"org_id": "OPEND-2-ARIN", "org_name": "Cisco OpenDNS, LLC", "country": "US", "asns": [25605,30607,36692]}
+    # {"org_id": "ORG-CIL21-RIPE", "org_name": "Cisco International Limited", "country": "GB", "asns": [201799]}
+    # {"org_id": "ORG-CL586-RIPE", "org_name": "CISCOM Ltd", "country": "RU", "asns": [61035]}
+    # {"org_id": "ORG-CSNA1-RIPE", "org_name": "Cisco Systems Norway AS", "country": "NO", "asns": [58298]}
+    # {"org_id": "WEX-ARIN", "org_name": "Cisco Webex LLC", "country": "US", "asns": [6577,13445,16472,26152,53258,399937]}
+    org_ids: List[str] = [
+        "CISCO-25-ARIN",
+        "CISCO-32-ARIN",
+        "CISCOR-ARIN",
+        "CISL-7-ARIN",
+        "CS-2787-ARIN",
+        "CS-2821-ARIN",
+        "CS-2825-ARIN",
+        "CS-2831-ARIN",
+        "CS-691-ARIN",
+        "CS-985-ARIN",
+        "OPEND-2-ARIN",
+        "ORG-CIL21-RIPE",
+        "ORG-CL586-RIPE",
+        "ORG-CSNA1-RIPE",
+        "WEX-ARIN",
+    ]

cloudcheck/providers/cloudflare.py

@@ -0,0 +1,40 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List, Dict
+
+
+class Cloudflare(BaseProvider):
+    v2fly_company: str = "cloudflare"
+    tags: List[str] = ["cdn"]
+    # {"org_id": "CLOUD14-ARIN", "org_name": "Cloudflare, Inc.", "country": "US", "asns": [13335,14789,394536,395747,400095]}
+    # {"org_id": "ORG-CHKL1-AP-APNIC", "org_name": "Cloudflare Hong Kong, LLC", "country": "US", "asns": [133877]}
+    # {"org_id": "ORG-CI4-AP-APNIC", "org_name": "Cloudflare, Inc.", "country": "US", "asns": [132892]}
+    # {"org_id": "ORG-CI40-RIPE", "org_name": "Cloudflare Inc", "country": "US", "asns": [202623,203898]}
+    # {"org_id": "ORG-CLL6-RIPE", "org_name": "Cloudflare London, LLC", "country": "US", "asns": [209242]}
+    # {"org_id": "ORG-CSL5-AP-APNIC", "org_name": "Cloudflare Sydney, LLC", "country": "US", "asns": [139242]}
+    org_ids: List[str] = [
+        "CLOUD14-ARIN",
+        "ORG-CHKL1-AP-APNIC",
+        "ORG-CI4-AP-APNIC",
+        "ORG-CI40-RIPE",
+        "ORG-CLL6-RIPE",
+        "ORG-CSL5-AP-APNIC",
+    ]
+    _bucket_name_regex = r"[a-z0-9_][a-z0-9-\.]{1,61}[a-z0-9]"
+    regexes: Dict[str, List[str]] = {
+        "STORAGE_BUCKET_NAME": [_bucket_name_regex],
+        "STORAGE_BUCKET_HOSTNAME": [
+            r"(" + _bucket_name_regex + r")\.(r2\.dev)",
+            r"(" + _bucket_name_regex + r")\.(r2\.cloudflarestorage\.com)",
+        ],
+    }
+
+    _ips_url = "https://api.cloudflare.com/client/v4/ips"
+
+    def fetch_cidrs(self):
+        response = self.request(self._ips_url)
+        ranges = set()
+        response_json = response.json()
+        for ip_type in ("ipv4_cidrs", "ipv6_cidrs"):
+            for ip_range in response_json.get("result", {}).get(ip_type, []):
+                ranges.add(ip_range)
+        return list(ranges)

cloudcheck/providers/cloudfront.py

@@ -0,0 +1,18 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Cloudfront(BaseProvider):
+    tags: List[str] = ["cdn"]
+
+    _ips_url = "https://d7uri8nf7uskq.cloudfront.net/tools/list-cloudfront-ips"
+
+    def fetch_cidrs(self):
+        response = self.request(self._ips_url)
+        ranges = set()
+        response_json = response.json()
+        if not isinstance(response_json, dict):
+            raise ValueError(f"Invalid response format: {type(response_json)}")
+        for r in response_json.values():
+            ranges.update(r)
+        return list(ranges)

cloudcheck/providers/dell.py

@@ -0,0 +1,11 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Dell(BaseProvider):
+    v2fly_company: str = "dell"
+    tags: List[str] = ["cloud"]
+    # {"org_id": "DCC-25-ARIN", "org_name": "Dell, Inc.", "country": "US", "asns": [3612,3613,3614,3615,7977,12257,14876,17187,23144,30614,46507,46977,53878,54701,64208]}
+    org_ids: List[str] = [
+        "DCC-25-ARIN",
+    ]

cloudcheck/providers/digitalocean.py

@@ -0,0 +1,30 @@
+import csv
+from cloudcheck.providers.base import BaseProvider
+from typing import List, Dict
+
+
+class DigitalOcean(BaseProvider):
+    v2fly_company: str = "digitalocean"
+    tags: List[str] = ["cloud"]
+    # {"org_id": "DO-13-ARIN", "org_name": "DigitalOcean, LLC", "country": "US", "asns": [14061,46652,62567,393406,394362]}
+    org_ids: List[str] = [
+        "DO-13-ARIN",
+    ]
+    _bucket_name_regex = r"[a-z0-9][a-z0-9-]{2,62}"
+    regexes: Dict[str, List[str]] = {
+        "STORAGE_BUCKET_NAME": [_bucket_name_regex],
+        "STORAGE_BUCKET_HOSTNAME": [
+            r"(" + _bucket_name_regex + r")\.([a-z]{3}[\d]{1}\.digitaloceanspaces\.com)"
+        ],
+    }
+
+    _ips_url = "https://www.digitalocean.com/geo/google.csv"
+
+    def fetch_cidrs(self):
+        response = self.request(self._ips_url)
+        do_ips = csv.DictReader(
+            response.content.decode("utf-8").splitlines(),
+            fieldnames=["range", "country", "region", "city", "postcode"],
+        )
+        ranges = set(i["range"] for i in do_ips)
+        return list(ranges)

cloudcheck/providers/fastly.py

@@ -0,0 +1,22 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Fastly(BaseProvider):
+    v2fly_company: str = "fastly"
+    tags: List[str] = ["cdn"]
+    # {"org_id": "SKYCA-3-ARIN", "org_name": "Fastly, Inc.", "country": "US", "asns": [895,54113,394192]}
+    org_ids: List[str] = [
+        "SKYCA-3-ARIN",
+    ]
+
+    _ips_url = "https://api.fastly.com/public-ip-list"
+
+    def fetch_cidrs(self):
+        response = self.request(self._ips_url)
+        j = response.json()
+        if j and isinstance(j, dict):
+            addresses = j.get("addresses", [])
+            if addresses and isinstance(addresses, list):
+                return list(set(addresses))
+        return []

cloudcheck/providers/github.py

@@ -0,0 +1,28 @@
+import ipaddress
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class GitHub(BaseProvider):
+    v2fly_company: str = "github"
+    tags: List[str] = ["cdn"]
+    # {"org_id": "GITHU-ARIN", "org_name": "GitHub, Inc.", "country": "US", "asns": [36459]}
+    org_ids: List[str] = [
+        "GITHU-ARIN",
+    ]
+
+    _ips_url = "https://api.github.com/meta"
+
+    def fetch_cidrs(self):
+        response = self.request(self._ips_url)
+        ranges = set()
+        response_json = response.json()
+        for k, v in response_json.items():
+            if isinstance(v, list):
+                for n in v:
+                    try:
+                        ipaddress.ip_network(n)
+                        ranges.add(n)
+                    except ValueError:
+                        pass
+        return list(ranges)

cloudcheck/providers/google.py

@@ -0,0 +1,61 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List, Dict
+
+
+class Google(BaseProvider):
+    v2fly_company: str = "google"
+    # domains = ["googleapis.cn", "googleapis.com", "cloud.google.com", "gcp.gvt2.com", "appspot.com", "firebaseio.com", "google"]
+    tags: List[str] = ["cloud"]
+    # {"org_id": "GAL-53-ARIN", "org_name": "Google Access LLC", "country": "US", "asns": [32381]}
+    # {"org_id": "GF-ARIN", "org_name": "Google Fiber Inc.", "country": "US", "asns": [6432,16591,19448]}
+    # {"org_id": "GL-946-ARIN", "org_name": "Google LLC", "country": "US", "asns": [33715]}
+    # {"org_id": "GOGL-ARIN", "org_name": "Google LLC", "country": "US", "asns": [13949,15169,19425,22577,22859,26684,36039,36040,40873]}
+    # {"org_id": "GOOGL-1-ARIN", "org_name": "Google LLC", "country": "US", "asns": [36383,36384,36385,36411,36520]}
+    # {"org_id": "GOOGL-2-ARIN", "org_name": "Google LLC", "country": "US", "asns": [16550,19527,26910,36561,55023,394089,395973,396178,396982]}
+    # {"org_id": "GOOGL-5-ARIN", "org_name": "Google LLC", "country": "US", "asns": [394639]}
+    # {"org_id": "GOOGL-9-ARIN", "org_name": "Google LLC", "country": "US", "asns": [394507]}
+    # {"org_id": "GOOGL-ARIN", "org_name": "Google, LLC", "country": "US", "asns": [36492]}
+    # {"org_id": "ORG-GAPP2-AP-APNIC", "org_name": "Google Asia Pacific Pte. Ltd.", "country": "SG", "asns": [139070,139190]}
+    # {"org_id": "ORG-GCEL1-RIPE", "org_name": "Google Cloud EMEA Ltd", "country": "IE", "asns": [209504,209519,209539,214609,214611]}
+    # {"org_id": "ORG-GIL4-RIPE", "org_name": "Google Ireland Limited", "country": "IE", "asns": [43515]}
+    # {"org_id": "ORG-GKL1-AFRINIC", "org_name": "Google Kenya Limited", "country": "KE", "asns": [36987]}
+    # {"org_id": "ORG-GSG10-RIPE", "org_name": "Google Switzerland GmbH", "country": "CH", "asns": [41264]}
+    # {"org_id": "ORG-GSPL5-AP-APNIC", "org_name": "Google Singapore Pte. Ltd.", "country": "SG", "asns": [45566]}
+    org_ids: List[str] = [
+        "GAL-53-ARIN",
+        "GF-ARIN",
+        "GL-946-ARIN",
+        "GOGL-ARIN",
+        "GOOGL-1-ARIN",
+        "GOOGL-2-ARIN",
+        "GOOGL-5-ARIN",
+        "GOOGL-9-ARIN",
+        "GOOGL-ARIN",
+        "ORG-GAPP2-AP-APNIC",
+        "ORG-GCEL1-RIPE",
+        "ORG-GIL4-RIPE",
+        "ORG-GKL1-AFRINIC",
+        "ORG-GSG10-RIPE",
+        "ORG-GSPL5-AP-APNIC",
+    ]
+    _bucket_name_regex = r"[a-z0-9][a-z0-9-_\.]{1,61}[a-z0-9]"
+    _firebase_bucket_name_regex = r"[a-z0-9][a-z0-9-\.]{1,61}[a-z0-9]"
+    regexes: Dict[str, List[str]] = {
+        "STORAGE_BUCKET_NAME": [_bucket_name_regex, _firebase_bucket_name_regex],
+        "STORAGE_BUCKET_HOSTNAME": [
+            r"(" + _firebase_bucket_name_regex + r")\.(firebaseio\.com)",
+            r"(" + _bucket_name_regex + r")\.(storage\.googleapis\.com)",
+        ],
+    }
+
+    _ips_url = "https://www.gstatic.com/ipranges/cloud.json"
+
+    def fetch_cidrs(self):
+        response = self.request(self._ips_url)
+        ranges = set()
+        for p in response.json()["prefixes"]:
+            try:
+                ranges.add(p["ipv4Prefix"])
+            except KeyError:
+                ranges.add(p["ipv6Prefix"])
+        return list(ranges)

cloudcheck/providers/heroku.py

@@ -0,0 +1,7 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Heroku(BaseProvider):
+    v2fly_company: str = "heroku"
+    tags: List[str] = ["cloud"]

cloudcheck/providers/hetzner.py

@@ -0,0 +1,18 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List, Dict
+
+
+class Hetzner(BaseProvider):
+    v2fly_company: str = "hetzner"
+    tags: List[str] = ["cloud"]
+    # {"org_id": "ORG-HOA1-RIPE", "org_name": "Hetzner Online GmbH", "country": "DE", "asns": [24940,212317,213230,215859]}
+    org_ids: List[str] = [
+        "ORG-HOA1-RIPE",
+    ]
+    _bucket_name_regex = r"[a-z0-9][a-z0-9-_\.]{1,61}[a-z0-9]"
+    regexes: Dict[str, List[str]] = {
+        "STORAGE_BUCKET_NAME": [_bucket_name_regex],
+        "STORAGE_BUCKET_HOSTNAME": [
+            r"(" + _bucket_name_regex + r")\.(your-objectstorage\.com)"
+        ],
+    }

cloudcheck/providers/hpe.py

@@ -0,0 +1,12 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class HPE(BaseProvider):
+    # Hewlett Packard Enterprise Development, L.P.
+    v2fly_company: str = "hpe"
+    tags: List[str] = ["cloud"]
+    # {"org_id": "HPE-15-ARIN", "org_name": "HEWLETT PACKARD ENTERPRISE COMPANY", "country": "US", "asns": [157,1033,1034,13481,20096,22149,25867,27510,40617,395714,395992,396063,397363,397957,398199,399185,399610,400054,400624,400737,400763]}
+    org_ids: List[str] = [
+        "HPE-15-ARIN",
+    ]

cloudcheck/providers/huawei.py

@@ -0,0 +1,17 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Huawei(BaseProvider):
+    v2fly_company: str = "huawei"
+    tags: List[str] = ["cloud"]
+    # {"org_id": "ORG-HIPL2-AP-APNIC", "org_name": "HUAWEI INTERNATIONAL PTE. LTD.", "country": "SG", "asns": [131444,136907,141180,149167,151610]}
+    # {"org_id": "ORG-HT57-RIPE", "org_name": "HUAWEI TECHNOLOGIES(UK)CO.,LTD", "country": "GB", "asns": [206798]}
+    # {"org_id": "ORG-HT61-RIPE", "org_name": "Huawei Tech(UAE)FZ-LLC", "country": "AE", "asns": [206204]}
+    # {"org_id": "ORG-HTB10-RIPE", "org_name": "Huawei Technologies (Netherlands) B.V.", "country": "NL", "asns": [200756]
+    org_ids: List[str] = [
+        "ORG-HIPL2-AP-APNIC",
+        "ORG-HT57-RIPE",
+        "ORG-HT61-RIPE",
+        "ORG-HTB10-RIPE",
+    ]

cloudcheck/providers/ibm.py

@@ -0,0 +1,57 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class IBM(BaseProvider):
+    v2fly_company: str = "ibm"
+    tags: List[str] = ["cloud"]
+    # {"org_id": "AWDIC-ARIN", "org_name": "Advanced Workstations Division, IBM Corporation", "country": "US", "asns": [706]}
+    # {"org_id": "IAD-7-ARIN", "org_name": "IBM AS/400 Division", "country": "US", "asns": [10337]}
+    # {"org_id": "IBM-1-ARIN", "org_name": "IBM", "country": "US", "asns": [763,10676,12237,15293,17390,18703,19152,19604,19898,22722,23145,23257,26543,27477,27530,29834,393850,395473]}
+    # {"org_id": "IBM-1-Z-ARIN", "org_name": "IBM", "country": "US", "asns": [163,547,1747,1786,1956,1997,2538,3082,3383]}
+    # {"org_id": "IBM-43-ARIN", "org_name": "IBM", "country": "US", "asns": [2560]}
+    # {"org_id": "IBMC-14-ARIN", "org_name": "IBM Corporation", "country": "US", "asns": [19765]}
+    # {"org_id": "IBMC-24-ARIN", "org_name": "IBM Cloud", "country": "US", "asns": [13749,13884,21844,30315,36351,36420,46702,46703,46704]}
+    # {"org_id": "IBML-1-ARIN", "org_name": "ibml", "country": "US", "asns": [40847]}
+    # {"org_id": "ICNS-4-ARIN", "org_name": "IBM Canada Network Services Company", "country": "CA", "asns": [3059]}
+    # {"org_id": "ORG-ACL6-AP-APNIC", "org_name": "FIBMESH IN LIMITED", "country": "IN", "asns": [133082,149779]}
+    # {"org_id": "ORG-CIF2-RIPE", "org_name": "COMPAGNIE IBM FRANCE SAS", "country": "FR", "asns": [202213]}
+    # {"org_id": "ORG-IBBC1-RIPE", "org_name": "IBM BTO Business Consulting Services Sp. z o.o.", "country": "PL", "asns": [200138]}
+    # {"org_id": "ORG-IBMC1-RIPE", "org_name": "INTERNATIONAL BUSINESS MACHINES CORPORATION", "country": "US", "asns": [204764,209394]}
+    # {"org_id": "ORG-IBMO1-RIPE", "org_name": "International Business Machines of Belgium Ltd", "country": "BE", "asns": [15776]}
+    # {"org_id": "ORG-IBSI1-AP-APNIC", "org_name": "IBM Business Services, Inc", "country": "PH", "asns": [133377]}
+    # {"org_id": "ORG-IDG12-RIPE", "org_name": "IBM Deutschland GmbH", "country": "DE", "asns": [214585]}
+    # {"org_id": "ORG-IIAT1-RIPE", "org_name": "IBM Israel-Science and technology Ltd.", "country": "IL", "asns": [50995]}
+    # {"org_id": "ORG-INZL1-AP-APNIC", "org_name": "IBM New Zealand Limited", "country": "NZ", "asns": [24189]}
+    # {"org_id": "ORG-IR9-RIPE", "org_name": "IBM Romania SRL", "country": "RO", "asns": [61179]}
+    # {"org_id": "ORG-IRS1-RIPE", "org_name": "IBM Romania S.R.L.", "country": "RO", "asns": [43283]}
+    # {"org_id": "ORG-ISPL9-AP-APNIC", "org_name": "IBM Singapore Pte Ltd", "country": "SG", "asns": [10120,134667,135291,136468,138450]}
+    # {"org_id": "ORG-IUL5-RIPE", "org_name": "IBM United Kingdom Limited", "country": "GB", "asns": [203652]}
+    # {"org_id": "ORG-LS306-RIPE", "org_name": "LTD SibMediaFon", "country": "RU", "asns": [48507]}
+    # {"org_id": "ORG-SCG6-RIPE", "org_name": "IBM Deutschland GmbH", "country": "DE", "asns": [50524]}
+    org_ids: List[str] = [
+        "AWDIC-ARIN",
+        "IAD-7-ARIN",
+        "IBM-1-ARIN",
+        "IBM-1-Z-ARIN",
+        "IBM-43-ARIN",
+        "IBMC-14-ARIN",
+        "IBMC-24-ARIN",
+        "IBML-1-ARIN",
+        "ICNS-4-ARIN",
+        "ORG-ACL6-AP-APNIC",
+        "ORG-CIF2-RIPE",
+        "ORG-IBBC1-RIPE",
+        "ORG-IBMC1-RIPE",
+        "ORG-IBMO1-RIPE",
+        "ORG-IBSI1-AP-APNIC",
+        "ORG-IDG12-RIPE",
+        "ORG-IIAT1-RIPE",
+        "ORG-INZL1-AP-APNIC",
+        "ORG-IR9-RIPE",
+        "ORG-IRS1-RIPE",
+        "ORG-ISPL9-AP-APNIC",
+        "ORG-IUL5-RIPE",
+        "ORG-LS306-RIPE",
+        "ORG-SCG6-RIPE",
+    ]