Skip to main content
100%

Chain of Trust - but verify...

✓ Published0🌍 Public
Aandrewxhill
Last edited Nov 3, 2023
Created on Nov 3, 2023

This visualization demonstrates the complete chain of trust in DNSSEC verification. Starting from a user-specified domain and TXT record flag, it systematically queries DNS records — including DNSKEY, DS, and RRSIG signatures — at every level of the DNS hierarchy from the target domain back to the root. Using the `dnspython` library and Cloudflare’s 1.1.1.1 resolver, the notebook collects signed TXT records, DNSKEYs, DS records, and their corresponding RRSIGs for each domain in the chain, storing the results as JSON. The visualization then walks this chain of trust, showing how cryptographic signatures tie each level to its parent, enabling the reader to verify the authenticity of the initial TXT record all the way back to the ICANN root.

AI-generated description

Provide a domain and a TXT content flag you want to discover and then verify all the way to ICANN.

On boom.fyi, we have a TXT record with data-cert=hello_world

domain = "boom.fyi"

Collect data for our target TXT record flag (including all sigs etc). Then collect data for the entire chain back to root.

chain_data = collect_record(domain, 'data-cert=')
chain_data = collect_chain_data(domain, chain_data)

This all is stored off in chain_data.json

Now, verify.

  • Check that the TXT record was signed correct
  • Check that the key that signed it came from the parent zoon
  • Check that that signature was correct
  • And check that it's key came from the parent zoon
  • Uncover the turtles
  • All the way down to the root
verify_chain(domain, data)

Finally, it makes sure the last step was signed by keys that came from the root we already know. Stored in root_rrset.json Since no exceptions were thrown, we'll finally show what the value of our flag was set to:

show_verified_message(domain, data)

Similar vizzes

Loading thumbnail…

Gist 91a0c8f7af33be004092701d40b9f719

This example presents a Keybase proof as a structured, interactive visualization. It shows the cryptographic signature chain and identity verification details in a hierarchical layout, using d3.forceSimulation to position nodes representing the proof’s components. The code renders the JSON structure with d3.select and d3.hierarchy, while d3.forceLink draws the connections between the public key, user, and service nodes. The visualization makes the otherwise opaque cryptographic verification process immediately readable by exposing the nested object relationships and their data.

Aaharonh
53% match
Loading thumbnail…

Gist 039cdcabb18f9847087e

This visualization renders a Keybase proof as a cryptographic signature chain, showing the JSON object’s fields and the resulting signature hex string. It uses a custom layout to display the data as interconnected nodes and edges, likely built with d3’s force simulation or a similar graph library. The proof text, including the key ID and signature, is visible as text elements. The rendering emphasizes the structure of the signed payload and its verification steps.

Aafbroman
53% match
Loading thumbnail…

keybase

This example visualizes the trust network and cryptographic signature chain that establishes a Keybase identity proof for a GitHub user. It renders the signed JSON object, Merkle root hash, and public key fingerprint as interactive graph nodes using the Keybase API and a force-directed layout. The visualization shows how the proof binds the GitHub username to the Keybase identity, with edges representing the cryptographic relationships between the user, their gist, and the signing key. The graph layout is computed with a custom force simulation, while node details and signature data are pulled directly from the Keybase proof file.

CCarlos-Augusto
52% match
Loading thumbnail…

lf-auth-notes

This interactive visualization demonstrates how cryptographic keys and team membership are managed in a decentralized graph, where each node is an encrypted lockbox containing keys accessible only to designated devices or roles. It shows the flow of authority from the group’s founder through admin roles to individual members, with mutual removals resolved by seniority. Built on the CRDX library, the graph uses asymmetric encryption for each node, and the visualization renders the key graph and lockbox relationships using custom SVG rendering. The code highlights the concrete APIs for graph traversal and cryptographic operations, such as key derivation and signature verification, as seen in the invitation and lockbox logic. Data is sourced from the embedded gist’s markdown and assets.

HHerbCaudill
51% match
Loading thumbnail…

keybase

This example visualizes the trust relationships embedded in a Keybase proof document, presenting the signed JSON payload and its cryptographic signature as an interactive graph. It uses the keybase.io proof format to show how a GitHub identity links to a Keybase user via a PGP key, rendering the nested claim structure with d3.js force-directed layout. Nodes represent entities like the service, username, key ID, and signature block, with edges depicting their associations. The visualization directly parses the provided gist data, making the verification process tangible by mapping each field to a visual component.

MMattieTK
51% match
Loading thumbnail…

Gist 7a4aa931c2aa66a9be73b0d0219ae57a

This visualization demonstrates a network graph of Blockstack ID verifications, mapping relationships between cryptographic addresses and their associated identities. It uses d3.forceSimulation to position nodes and links, with each node representing a blockchain address or ID and edges showing verification connections. The graph renders via SVG paths and circles, with color and size encoding node attributes like address type or verification status. Data comes from the Blockstack explorer API, pulling address and verification details from the public blockchain. The visualization updates dynamically as the simulation runs, letting users explore the interconnected web of verified identities.

UUtopiah
51% match
Loading thumbnail…

Gist 84c19b830de7ca18d8bc432ac5de9737

This example demonstrates a cryptographic identity verification workflow, showing how a GitHub user proves ownership of their account through a signed Keybase statement. The visual focus is on the structured JSON payload, which contains the user’s public key, service binding details, and a Merkle root hash. The code uses the `crypto` module for signature validation and `JSON.stringify` to format the payload for display. It also references Keybase’s command-line interface and the public API for fetching identity data, with the rendered output emphasizing the signature’s provenance and auditability.

Aandrewxhill
50% match
Loading thumbnail…

Keybase proof

This example visualizes a cryptographic identity proof from Keybase, showing the linkage between a GitHub account and a Keybase user through a signed JSON object. It renders the proof’s structured data, including the public key, Merkle root hash, and signature, as an interactive network graph. The visualization uses d3.forceSimulation to position nodes representing the user, service, and cryptographic components, with edges indicating signed relationships. It relies on the raw JSON payload from the Keybase proof file, parsing the `body` and `client` fields to display the verification chain. The graph updates dynamically when hovering over nodes to highlight connected proof elements.

AAnsonT
49% match