guarddog 2.5.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

guarddog/scanners/pypi_project_scanner.py

@@ -1,11 +1,14 @@
 import logging
+import os
 import re
+from typing import List
+
 import pkg_resources
 import requests
 from packaging.specifiers import Specifier, Version
 
 from guarddog.scanners.pypi_package_scanner import PypiPackageScanner
-from guarddog.scanners.scanner import ProjectScanner
+from guarddog.scanners.scanner import Dependency, DependencyVersion, ProjectScanner
 from guarddog.utils.config import VERIFY_EXHAUSTIVE_DEPENDENCIES
 
 log = logging.getLogger("guarddog")
@@ -37,17 +40,20 @@ class PypiRequirementsScanner(ProjectScanner):
 
         for line in requirements:
             is_requirement = re.match(r"\w", line)
-            if is_requirement:
-                if "\\" in line:
-                    line = line.replace("\\", "")
 
-                stripped_line = line.strip()
-                if len(stripped_line) > 0:
-                    sanitized_lines.append(stripped_line)
+            if not is_requirement:
+                sanitized_lines.append("")  # empty line to keep the line number
+                continue
+
+            if "\\" in line:
+                line = line.replace("\\", "")
+
+            stripped_line = line.strip()
+            sanitized_lines.append(stripped_line)
 
         return sanitized_lines
 
-    def parse_requirements(self, raw_requirements: str) -> dict[str, set[str]]:
+    def parse_requirements(self, raw_requirements: str) -> List[Dependency]:
         """
         Parses requirements.txt specification and finds all valid
         versions of each dependency
@@ -57,17 +63,10 @@ class PypiRequirementsScanner(ProjectScanner):
 
         Returns:
             dict: mapping of dependencies to valid versions
-
-            ex.
-            {
-                ....
-                <dependency-name>: [0.0.1, 0.0.2, ...],
-                ...
-            }
         """
         requirements = raw_requirements.splitlines()
         sanitized_requirements = self._sanitize_requirements(requirements)
