Skip to main content
100%

Gist 91a0c8f7af33be004092701d40b9f719

✓ Published0🌍 Public
Aaharonh
Last edited Apr 19, 2018
Created on Apr 19, 2018

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.

AI-generated description

Similar vizzes

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
91% 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
89% match
Loading thumbnail…

Gist d38663c8f56499090f89c99b01f21db1

This example shows a keybase proof-of-ownership verification workflow, where a user’s GitHub and Keybase identities are cryptographically linked via a signed JSON statement. The visualization maps the structure of the proof document, highlighting the nested fields for the key, merkle root, and service details. It uses `d3.hierarchy` and `d3.treemap` to render the JSON’s object hierarchy as nested rectangles, with color encoding indicating the top-level sections. The code loads the raw JSON data, parses it, and applies a zoomable treemap layout, making the proof’s data schema immediately apparent.

AAdrienCos
87% 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
86% match
Loading thumbnail…

Gist 861cbdb146340b013164ef53cc044748

This example shows a Keybase identity proof, presenting a signed JSON object and its corresponding signature in plain text. The visualization uses d3.js to render the proof as a formatted code block, highlighting the key fields such as the user’s public key, merkle root, and the final signature string. It also displays the command-line instructions for verifying the identity via the Keybase CLI. The data originates from a gist file authored by Yahyaal, which the code parses and displays directly.

YYahyaal
85% match
Loading thumbnail…

Gist 9d13d547629c3ff94ae7fc08763b9c24

This example displays a Keybase proof verification for a GitHub account, showing the cryptographic signature and identity claims in a structured document. The page renders the signed JSON payload and the public key fingerprint using standard HTML and CSS, with the signature embedded as plain text. The implementation relies on basic DOM manipulation and does not appear to use any visualization libraries or dynamic data rendering, instead presenting the keybase proof as a static, scrollable text block for auditability.

SSimplicissimusFr
85% match
Loading thumbnail…

Keybase proof

This example shows a Keybase proof as a signed JSON object, demonstrating how a GitHub user can cryptographically authenticate their identity across services. The visualization renders the proof’s structure, highlighting the embedded public key, signature, and metadata fields. The code parses the JSON payload and uses the Keybase API to verify the signature, while a custom SVG layout maps the hierarchical relationships between the user, service, and cryptographic elements. The data source is the gist’s raw content, and the rendering approach relies on d3.js for hierarchical node placement and Canvas for signature visualization, making the authentication flow transparent.

FFranklin Chen
85% match
Loading thumbnail…

Gist 1a826885eacfebb60a6ff421d57a9e37

This example shows a Keybase proof file, which cryptographically links a GitHub account to a Keybase identity. It demonstrates how the raw JSON payload and its signature are structured for public verification, including the nested key, Merkle root, and service binding fields. The gist itself contains no visualization code; instead, it serves as a static text-based proof, relying on Keybase’s cryptographic signing (Ed25519) and hashing (SHA-256) rather than any charting or rendering library. The rendering approach is purely textual, presenting the signed object and signature for manual or programmatic validation.

HHerbCaudill
84% match