certgraph 0.1.0__tar.gz → 0.2.0__tar.gz

{certgraph-0.1.0 → certgraph-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: certgraph
-Version: 0.1.0
+Version: 0.2.0
 Summary: Utility for exploring and mapping X509 certificate chains.
 Author: Chris Adshead
 License: MIT License

{certgraph-0.1.0 → certgraph-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "certgraph"
-version = "0.1.0"
+version = "0.2.0"
 description = "Utility for exploring and mapping X509 certificate chains."
 readme = "README.md"
 requires-python = ">=3.12"

certgraph-0.2.0/src/certgraph/certgraph.py

@@ -0,0 +1,217 @@
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes
+import networkx as nx
+from rapidfuzz import fuzz
+
+
+class certgraph:
+    """Class for creating and exploring directed graphs of X509 certificates."""
+
+    def __init__(self) -> None:
+        """Initialise an empty certgraph object."""
+        self._certlist: set[x509.Certificate] = []
+        self._graph = nx.DiGraph()
+
+    def import_certificates(
+        self,
+        certificates: (
+            x509.Certificate | str | bytes | list[x509.Certificate | str | bytes]
+        ),
+    ) -> certgraph:
+        """
+        Import one or more certificates and regenerate the certificate digraph.
+
+        Args:
+            certificates: Certificates to import, either individual or a list. x509.Certificate objects are directly imported, str is assumed to be PEM encoded, bytes are assumed to be DER encoded.
+
+        Returns:
+            Returns self to allow method chaining.
+
+        Raises:
+            TypeError: Certificate type is not supported (i.e. not x509.Certificate, str or bytes)
+        """
+        new_certs: set[x509.Certificate] = []
+
+        # If there's only a non-list object being handing in, turn it into an array to keep the same iteration code
+        for i, cert in enumerate(
+            certificates if isinstance(certificates, list) else [certificates]
+        ):
+            if isinstance(cert, x509.Certificate):
+                # No conversion neccessary
+                new_certs.append(cert)
+            elif isinstance(cert, str):
+                # PEM encoded
+                pem_certs = x509.load_pem_x509_certificates(cert.encode("utf-8"))
+                new_certs.extend(pem_certs)
+            elif isinstance(cert, bytes):
+                # DER encoded
+                der_cert = x509.load_der_x509_certificate(cert)
+                new_certs.append(der_cert)
+            else:
+                raise TypeError(
+                    f"Cannot import certificate {i} from data type {type(cert)}"
+                )
+
+        self._certlist.extend(new_certs)
+        self._graph = self._generate_graph(self._certlist)
+
+        return self
+
+    def _generate_graph(self, certificates: set[x509.Certificate]) -> nx.DiGraph:
+        """Generate a networkx digraph from the provided list of certificates."""
+        G = nx.DiGraph()
+
+        # Pass 1: add nodes and build a subject_dn -> fingerprint index
+        subject_index: dict[str, list[str]] = {}
+        for cert in certificates:
+            fingerprint = cert.fingerprint(hashes.SHA256()).hex()
+            G.add_node(fingerprint, certificate=cert)
+
+            subject_dn = cert.subject.rfc4514_string()
+            subject_index.setdefault(subject_dn, []).append(fingerprint)
+
+        # Pass 2: add edges using the index
+        for fingerprint, data in G.nodes(data=True):
+            issuer_dn = data["certificate"].issuer.rfc4514_string()
+
+            for issuer_fingerprint in subject_index.get(issuer_dn, []):
+                G.add_edge(issuer_fingerprint, fingerprint)
+
+        return G
+
+    def report_fingerprint_edges(self) -> list[str]:
+        """
+        Get the list of all edges in the form 'fingerprint1 -> fingerprint2'. Only contains the first 8 characters of each fingerprint, because this is mostly for debugging from a terminal without having to generate a complete graph image.
+
+        Returns:
+            List of all edges in the current certificate digraph in terms of fingerprints.
+        """
+        return [f"{edge[0][:8]} -> {edge[1][:8]}" for edge in self._graph.edges()]
+
+    def export_dot(self, format: str = "svg") -> str:
+        """Function to export the current certificate digraph in the dot language. NOTE: Still in progress."""
+        allowed_types = ["svg", "png"]
+
+        if format not in allowed_types:
+            raise ValueError(
+                f"Cannot export dot graph of type {format} - must be one of {allowed_types}"
+            )
+
+        dot_graph = nx.DiGraph()
+
+        for fingerprint, data in self._graph.nodes(data=True):
+            label = data["certificate"].subject.rfc4514_string()
+            dot_graph.add_node(fingerprint, label=label)
+        dot_graph.add_edges_from(self._graph.edges())
+
+        nx.drawing.nx_pydot.write_dot(dot_graph, "./test_out.dot")
+
+        return "dot"
+
+    def clear(self) -> certgraph:
+        """
+        Remove all certificates imported and clear the digraph.
+
+        Returns:
+            Returns self to allow method chaining.
+        """
+        self._certlist.clear()
+        self._graph.clear()
+        return self
+
+    def fingerprint_from_distinguished_name(self, dn: str, cutoff: int = 0) -> str:
+        """
+        Get the fingerprint of the imported certificate with the best fuzzy-search match between the requested distinguised name and the rfc4514 string of each imported certificate.
+
+        Args:
+            dn: The distinguished name to use as the basis for the fuzzy-search.
+            cutoff: Cutoff value for matching, from 0-100. 0 will always return the closest match (even if poor), 100 will only ever return an exact match.
+
+        Returns:
+            The fingerprint of the certificate with the closes matching distinguished name to the one requested. Can also return None if there are no certificates above the cutoff threshold.
+        """
+        if (cutoff < 0) or (cutoff > 100):
+            raise ValueError("cutoff must be between 0-100")
+
+        # Evaluate the nodes
+        nodes: list[tuple[str, dict]] = list(self._graph.nodes(data=True))
+
+        # Sort using a fuzzy-search
+        ranked = sorted(
+            nodes,
+            key=lambda t: fuzz.ratio(
+                dn, t[1]["certificate"].subject.rfc4514_string(), score_cutoff=cutoff
+            ),
+        )
+
+        if not ranked:
+            return None
+
+        return ranked[-1][0]
+
+    def get_certificate(self, fingerprint: str) -> x509.Certificate | None:
+        """
+        Get an imported ceritficate based on the fingerprint.
+
+        Args:
+            fingerprint: Fingerprint of the certificate to get. Use fingerprint_from_distinguished_name() to resolve the fingerprint from a DN.
+
+        Returns:
+            Certificate that matches the provided fingerprint or None if it doesn't exist.
+        """
+        if fingerprint not in self._graph.nodes:
+            return None
+
+        return self._graph.nodes[fingerprint]["certificate"]
+
+    def get_issuer_fingerprint(self, fingerprint: str) -> str:
+        """
+        Get the fingerprint of the issuer certificate.
+
+        Args:
+            fingerprint: Fingerprint of the certificate to get the issuer of.
+        
+        Returns:
+            The fingerprint of the issuing certificate or None if not present in the digraph.
+
+        Raises:
+            ValueError: If certificate with the supplied fingerprint isn't in the digraph.
+        """
+        if fingerprint not in self._graph.nodes:
+            raise ValueError(f"Fingerprint supplied doesn't match any imported certificate.")
+
+        return next(self._graph.predecessors(fingerprint), None)
+
+    def get_child_fingerprints(self, fingerprint: str) -> str:
+        """
+        Get the fingerprints of any certificates issued by the certificate with the provided fingerprint.
+
+        Args:
+            fingerprint: Fingerprint of the certificate to get the child certificates of.
+        
+        Returns:
+            The list of fingerprints belonging to child certificates.
+
+        Raises:
+            ValueError: If certificate with the supplied fingerprint isn't in the digraph.
+        """
+        if fingerprint not in self._graph.nodes:
+            raise ValueError(f"Fingerprint supplied doesn't match any imported certificate.")
+
+        return list(self._graph.successors(fingerprint))
+
+    def remove_certificate(self, fingerprint: str) -> None:
+        """
+        Remove an imported ceritficate based on the fingerprint and update the certificate digraph.
+
+        Args:
+            fingerprint: Fingerprint of the certificate to remove. Use fingerprint_from_distinguished_name() to resolve the fingerprint from a DN.
+        """
+        if fingerprint in self._graph.nodes:
+            cert = self._graph.nodes[fingerprint]["certificate"]
+
+            self._graph.remove_node(fingerprint)
+
+            if cert in self._certlist:
+                self._certlist.remove(cert)
+

{certgraph-0.1.0 → certgraph-0.2.0}/src/certgraph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: certgraph
-Version: 0.1.0
+Version: 0.2.0
 Summary: Utility for exploring and mapping X509 certificate chains.
 Author: Chris Adshead
 License: MIT License

certgraph-0.2.0/src/certgraph.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+src/certgraph/__init__.py
+src/certgraph/certgraph.py
+src/certgraph.egg-info/PKG-INFO
+src/certgraph.egg-info/SOURCES.txt
+src/certgraph.egg-info/dependency_links.txt
+src/certgraph.egg-info/requires.txt
+src/certgraph.egg-info/top_level.txt
+tests/test_clear.py
+tests/test_export_dot.py
+tests/test_fingerprint_search.py
+tests/test_get_certificate.py
+tests/test_get_child_fingerprints.py
+tests/test_get_issuer_fingerprint.py
+tests/test_graph.py
+tests/test_import_certificates.py
+tests/test_remove_certificate.py

certgraph-0.2.0/tests/test_clear.py

@@ -0,0 +1,21 @@
+def test_clear_removes_edges(graph, chain_certs):
+    graph.import_certificates(chain_certs)
+    assert graph.report_fingerprint_edges()
+
+    graph.clear()
+
+    assert graph.report_fingerprint_edges() == []
+
+
+def test_clear_returns_self(graph):
+    assert graph.clear() is graph
+
+
+def test_clear_resets_dn_search(graph, self_signed_cert):
+    graph.import_certificates(self_signed_cert)
+    dn = self_signed_cert.subject.rfc4514_string()
+    assert graph.fingerprint_from_distinguished_name(dn) is not None
+
+    graph.clear()
+
+    assert graph.fingerprint_from_distinguished_name(dn) is None

certgraph-0.2.0/tests/test_export_dot.py

@@ -0,0 +1,9 @@
+import pytest
+
+# export_dot()'s actual output generation is still rough and not covered here.
+# Only the argument validation, which happens before anything is written, is tested.
+
+
+def test_export_dot_rejects_invalid_format(graph):
+    with pytest.raises(ValueError):
+        graph.export_dot(format="jpeg")

certgraph-0.2.0/tests/test_fingerprint_search.py

@@ -0,0 +1,28 @@
+from cryptography.hazmat.primitives import hashes
+
+
+def test_returns_none_for_empty_graph(graph):
+    assert graph.fingerprint_from_distinguished_name("CN=whatever") is None
+
+
+def test_exact_match_returns_correct_fingerprint(graph, chain_certs):
+    graph.import_certificates(chain_certs)
+    target = chain_certs[1]
+    dn = target.subject.rfc4514_string()
+    expected_fp = target.fingerprint(hashes.SHA256()).hex()
+
+    result = graph.fingerprint_from_distinguished_name(dn)
+
+    assert result == expected_fp
+
+
+def test_fuzzy_match_finds_closest_dn(graph, chain_certs):
+    graph.import_certificates(chain_certs)
+    target = chain_certs[0]
+    dn = target.subject.rfc4514_string()
+    typo_dn = dn[:-1]  # drop a character to force a fuzzy, non-exact match
+    expected_fp = target.fingerprint(hashes.SHA256()).hex()
+
+    result = graph.fingerprint_from_distinguished_name(typo_dn)
+
+    assert result == expected_fp

certgraph-0.2.0/tests/test_get_certificate.py

@@ -0,0 +1,20 @@
+from cryptography.hazmat.primitives import hashes
+
+
+def test_returns_none_for_unknown_fingerprint(graph):
+    assert graph.get_certificate("does-not-exist") is None
+
+
+def test_returns_certificate_for_known_fingerprint(graph, self_signed_cert):
+    graph.import_certificates(self_signed_cert)
+    fingerprint = self_signed_cert.fingerprint(hashes.SHA256()).hex()
+
+    assert graph.get_certificate(fingerprint) == self_signed_cert
+
+
+def test_returns_correct_certificate_from_chain(graph, chain_certs):
+    graph.import_certificates(chain_certs)
+    target = chain_certs[1]
+    fingerprint = target.fingerprint(hashes.SHA256()).hex()
+
+    assert graph.get_certificate(fingerprint) == target

certgraph-0.2.0/tests/test_get_child_fingerprints.py

@@ -0,0 +1,38 @@
+import pytest
+from cryptography.hazmat.primitives import hashes
+
+
+def test_raises_for_unknown_fingerprint(graph):
+    with pytest.raises(ValueError):
+        graph.get_child_fingerprints("does-not-exist")
+
+
+def test_leaf_certificate_has_no_children(graph, chain_certs):
+    graph.import_certificates(chain_certs)
+    leaf_fp = chain_certs[2].fingerprint(hashes.SHA256()).hex()
+
+    assert graph.get_child_fingerprints(leaf_fp) == []
+
+
+def test_self_signed_certificate_is_its_own_child(graph, self_signed_cert):
+    graph.import_certificates(self_signed_cert)
+    fingerprint = self_signed_cert.fingerprint(hashes.SHA256()).hex()
+
+    assert graph.get_child_fingerprints(fingerprint) == [fingerprint]
+
+
+def test_root_returns_itself_and_issued_certificate(graph, chain_certs):
+    graph.import_certificates(chain_certs)
+    root_fp = chain_certs[0].fingerprint(hashes.SHA256()).hex()
+    intermediate_fp = chain_certs[1].fingerprint(hashes.SHA256()).hex()
+
+    # root has a self-loop plus the certificate it issued
+    assert set(graph.get_child_fingerprints(root_fp)) == {root_fp, intermediate_fp}
+
+
+def test_intermediate_returns_only_leaf_it_issued(graph, chain_certs):
+    graph.import_certificates(chain_certs)
+    intermediate_fp = chain_certs[1].fingerprint(hashes.SHA256()).hex()
+    leaf_fp = chain_certs[2].fingerprint(hashes.SHA256()).hex()
+
+    assert graph.get_child_fingerprints(intermediate_fp) == [leaf_fp]

certgraph-0.2.0/tests/test_get_issuer_fingerprint.py

@@ -0,0 +1,35 @@
+import pytest
+from cryptography.hazmat.primitives import hashes
+
+
+def test_raises_for_unknown_fingerprint(graph):
+    with pytest.raises(ValueError):
+        graph.get_issuer_fingerprint("does-not-exist")
+
+
+def test_self_signed_certificate_is_its_own_issuer(graph, self_signed_cert):
+    graph.import_certificates(self_signed_cert)
+    fingerprint = self_signed_cert.fingerprint(hashes.SHA256()).hex()
+
+    assert graph.get_issuer_fingerprint(fingerprint) == fingerprint
+
+
+def test_leaf_returns_direct_issuer_fingerprint(graph, chain_certs):
+    graph.import_certificates(chain_certs)
+    root_fp = chain_certs[0].fingerprint(hashes.SHA256()).hex()
+    intermediate_fp = chain_certs[1].fingerprint(hashes.SHA256()).hex()
+    leaf_fp = chain_certs[2].fingerprint(hashes.SHA256()).hex()
+
+    assert graph.get_issuer_fingerprint(intermediate_fp) == root_fp
+    assert graph.get_issuer_fingerprint(leaf_fp) == intermediate_fp
+
+
+def test_unrelated_self_signed_certs_do_not_share_issuer(graph, make_chain):
+    cert_a = make_chain(1, cns=["alpha-root"])[0]
+    cert_b = make_chain(1, cns=["beta-root"])[0]
+    graph.import_certificates([cert_a, cert_b])
+    fp_a = cert_a.fingerprint(hashes.SHA256()).hex()
+    fp_b = cert_b.fingerprint(hashes.SHA256()).hex()
+
+    assert graph.get_issuer_fingerprint(fp_a) == fp_a
+    assert graph.get_issuer_fingerprint(fp_b) == fp_b

certgraph-0.2.0/tests/test_graph.py

@@ -0,0 +1,36 @@
+def test_empty_graph_has_no_edges(graph):
+    assert graph.report_fingerprint_edges() == []
+
+
+def test_self_signed_certificate_produces_self_loop(graph, self_signed_cert):
+    graph.import_certificates(self_signed_cert)
+    edges = graph.report_fingerprint_edges()
+    assert len(edges) == 1
+    src, _, dst = edges[0].partition(" -> ")
+    assert src == dst
+
+
+def test_chain_produces_expected_number_of_edges(graph, chain_certs):
+    graph.import_certificates(chain_certs)
+    # one self-loop for the root, plus one edge linking each subsequent cert to its issuer
+    assert len(graph.report_fingerprint_edges()) == len(chain_certs)
+
+
+def test_unrelated_self_signed_certs_do_not_link(graph, make_chain):
+    cert_a = make_chain(1, cns=["alpha-root"])[0]
+    cert_b = make_chain(1, cns=["beta-root"])[0]
+    graph.import_certificates([cert_a, cert_b])
+
+    edges = graph.report_fingerprint_edges()
+    assert len(edges) == 2
+    for edge in edges:
+        src, _, dst = edge.partition(" -> ")
+        assert src == dst
+
+
+def test_edge_report_format_uses_truncated_fingerprints(graph, self_signed_cert):
+    graph.import_certificates(self_signed_cert)
+    edge = graph.report_fingerprint_edges()[0]
+    src, _, dst = edge.partition(" -> ")
+    assert len(src) == 8
+    assert len(dst) == 8

certgraph-0.2.0/tests/test_import_certificates.py

@@ -0,0 +1,39 @@
+import pytest
+from cryptography.hazmat.primitives import serialization
+
+
+def test_import_single_certificate_object(graph, self_signed_cert):
+    graph.import_certificates(self_signed_cert)
+    assert len(graph.report_fingerprint_edges()) == 1
+
+
+def test_import_certificate_list(graph, chain_certs):
+    graph.import_certificates(chain_certs)
+    assert len(graph.report_fingerprint_edges()) == len(chain_certs)
+
+
+def test_import_pem_string(graph, chain_pem, chain_certs):
+    graph.import_certificates(chain_pem)
+    assert len(graph.report_fingerprint_edges()) == len(chain_certs)
+
+
+def test_import_der_bytes(graph, self_signed_cert):
+    der = self_signed_cert.public_bytes(serialization.Encoding.DER)
+    graph.import_certificates(der)
+    assert len(graph.report_fingerprint_edges()) == 1
+
+
+def test_import_invalid_type_raises_typeerror(graph):
+    with pytest.raises(TypeError):
+        graph.import_certificates(12345)
+
+
+def test_import_returns_self_for_chaining(graph, self_signed_cert):
+    result = graph.import_certificates(self_signed_cert)
+    assert result is graph
+
+
+def test_import_accumulates_across_multiple_calls(graph, chain_certs):
+    graph.import_certificates(chain_certs[0])
+    graph.import_certificates(chain_certs[1:])
+    assert len(graph.report_fingerprint_edges()) == len(chain_certs)

certgraph-0.2.0/tests/test_remove_certificate.py

@@ -0,0 +1,41 @@
+from cryptography.hazmat.primitives import hashes
+
+
+def test_removes_node_from_graph(graph, self_signed_cert):
+    graph.import_certificates(self_signed_cert)
+    fingerprint = self_signed_cert.fingerprint(hashes.SHA256()).hex()
+
+    graph.remove_certificate(fingerprint)
+
+    assert graph.get_certificate(fingerprint) is None
+
+
+def test_removes_certificate_from_certlist(graph, self_signed_cert):
+    graph.import_certificates(self_signed_cert)
+
+    fingerprint = self_signed_cert.fingerprint(hashes.SHA256()).hex()
+    graph.remove_certificate(fingerprint)
+
+    assert self_signed_cert not in graph._certlist
+
+
+def test_unknown_fingerprint_is_a_no_op(graph, chain_certs):
+    graph.import_certificates(chain_certs)
+    edges_before = graph.report_fingerprint_edges()
+
+    graph.remove_certificate("does-not-exist")
+
+    assert graph.report_fingerprint_edges() == edges_before
+
+
+def test_removing_intermediate_drops_its_edges(graph, chain_certs):
+    graph.import_certificates(chain_certs)
+    intermediate_fp = chain_certs[1].fingerprint(hashes.SHA256()).hex()
+    leaf_fp = chain_certs[2].fingerprint(hashes.SHA256()).hex()
+
+    graph.remove_certificate(intermediate_fp)
+
+    remaining = graph.report_fingerprint_edges()
+    assert all(intermediate_fp[:8] not in edge for edge in remaining)
+    # the leaf certificate is still present, just orphaned
+    assert graph.get_certificate(leaf_fp) == chain_certs[2]

certgraph-0.1.0/src/certgraph/certgraph.py

@@ -1,109 +0,0 @@
-from cryptography import x509
-from cryptography.hazmat.primitives import hashes
-import networkx as nx
-from rapidfuzz import fuzz
-
-
-class certgraph:
-    def __init__(self) -> None:
-        self._certlist: set[x509.Certificate] = []
-        self._graph = nx.DiGraph()
-
-    def import_certificates(
-        self,
-        certificates: (
-            x509.Certificate | str | bytes | list[x509.Certificate | str | bytes]
-        ),
-        pem_encoding: str = "utf-8",
-    ) -> certgraph:
-        new_certs: set[x509.Certificate] = []
-
-        # If there's only a non-list object being handing in, turn it into an array to keep the same iteration code
-        for i, cert in enumerate(
-            certificates if isinstance(certificates, list) else [certificates]
-        ):
-            if isinstance(cert, x509.Certificate):
-                # No conversion neccessary
-                new_certs.append(cert)
-            elif isinstance(cert, str):
-                # PEM encoded
-                pem_certs = x509.load_pem_x509_certificates(cert.encode(pem_encoding))
-                new_certs.extend(pem_certs)
-            elif isinstance(cert, bytes):
-                # DER encoded
-                der_cert = x509.load_der_x509_certificate(cert)
-                new_certs.append(der_cert)
-            else:
-                raise TypeError(
-                    f"Cannot import certificate {i} from data type {type(cert)}"
-                )
-
-        self._certlist.extend(new_certs)
-        self._graph = self._generate_graph(self._certlist)
-
-        return self
-
-    def _generate_graph(self, certificates: set[x509.Certificate]) -> nx.DiGraph:
-        G = nx.DiGraph()
-
-        # Pass 1: add nodes and build a subject_dn -> fingerprint index
-        subject_index: dict[str, list[str]] = {}
-        for cert in certificates:
-            fingerprint = cert.fingerprint(hashes.SHA256()).hex()
-            G.add_node(fingerprint, certificate=cert)
-
-            subject_dn = cert.subject.rfc4514_string()
-            subject_index.setdefault(subject_dn, []).append(fingerprint)
-
-        # Pass 2: add edges using the index
-        for fingerprint, data in G.nodes(data=True):
-            issuer_dn = data["certificate"].issuer.rfc4514_string()
-
-            for issuer_fingerprint in subject_index.get(issuer_dn, []):
-                G.add_edge(issuer_fingerprint, fingerprint)
-
-        return G
-
-    def report_fingerprint_edges(self) -> list[str]:
-        return [f"{edge[0][:8]} -> {edge[1][:8]}" for edge in self._graph.edges()]
-
-    def export_dot(self, format: str = "svg") -> str:
-        allowed_types = ["svg", "png"]
-
-        if format not in allowed_types:
-            raise ValueError(
-                f"Cannot export dot graph of type {format} - must be one of {allowed_types}"
-            )
-
-        dot_graph = nx.DiGraph()
-
-        for fingerprint, data in self._graph.nodes(data=True):
-            label = data["certificate"].subject.rfc4514_string()
-            dot_graph.add_node(fingerprint, label=label)
-        dot_graph.add_edges_from(self._graph.edges())
-
-        nx.drawing.nx_pydot.write_dot(dot_graph, "./test_out.dot")
-
-        return "dot"
-
-    def clear(self) -> certgraph:
-        self._certlist.clear()
-        self._graph.clear()
-        return self
-
-    def fingerprint_from_distinguished_name(self, dn: str, cutoff: int = 0) -> str:
-        # Evaluate the nodes
-        nodes: list[tuple[str, dict]] = list(self._graph.nodes(data=True))
-
-        # Sort using a fuzzy-search
-        ranked = sorted(
-            nodes,
-            key=lambda t: fuzz.ratio(
-                dn, t[1]["certificate"].subject.rfc4514_string(), score_cutoff=cutoff
-            )
-        )
-
-        if not ranked:
-            return None
-
-        return ranked[-1][0]

certgraph-0.1.0/src/certgraph.egg-info/SOURCES.txt

@@ -1,10 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-src/certgraph/__init__.py
-src/certgraph/certgraph.py
-src/certgraph.egg-info/PKG-INFO
-src/certgraph.egg-info/SOURCES.txt
-src/certgraph.egg-info/dependency_links.txt
-src/certgraph.egg-info/requires.txt
-src/certgraph.egg-info/top_level.txt