-        dependencies = {}
+        dependencies: List[Dependency] = []
 
         def get_matched_versions(versions: set[str], semver_range: str) -> set[str]:
             """
@@ -77,8 +76,11 @@ class PypiRequirementsScanner(ProjectScanner):
 
             # Filters to specified versions
             try:
-                spec = Specifier(semver_range)
-                result = [Version(m) for m in spec.filter(versions)]
+                matching_versions = versions
+                if semver_range:
+                    spec = Specifier(semver_range)
+                    matching_versions = set(spec.filter(versions))
+                result = [Version(m) for m in matching_versions]
             except ValueError:
                 # use it raw
                 return set([semver_range])
@@ -142,8 +144,47 @@ class PypiRequirementsScanner(ProjectScanner):
                     )
                     continue
 
-                dependencies[requirement.project_name] = versions
+                idx = next(
+                    iter(
+                        [
+                            ix
+                            for ix, line in enumerate(requirements)
+                            if str(requirement) in line
+                        ]
+                    ),
+                    0,
+                )
+
+                dep_versions = list(
+                    map(
+                        lambda d: DependencyVersion(version=d, location=idx + 1),
+                        versions,
+                    )
+                )
+
+                # find the dep with the same name or create a new one
+                dep = next(
+                    filter(
+                        lambda d: d.name == requirement.project_name,
+                        dependencies,
+                    ),
+                    None,
+                )
+                if not dep:
+                    dep = Dependency(name=requirement.project_name, versions=set())
+                    dependencies.append(dep)
+
+                dep.versions.update(dep_versions)
+
         except Exception as e:
             log.error(f"Received error {str(e)}")
 
         return dependencies
+
+    def find_requirements(self, directory: str) -> list[str]:
+        requirement_files = []
+        for root, dirs, files in os.walk(directory):
+            for name in files:
+                if re.match(r"^requirements(-dev)?\.txt$", name, flags=re.IGNORECASE):
+                    requirement_files.append(os.path.join(root, name))
+        return requirement_files

guarddog/scanners/scanner.py

@@ -2,11 +2,12 @@ import concurrent.futures
 import json
 import logging
 import os
-import sys
 import tempfile
 import typing
 from abc import abstractmethod
 from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from typing import List, Optional, Set, Tuple
 
 import requests
 
@@ -21,183 +22,65 @@ def noop(arg: typing.Any) -> None:
     pass
 
 
-class ProjectScanner:
-    def __init__(self, package_scanner):
-        super().__init__()
-        self.package_scanner = package_scanner
-
-    def _authenticate_by_access_token(self) -> tuple[str, str]:
-        """
-        Gives GitHub authentication through access token
-
-        Returns:
-            tuple[str, str]: username, personal access token
-        """
-
-        user = os.getenv("GIT_USERNAME")
-        personal_access_token = os.getenv("GH_TOKEN")
-        if not user or not personal_access_token:
-            log.error(
-                """WARNING: Please set GIT_USERNAME (Github handle) and GH_TOKEN
-                (generate a personal access token in Github settings > developer)
-                as environment variables before proceeding."""
-            )
-            exit(1)
-        return (user, personal_access_token)
-
-    def scan_requirements(
-        self,
-        requirements: str,
-        rules=None,
-        callback: typing.Callable[[dict], None] = noop,
-    ) -> dict:
-        """
-        Reads the requirements.txt file and scans each possible
-        dependency and version
-
-        Args:
-            requirements (str): contents of requirements.txt file
-            rules: list of rules to apply
-            callback: callback to call for each result
-
-        Returns:
-            dict: mapping of dependencies to scan results
-
-            ex.
-            {
-                ....
-                <dependency-name>: {
-                        issues: ...,
-                        results: {
-                            ...
-                        }
-                    },
-                ...
-            }
-        """
-
-        def scan_single_dependency(dependency, version):
-            log.debug(f"Scanning {dependency} version {version}")
-            result = self.package_scanner.scan_remote(dependency, version, rules)
-            return {"dependency": dependency, "version": version, "result": result}
-
-        dependencies = self.parse_requirements(requirements)
-        num_workers = PARALLELISM
-
-        log.info(
-            f"Scanning using at most {num_workers} parallel worker threads\n"
-        )
-        with ThreadPoolExecutor(max_workers=num_workers) as pool:
-            try:
-                futures: typing.List[concurrent.futures.Future] = []
-                for dependency, versions in dependencies.items():
-                    assert versions is None or len(versions) > 0
-                    if versions is None:
-                        # this will cause scan_remote to use the latest version
-                        futures.append(
-                            pool.submit(scan_single_dependency, dependency, None)
-                        )
-                    else:
-                        futures.extend(
-                            map(
-                                lambda version: pool.submit(
-                                    scan_single_dependency, dependency, version
-                                ),
-                                versions,
-                            )
-                        )
-
-                results = []
-                for future in concurrent.futures.as_completed(futures):
-                    result = future.result()
-                    if callback is not None:
-                        callback(result)
-                    results.append(result)
-            except KeyboardInterrupt:
-                log.warning("Received keyboard interrupt, cancelling scan\n")
-                pool.shutdown(wait=False, cancel_futures=True)
-
-        return results  # type: ignore
+@dataclass
+class DependencyVersion:
+    """
+    This class represents the identified dependency versions in a project,
+    usually defined in a specification file (requirements.txt, package.json, etc.)
 
-    def scan_remote(self, url: str, branch: str, requirements_name: str) -> dict:
-        """
-        Scans remote requirements.txt file
+    Attributes:
+        version (str): The version of the dependency. e.g., "1.0.0"
+        location (int): This indicates the line number in the specification file where the dependency is defined.
+    """
 
-        Args:
-            url (str): url of the GitHub repo
-            branch (str): branch containing requirements.txt
-            requirements_name (str, optional): name of requirements file.
-                Defaults to "requirements.txt".
+    version: str  # the version number of the dependency
+    location: int
 
