cloudcheck 8.7.2__pp311-pypy311_pp73-manylinux_2_17_i686.manylinux2014_i686.whl

cloudcheck/providers/base.py

@@ -0,0 +1,317 @@
+import ipaddress
+import os
+import traceback
+import subprocess
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+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
+    short_description: str = ""  # Short description of the provider
+    long_description: str = ""  # Long description of the provider
+
+    # 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)
+        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 = []
+        domains = set()
+
+        # fetch any dynamically-updated lists of domains
+        try:
+            dynamic_domains = self.fetch_domains()
+            print(f"Got {len(dynamic_domains)} dynamic domains for {self.name}")
+            domains.update(dynamic_domains)
+        except Exception as e:
+            errors.append(
+                f"Failed to fetch dynamic domains for {self.name}: {e}:\n{traceback.format_exc()}"
+            )
+
+        if self.v2fly_company:
+            _domains, _errors = self.fetch_v2fly_domains()
+            if _domains:
+                domains.update(_domains)
+            else:
+                errors.append(
+                    f"No v2fly domains were found for {self.name} (company name: {self.v2fly_company})"
+                )
+            errors.extend(_errors)
+
+        # finally, put in any manually-specified domains
+        print(f"Adding {len(self.domains)} manually-specified domains for {self.name}")
+        if self.domains:
+            domains.update(self.domains)
+
+        print(f"Total {len(domains)} domains for {self.name}")
+
+        try:
+            self.domains = self.validate_domains(domains)
+        except Exception as e:
+            errors.append(
+                f"Error validating domains for {self.name}: {e}:\n{traceback.format_exc()}"
+            )
+
+        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_id(self, org_id: str):
+        """Fetch ASNs for a single org_id."""
+        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()
+            return j.get("asns", []), []
+        except Exception as e:
+            error = f"Failed to fetch cidrs for {org_id} from asndb: {e}:\n{traceback.format_exc()}"
+            return [], [error]
+
+    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()
+
+        # Parallelize org_id fetching
+        with ThreadPoolExecutor() as executor:
+            org_futures = {
+                executor.submit(self._fetch_org_id, org_id): org_id
+                for org_id in self.org_ids
+            }
+            for future in as_completed(org_futures):
+                _asns, _errors = future.result()
+                errors.extend(_errors)
+                asns.update(_asns)
+
+        # Parallelize ASN fetching
+        with ThreadPoolExecutor() as executor:
+            asn_futures = {executor.submit(self.fetch_asn, asn): asn for asn in asns}
+            for future in as_completed(asn_futures):
+                asn_cidrs, _errors = future.result()
+                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):
+        headers = kwargs.get("headers", {})
+        headers["x-rate-limit-blocking"] = "true"
+        kwargs["headers"] = headers
+        return request(*args, **kwargs)
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(name='{self.name}')"

cloudcheck/providers/cachefly.py

@@ -0,0 +1,26 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Cachefly(BaseProvider):
+    tags: List[str] = ["cdn"]
+    short_description: str = "CacheFly"
+    long_description: str = (
+        "A content delivery network provider offering global CDN services."
+    )
+    # {"org_id": "CL-1923-ARIN", "org_name": "CacheFly", "country": "US", "asns": [30081]}
+    org_ids: List[str] = [
+        "CL-1923-ARIN",
+    ]
+
+    _ips_url = "https://cachefly.cachefly.net/ips/rproxy.txt"
+
+    def fetch_cidrs(self):
+        response = self.request(self._ips_url)
+        ranges = set()
+        if getattr(response, "status_code", 0) == 200:
+            for line in response.text.splitlines():
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    ranges.add(line)
+        return list(ranges)

cloudcheck/providers/cdnetworks.py

@@ -0,0 +1,14 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Cdnetworks(BaseProvider):
+    tags: List[str] = ["cdn"]
+    short_description: str = "CDNetworks (씨디네트웍스)"
+    long_description: str = (
+        "A Korean content delivery network provider offering CDN and cloud services."
+    )
+    # {"org_id": "CDNET-ARIN", "org_name": "CDNetworks Inc.", "country": "US", "asns": [36408,40366]}
+    org_ids: List[str] = [
+        "CDNET-ARIN",
+    ]

cloudcheck/providers/cisco.py

@@ -0,0 +1,41 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Cisco(BaseProvider):
+    v2fly_company: str = "cisco"
+    tags: List[str] = ["cloud"]
+    short_description: str = "Cisco"
+    long_description: str = "A multinational technology corporation that designs, manufactures, and sells networking hardware, software, and telecommunications equipment."
+    # {"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,42 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List, Dict
+
+
+class Cloudflare(BaseProvider):
+    v2fly_company: str = "cloudflare"
+    tags: List[str] = ["cdn"]
+    short_description: str = "Cloudflare"
+    long_description: str = "A web infrastructure and security company providing content delivery network services, DDoS mitigation, and web security solutions."
+    # {"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,20 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Cloudfront(BaseProvider):
+    tags: List[str] = ["cdn"]
+    short_description: str = "Amazon CloudFront"
+    long_description: str = "A content delivery network service provided by Amazon Web Services that delivers data, videos, applications, and APIs to customers globally."
+
+    _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/ddosguard.py

