Keybase proof

100%

✓ Published0🌍 Public

Last edited Nov 28, 2016

Created on Nov 28, 2016

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.

AI-generated description

Similar vizzes

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

90% match

Loading thumbnail…

Keybase

This example shows a Keybase proof document rendered as a text artifact, outlining a user’s cryptographic identity claim across GitHub and Keybase. It displays the signed JSON message, the PGP signature, and command-line verification instructions. The code uses markdown formatting to structure the proof, embedding the public key fingerprint and signature blocks directly in the gist. No external visualization libraries are used; the data is presented purely as static plain text.

CCliffordAnderson

88% 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

87% match

Loading thumbnail…

Gist 0ed0d9c83434b39760891be6d14dede2

This example demonstrates a Keybase identity proof by visually presenting the cryptographic signature that links a GitHub account to a Keybase user. The gist shows a JSON object containing the signed statement, along with the PGP-signed message and the public key fingerprint, all rendered as structured text. The visualization uses a plain-text layout to display the keybase.md file, highlighting the nested JSON and the encoded signature block without any additional charting or graphics libraries. The data source is the gist itself, and the rendering relies solely on HTML text formatting, with no interactive or dynamic elements beyond the static content.

EEleonore9

86% match

Loading thumbnail…

keybase.md

This example shows a Keybase proof-of-ownership workflow in action, demonstrating how a GitHub user cryptographically links their identity across platforms. It uses the Keybase command-line client and the keybase.io API to generate a signed JSON object, with the signature displayed as a hexadecimal string. The visualization highlights the verification process, where the public key and merkle root are checked against Keybase’s ledger, using the `keybase id` command for lookups. The data originates from the user’s gist and the Keybase service, with rendering emphasizing the cryptographic chain of trust through the nested JSON structure.

CCaged

85% 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

85% 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

84% match

Loading thumbnail…

Gist ce00b8f09d14cbb43b4525651def6528

This example demonstrates a cryptographic identity verification proof posted as a GitHub gist, using Keybase’s public-key infrastructure. It shows how a user (Ekthelion) claims ownership of both a GitHub account and a Keybase identity by embedding a signed JSON object that includes a fingerprint and a PGP signature. The code references the Keybase command-line tool and the OpenPGP API to generate and validate the signature. The visualization would render the JSON structure and signature block as textual data, highlighting the nested cryptographic fields and the verification steps without relying on graphical libraries.

EEkthelion

84% match