-        Returns:
-            dict: mapping of dependencies to scan results
+    def __eq__(self, other):
+        if isinstance(other, str):
+            return self.version == other
+        if isinstance(other, DependencyVersion):
+            return self.version == other.version
+        return NotImplemented
 
-            ex.
-            {
-                ....
-                <dependency-name>: {
-                        issues: ...,
-                        results: {
-                            ...
-                        }
-                    },
-                ...
-            }
-        """
+    def __hash__(self):
+        return hash(self.version)
 
-        token = self._authenticate_by_access_token()
-        githubusercontent_url = url.replace("github", "raw.githubusercontent")
+    def __repr__(self):
+        return f"DependencyVersion({self.version!r})"
 
-        req_url = f"{githubusercontent_url}/{branch}/{requirements_name}"
-        resp = requests.get(url=req_url, auth=token)
 
-        if resp.status_code == 200:
-            return self.scan_requirements(resp.content.decode())
-        else:
-            log.error(
-                f"{req_url} does not exist. Check your link or branch name."
-            )
-            sys.exit(255)
+@dataclass
+class Dependency:
+    """
+    This class represents a dependency in a project, usually defined in a specification file
 
-    def scan_local(
-        self, path, rules=None, callback: typing.Callable[[dict], None] = noop
-    ):
-        """
-        Scans a local requirements.txt file
+    Attributes:
+        name (str): The name of the dependency. e.g., "requests"
+        versions (Set[DependencyVersion]): A set of identified versions of the dependency.
+    """
+    name: str
+    versions: Set[DependencyVersion]
 
-        Args:
-            path (str): path to requirements.txt file
-            rules: list of rules to apply
-            callback: callback to call for each result
+    def __eq__(self, other):
+        if isinstance(other, str):
+            return self.name == other
+        if isinstance(other, Dependency):
+            return self.name == other.name
+        return NotImplemented
 
-        Returns:
-            dict: mapping of dependencies to scan results
+    def __repr__(self):
+        return f"Dependency({self.name!r})"
 