@@ -0,0 +1,14 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class DDoSGuard(BaseProvider):
+    tags: List[str] = ["cdn"]
+    short_description: str = "DDoS Guard"
+    long_description: str = (
+        "A DDoS protection and content delivery network service provider."
+    )
+    # {"org_id": "ORG-DL236-RIPE", "org_name": "DDOS-GUARD LTD", "country": "RU", "asns": [44556,49612,57724]}
+    org_ids: List[str] = [
+        "ORG-DL236-RIPE",
+    ]

cloudcheck/providers/dell.py

@@ -0,0 +1,13 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Dell(BaseProvider):
+    v2fly_company: str = "dell"
+    tags: List[str] = ["cloud"]
+    short_description: str = "Dell"
+    long_description: str = "A multinational technology company that develops, sells, repairs, and supports computers and related products and services."
+    # {"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,32 @@
+import csv
+from cloudcheck.providers.base import BaseProvider
+from typing import List, Dict
+
+
+class DigitalOcean(BaseProvider):
+    v2fly_company: str = "digitalocean"
+    tags: List[str] = ["cloud"]
+    short_description: str = "DigitalOcean"
+    long_description: str = "A cloud infrastructure provider offering virtual private servers, managed databases, and other cloud services for developers and businesses."
+    # {"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/dod.py

@@ -0,0 +1,31 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class DoD(BaseProvider):
+    """Department of Defense"""
+
+    tags: List[str] = ["gov"]
+    short_description: str = "Department of Defense"
+    long_description: str = "A U.S. government agency responsible for coordinating and supervising all agencies and functions of the government directly related to national security and the United States Armed Forces."
+    org_ids: List[str] = [
+        "USDDD-ARIN",
+    ]
+    domains: List[str] = ["defense.gov", "war.gov", "mil"]
+
+    # https://en.wikipedia.org/wiki/List_of_assigned_/8_IPv4_address_blocks
+    cidrs: List[str] = [
+        "6.0.0.0/8",  # Army Information Systems Center
+        "7.0.0.0/8",  # DoD Network Information Center
+        "11.0.0.0/8",  # DoD Intel Information Systems
+        "21.0.0.0/8",  # DDN-RVN
+        "22.0.0.0/8",  # Defense Information Systems Agency
+        "26.0.0.0/8",  # Defense Information Systems Agency
+        "28.0.0.0/8",  # DSI-North
+        "29.0.0.0/8",  # Defense Information Systems Agency
+        "30.0.0.0/8",  # Defense Information Systems Agency
+        "33.0.0.0/8",  # DLA Systems Automation Center
+        "55.0.0.0/8",  # DoD Network Information Center
+        "214.0.0.0/8",  # DoD Network Information Center
+        "215.0.0.0/8",  # DoD Network Information Center
+    ]

cloudcheck/providers/fastly.py

@@ -0,0 +1,24 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Fastly(BaseProvider):
+    v2fly_company: str = "fastly"
+    tags: List[str] = ["cdn"]
+    short_description: str = "Fastly"
+    long_description: str = "A content delivery network and edge cloud platform that provides edge computing, security, and performance services."
+    # {"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/fbi.py

@@ -0,0 +1,18 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class FBI(BaseProvider):
+    """Federal Bureau of Investigation"""
+
+    tags: List[str] = ["gov"]
+    short_description: str = "Federal Bureau of Investigation"
+    long_description: str = "A U.S. government agency that serves as the domestic intelligence and security service, responsible for investigating federal crimes and protecting national security."
+    org_ids: List[str] = [
+        "FCJIS-ARIN",  # Federal Criminal Justice Information Services
+    ]
+    domains: List[str] = [
+        "fbi.gov",
+        "fbijobs.gov",
+        "ic3.gov",
+    ]

cloudcheck/providers/gabia.py

@@ -0,0 +1,12 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Gabia(BaseProvider):
+    tags: List[str] = ["cloud"]
+    short_description: str = "Gabia (가비아)"
+    long_description: str = "A Korean cloud hosting and infrastructure provider."
+    # {"org_id": "@aut-17589-APNIC", "org_name": null, "country": null, "asns": [17589]}
+    org_ids: List[str] = [
+        "@aut-17589-APNIC",
+    ]

cloudcheck/providers/gcore.py

@@ -0,0 +1,27 @@
+from cloudcheck.providers.base import BaseProvider
+from typing import List
+
+
+class Gcore(BaseProvider):
+    tags: List[str] = ["cdn"]
+    short_description: str = "G-Core Labs"
+    long_description: str = "A content delivery network and cloud infrastructure provider offering CDN, cloud computing, and edge services."
+    # {"org_id": "ORG-GLS1-AP-APNIC", "org_name": "G-Core Labs S.A", "country": "LU", "asns": [59245]}
+    # {"org_id": "ORG-WIG6-RIPE", "org_name": "G-Core Labs S.A.", "country": "LU", "asns": [199524,202422,210559]}
+    org_ids: List[str] = [
+        "ORG-GLS1-AP-APNIC",
+        "ORG-WIG6-RIPE",
+    ]
+
+    _ips_url = "https://api.gcore.com/cdn/public-ip-list"
+
+    def fetch_cidrs(self):
+        response = self.request(self._ips_url)
+        ranges = set()
+        if getattr(response, "status_code", 0) == 200:
+            response_json = response.json()
+            if isinstance(response_json, dict):
+                for key in "addresses", "addresses_v6":
+                    for ip_range in response_json.get(key, []):
+                        ranges.add(ip_range)
+        return list(ranges)