-            ex.
-            {
-                ....
-                <dependency-name>: {
-                        issues: ...,
-                        results: {
-                            ...
-                        }
-                    },
-                ...
-            }
-        """
 
-        try:
-            with open(path, "r") as f:
-                return self.scan_requirements(f.read(), rules, callback)
-        except Exception as e:
-            log.error(f"Received {e}")
-            sys.exit(255)
+@dataclass
+class DependencyFile:
+    """
+    This class represents a specification file for a project (requirements.txt, package.json, etc.)
+    """
 
-    @abstractmethod
-    def parse_requirements(
-        self, raw_requirements: str
-    ) -> dict[str, set[str]]:  # returns { package: version }
-        pass
+    file_path: str
+    dependencies: List[Dependency]
 
 
 class PackageScanner:
@@ -324,3 +207,202 @@ class PackageScanner:
         finally:
             log.debug(f"Removing temporary archive file {archive_path}")
             os.remove(archive_path)
+
+
+class ProjectScanner:
+    def __init__(self, package_scanner: PackageScanner):
+        super().__init__()
+        self.package_scanner = package_scanner
+
+    def _authenticate_by_access_token(self) -> tuple[str, str]:
+        """
+        Gives GitHub authentication through access token
+
+        Returns:
+            tuple[str, str]: username, personal access token
+        """
+
+        user = os.getenv("GIT_USERNAME")
+        personal_access_token = os.getenv("GH_TOKEN")
+        if not user or not personal_access_token:
+            log.error(
+                """WARNING: Please set GIT_USERNAME (Github handle) and GH_TOKEN
+                (generate a personal access token in Github settings > developer)
+                as environment variables before proceeding."""
+            )
+            exit(1)
+        return (user, personal_access_token)
+
+    def scan_dependencies(
+        self,
+        dependencies: List[Dependency],
+        rules=None,
+        callback: typing.Callable[[dict], None] = noop,
+    ) -> list[dict]:
+        """
+        scans each possible dependency and version supplied
+
+        Args:
+            dependencies a list of dependencies to scan
+            rules: list of rules to apply
+            callback: callback to call for each result
+
+        Returns:
+            dict: mapping of dependencies to scan results
+
+            ex.
+            {
+                ....
+                <dependency-name>: {
+                        issues: ...,
+                        results: {
+                            ...
+                        }
+                    },
+                ...
+            }
+        """
+
+        def scan_single_dependency(dependency: str, version: Optional[str]) -> dict:
+            log.debug(f"Scanning {dependency} version {version}")
+            result = self.package_scanner.scan_remote(dependency, version, rules)
+            return {"dependency": dependency, "version": version, "result": result}
+
+        num_workers = PARALLELISM
+
+        log.info(f"Scanning using at most {num_workers} parallel worker threads\n")
+        with ThreadPoolExecutor(max_workers=num_workers) as pool:
+            try:
+                futures: typing.List[concurrent.futures.Future] = []
+                for dependency in dependencies:
+                    versions = dependency.versions
+                    if not versions:
+                        # this will cause scan_remote to use the latest version
+                        futures.append(
+                            pool.submit(scan_single_dependency, dependency.name, None)
+                        )
+                    else:
+                        futures.extend(
+                            map(
+                                lambda version: pool.submit(
+                                    scan_single_dependency,
+                                    dependency.name,
+                                    version.version,
+                                ),
+                                versions,
+                            )
+                        )
+
+                results = []
+                for future in concurrent.futures.as_completed(futures):
+                    result = future.result()
+                    if callback is not None:
+                        callback(result)
+                    results.append(result)
+            except KeyboardInterrupt:
+                log.warning("Received keyboard interrupt, cancelling scan\n")
+                pool.shutdown(wait=False, cancel_futures=True)
+
+        return results
+
+    def scan_remote(
+        self, url: str, branch: str, requirements_name: str
+    ) -> tuple[List[Dependency], list[dict]]:
+        """
+        Scans remote requirements.txt file
+
+        Args:
+            url (str): url of the GitHub repo
+            branch (str): branch containing requirements.txt
+            requirements_name (str, optional): name of requirements file.
+                Defaults to "requirements.txt".
+
+        Returns:
+            deps: list of dependencies to scan
+            results: mapping of dependencies to scan results
+            ex.
+            {
+                ....
+                <dependency-name>: {
+                        issues: ...,
+                        results: {
+                            ...
+                        }
+                    },
+                ...
+            }
+        """
+
+        token = self._authenticate_by_access_token()
+        githubusercontent_url = url.replace("github", "raw.githubusercontent")
+        req_url = f"{githubusercontent_url}/{branch}/{requirements_name}"
+        resp = requests.get(url=req_url, auth=token)
+        resp.raise_for_status()
+        dependencies = self.parse_requirements(resp.content.decode())
+        return dependencies, self.scan_dependencies(dependencies)
+
+    def scan_local(
+        self, path, rules=None, callback: typing.Callable[[dict], None] = noop
+    ) -> Tuple[List[DependencyFile], list[dict]]:
+        """
+        Scans a local requirements files (requirements.txt, package.json, etc.)
+
+        Args:
+            path (str): path to requirements file or directory to search
+            rules: list of rules to apply
+            callback: callback to call for each result
+
+        Returns:
+            deps: list of dependencies to scan
+            results: mapping of dependencies to scan results
+            ex.
+            {
+                ....
+                <dependency-name>: {
+                        issues: ...,
+                        results: {
+                            ...
+                        }
+                    },
+                ...
+            }
+
+        """
+
+        requirement_paths = []
+
+        try:
+            if os.path.isfile(path):
+                requirement_paths.append(path)
+            elif os.path.isdir(path):
+                requirement_paths.extend(self.find_requirements(path))
+            else:
+                raise ValueError(f"unable to find file or directory {path}")
+
+            dep_files: List[DependencyFile] = []
+
+            for req in requirement_paths:
+                with open(req, "r") as f:
+                    dep_files.append(
+                        DependencyFile(
+                            file_path=req,
+                            dependencies=self.parse_requirements(f.read()),
+                        )
+                    )
+            deps_to_scan = [d for d_file in dep_files for d in d_file.dependencies]
+            results = self.scan_dependencies(deps_to_scan, rules, callback)
+            return dep_files, results
+        except Exception as e:
+            log.error(f"Error while scanning. Received {e}")
+            raise e
+
+    @abstractmethod
+    def parse_requirements(self, raw_requirements: str) -> List[Dependency]:
+        pass
+
+    @abstractmethod
+    def find_requirements(
+        self,
+        directory: str,
+    ) -> list[str]:  # returns paths of files
+        pass

{guarddog-2.5.0.dist-info → guarddog-2.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: guarddog
-Version: 2.5.0
+Version: 2.6.0
 Summary: GuardDog is a CLI tool to Identify malicious PyPI packages
 License: Apache-2.0
 Author: Ellen Wang
@@ -15,7 +15,7 @@ Requires-Dist: click (>=8.1.3,<9.0.0)
 Requires-Dist: click-option-group (>=0.5.5,<0.6.0)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: configparser (>=5.3,<8.0)
-Requires-Dist: disposable-email-domains (>=0.0.103,<0.0.119)
+Requires-Dist: disposable-email-domains (>=0.0.103,<0.0.121)
 Requires-Dist: prettytable (>=3.6.0,<4.0.0)
 Requires-Dist: pygit2 (>=1.11,<1.18)
 Requires-Dist: python-dateutil (>=2.8.2,<3.0.0)
@@ -24,7 +24,7 @@ Requires-Dist: pyyaml (>=6.0,<7.0)
 Requires-Dist: requests (>=2.29.0,<3.0.0)
 Requires-Dist: semantic-version (>=2.10.0,<3.0.0)
 Requires-Dist: semgrep (>=1.102.0,<2.0.0)
-Requires-Dist: setuptools (>=70.3,<76.0)
+Requires-Dist: setuptools (>=70.3,<77.0)
 Requires-Dist: tarsafe (>=0.0.5,<0.0.6)
 Requires-Dist: termcolor (>=2.1.0,<3.0.0)
 Requires-Dist: urllib3 (==2.3.0)

{guarddog-2.5.0.dist-info → guarddog-2.6.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 guarddog/__init__.py,sha256=reb53KZG9b1nFmsDxj2fropaOceOCyM9bVMUdmZ2wS8,227
 guarddog/__main__.py,sha256=GEdfW6I6g2c3H7bS0G43E4C-g7kXGUswzDCPFSwPgHY,246
 guarddog/analyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-guarddog/analyzer/analyzer.py,sha256=GADeg_zWJYGXYtCv8NJYxIl3QhP204CYFTeJX4QZK2U,14575
+guarddog/analyzer/analyzer.py,sha256=9R6AlRulH87YuF-4Ed2Z6GZUYqxgb8QivXJy7hewM7E,15009
 guarddog/analyzer/metadata/__init__.py,sha256=xaN-DlSHgudKDjKkfpNFue8ANmq1QUmEoAvU_Bc2OUo,749
 guarddog/analyzer/metadata/bundled_binary.py,sha256=8i5ZPnyPyaLv6MG3KNMDVAElv5bDCOlnlsDt9SGUFsg,2596
 guarddog/analyzer/metadata/deceptive_author.py,sha256=nuFyQqKpOuBKAJxpgbcjwXt3FVLzdmOg2mioUZ1D2TI,2789
@@ -38,7 +38,7 @@ guarddog/analyzer/metadata/repository_integrity_mismatch.py,sha256=riAvZYSV64sYN
 guarddog/analyzer/metadata/resources/placeholder_email_domains.txt,sha256=o3mm9u6vuaVeN4wRgDTidR5oL6ufLTCrE9ISVYbOGUc,11
 guarddog/analyzer/metadata/resources/top_go_packages.json,sha256=HHOTcuWTGqlpXDOUgF7ejgmr8sGF_T5l7NQYdXmHcKQ,104044
 guarddog/analyzer/metadata/resources/top_npm_packages.json,sha256=eeqVkFNW8ltYcGbjAJBzZrdxBEKezxa6AVVYoEpFazs,192960
-guarddog/analyzer/metadata/resources/top_pypi_packages.json,sha256=DWSWEOEsZs6RivYE2crI8F3l0bXtVWiHkgZHp1YXBNI,786975
+guarddog/analyzer/metadata/resources/top_pypi_packages.json,sha256=7tN8yUTqbpq3HvNePK9IKrTIEeYblTMHXhUzyOdVN-w,1479906
 guarddog/analyzer/metadata/typosquatting.py,sha256=EMtHwKWWEYUs7ikyaPNtXH0FGPNDPDc2IFMZSDiv3Mg,4560
 guarddog/analyzer/metadata/unclaimed_maintainer_email_domain.py,sha256=qy8AZqbVxD1U3Q--h0FYV7lKPFNlhSzfZK0GwjvQxdQ,2343
 guarddog/analyzer/metadata/utils.py,sha256=bOrkELPza4ScUx1DfQxlqU-9DQeA5weISF42c0QCtls,1768
@@ -50,41 +50,47 @@ guarddog/analyzer/sourcecode/dll-hijacking.yml,sha256=SH1lJ_-EoPfZKrsut9smnEmKPO
 guarddog/analyzer/sourcecode/download-executable.yml,sha256=VuSNkpVh3DxHG7wfep3eAErGsOY9EL_268sNULYbfW4,3361
 guarddog/analyzer/sourcecode/exec-base64.yml,sha256=Wg1jI_ff9I58Xq8gt8wXOQMrwHcPnzkAPyAURxnKHgw,2371
 guarddog/analyzer/sourcecode/exfiltrate-sensitive-data.yml,sha256=hUxQEsJ4qF_25oMF8pdzAFOzq59m6k28WKz280uyaMg,2264
+guarddog/analyzer/sourcecode/go-exec-base64.yml,sha256=Y5TUfLrmU1e5FTYW2zRKwn8yluBARHSXPr6Mr5vMVOY,1554
+guarddog/analyzer/sourcecode/go-exec-download.yml,sha256=ZaZOvn3Xojsd2m8MQGLW1H7p28bPdpEbmDd37q2ZiX4,2931
+guarddog/analyzer/sourcecode/go-exfiltrate-sensitive-data.yml,sha256=sb5GI-523zgE1nxNCrnRVjBSeOp7IfPy7qTQPBJMkco,3697
 guarddog/analyzer/sourcecode/npm-dll-hijacking.yml,sha256=1TvI6UtCGCOMy4Ii-kM_oICYbMRGeOYdgXrG7-zmJ_Y,3460
 guarddog/analyzer/sourcecode/npm-exec-base64.yml,sha256=zc5w2FTlHoZ7ot1flzlmYBkQu1I8eG1E63S5Aki7Goc,814
 guarddog/analyzer/sourcecode/npm-exfiltrate-sensitive-data.yml,sha256=UYWXdkAab-dg_6UwVjiauHmy-9nlKiF86qcyxAwUoXg,3488
 guarddog/analyzer/sourcecode/npm-install-script.yml,sha256=6BLe_V0SGEi1C79Y-FEIcMYHl4vLOOz8bLPrCU5jre8,1329
-guarddog/analyzer/sourcecode/npm-obfuscation.yml,sha256=27lTt_Dy0G_ogD6woktg1t__R77vpOa-_8LJPQ1XU1k,2151
+guarddog/analyzer/sourcecode/npm-obfuscation.yml,sha256=UxR5ezKr9sFcXEh2JKa20IYqq25J0JDfje82O3jUYMg,2174
 guarddog/analyzer/sourcecode/npm-serialize-environment.yml,sha256=gFpr58INp44ZwxYZlIHyzpOgbVMDLv1ZRPTGAczX5dw,835
 guarddog/analyzer/sourcecode/npm-silent-process-execution.yml,sha256=qnJHGesNPNpxGa8n2kQMpttLGck-6vZjI_SsweDyk7M,3513
 guarddog/analyzer/sourcecode/npm-steganography.yml,sha256=XH0udcriAQq_6WOHAG4TpIedw8GgKyWx9gsG_Q_Fki8,915
 guarddog/analyzer/sourcecode/obfuscation.yml,sha256=dp0BeCYShcTS8QiijSa9U53r6jkCjrFBW5jjNVoXdUU,1224
-guarddog/analyzer/sourcecode/shady-links.yml,sha256=Jl2XO6O9vwyhfaj7K3u7-OtB4oQxKcdyb6-_qCrBdUo,3087
+guarddog/analyzer/sourcecode/shady-links.yml,sha256=uDYVWDh0u20oy2zbXTJns64lvrQzLi95CLWgnftvX6Y,3222
 guarddog/analyzer/sourcecode/silent-process-execution.yml,sha256=b6RjenMv7si7lXGak3uMmD7PMtQRuKPeJFggPW6UDNI,418
 guarddog/analyzer/sourcecode/steganography.yml,sha256=3ceO6SJhu4XpZEjfwelLdOxeZ4Ho1OgUjbcacwtOhR0,606
-guarddog/cli.py,sha256=TJT2yxoUokhoDm7P_FF-x0B9zbtxgDou5BFbu4vSWm4,13168
+guarddog/cli.py,sha256=Pk4WUD5a_TlPRpq2G4v_6FDGWu8IriXQPQ_ft8RXm5o,10692
 guarddog/ecosystems.py,sha256=1-emct9cGLU3V0drEdNmGFEmxMEmJHEQOuyOiuuoCGA,489
-guarddog/reporters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-guarddog/reporters/sarif.py,sha256=92HjvASZFyv5otB1qbsUqj6423tNgZbmSQS4qApffAw,5820
+guarddog/reporters/__init__.py,sha256=lHNa5ZDsaIpjzS7SmheD5_GGAimGitXU-DNk-Wn97bI,749
+guarddog/reporters/human_readable.py,sha256=WEyjOPdBE8adxC-tdFgwxcyDijsppLk4gIiZOUO69O0,4548
+guarddog/reporters/json.py,sha256=gpbucxGoXBA6s7fNRzhQwZ4P6gWyz7BowsmQrnm4x6U,802
+guarddog/reporters/reporter_factory.py,sha256=JUagC2UFkN2TZGpZIkI1MwMHEbwT9Ja1goQP95-k9SM,1465
+guarddog/reporters/sarif.py,sha256=diOHJcN3CkSBxBDDg6l9DiZ3ebtUNCw0Rwd7QxCpM9k,7691
 guarddog/scanners/__init__.py,sha256=KNZcGjKNPOs60qpOE8Hr_HsiaRIpJLNzA8qbyvebRIk,1924
-guarddog/scanners/github_action_project_scanner.py,sha256=FY5UEIGeQlmyyjh2Z1LDXsHnzfs2gCQ-wIurpbPvXN4,2847
+guarddog/scanners/github_action_project_scanner.py,sha256=ISoBqUurwN0lMBtXwcNoalo3ghlbOJkZs9vSNZOT0kk,4216
 guarddog/scanners/github_action_scanner.py,sha256=GxhUSetLvT8YxKUIZue9MWOE_IVugM2MdiluOy4f068,1745
 guarddog/scanners/go_package_scanner.py,sha256=OdCbwtjJow9AxEv34z7WBfgTamqKj5DxJh7dly_1NuY,2926
-guarddog/scanners/go_project_scanner.py,sha256=3D5dYSA7FVqc7IIM7uAHlCJZalshP_WhagWmOcYirog,2123
+guarddog/scanners/go_project_scanner.py,sha256=LqhoD1iShdlTO_hkmN2jckeTWARPOfCTkkizmRC6mbM,3348
 guarddog/scanners/npm_package_scanner.py,sha256=qBU0tCbW2pTL3cy5Y4JVAJyAGdvb-HY69qSQmjWbPxU,1968
-guarddog/scanners/npm_project_scanner.py,sha256=L_gqinZit6KHE0dJTRnuJ49U4E3izNf4UBVGkHkiPjw,3585
+guarddog/scanners/npm_project_scanner.py,sha256=liz5Fyscab53IiSPg0T21Z0vT5eotcHPc_W5Xam4A88,4957
 guarddog/scanners/pypi_package_scanner.py,sha256=Tg7M837vhNZim3Jy9OMJSQY2C_m9C75UDy0S_5WKT6M,2375
-guarddog/scanners/pypi_project_scanner.py,sha256=Twbu__Xe1TAX19VQxOXyDGqCsrzVUyrg5bXtJGyOO3I,5031
-guarddog/scanners/scanner.py,sha256=9k5Z7enm0J80h_q5Zd5fLoB6le6QVJwBBEZ-wL1QRB0,10884
+guarddog/scanners/pypi_project_scanner.py,sha256=hKA0LkokPQ9W-y96TS1rSdi5ergIMcuBuorRbCqEBQg,6522
+guarddog/scanners/scanner.py,sha256=RQ00CUg7i5nM6t9LZSXeQrRA9cdWy1ou0QW-VuO55zk,13694
 guarddog/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guarddog/utils/archives.py,sha256=jOXAhxZx-mTtpDidGGKxQg052CvaQOAVklvOeUn9HTQ,2593
 guarddog/utils/config.py,sha256=Msz7altsmNKry0vBPtL2BJ_VdBXsBFZX5ksLvXc2ix4,1403
 guarddog/utils/exceptions.py,sha256=23Kzl3exqYK6X-bcGUeb8wPmSglWNX3GIDPkJ6lQzo4,54
 guarddog/utils/package_info.py,sha256=TFjE1xsGNf60SuHlIeDV2pzMUbogl5TKJdSzswat6jI,953
-guarddog-2.5.0.dist-info/LICENSE,sha256=w1aNZxHyoyOPJ4fSdiyrr06tCJZbTjCsH9K1uqeDVyU,11377
-guarddog-2.5.0.dist-info/LICENSE-3rdparty.csv,sha256=cS61ONZL_xlXaTMvQXyBEi3J3es-40Gg6G-6idoa5Qk,314
-guarddog-2.5.0.dist-info/METADATA,sha256=ZqDqDVCnZh05Dgy9jpJ4SKqEX9ltSWJR15Qd5ATC9QI,1432
-guarddog-2.5.0.dist-info/NOTICE,sha256=nlyNt2IjG8IBoQkb7n6jszwAvmREpKAx0POzFO1s2JM,140
-guarddog-2.5.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-guarddog-2.5.0.dist-info/entry_points.txt,sha256=vX2fvhnNdkbEL4pDzrH2NqjWVxeOaEYi0sJYmNgS2-s,45
-guarddog-2.5.0.dist-info/RECORD,,
+guarddog-2.6.0.dist-info/LICENSE,sha256=w1aNZxHyoyOPJ4fSdiyrr06tCJZbTjCsH9K1uqeDVyU,11377
+guarddog-2.6.0.dist-info/LICENSE-3rdparty.csv,sha256=cS61ONZL_xlXaTMvQXyBEi3J3es-40Gg6G-6idoa5Qk,314
+guarddog-2.6.0.dist-info/METADATA,sha256=RkFhL1I97xJuzxpLsEMDwyHroPphmmG6AfSPRznXgiU,1432
+guarddog-2.6.0.dist-info/NOTICE,sha256=nlyNt2IjG8IBoQkb7n6jszwAvmREpKAx0POzFO1s2JM,140
+guarddog-2.6.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+guarddog-2.6.0.dist-info/entry_points.txt,sha256=vX2fvhnNdkbEL4pDzrH2NqjWVxeOaEYi0sJYmNgS2-s,45
+guarddog-2.6.0.dist-info/RECORD,,