keybase.md

100%

✓ Published0🌍 Public

Last edited Jan 11, 2019

Created on Jan 11, 2019

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.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 0693c7ab834bc69220ead71474a287e5

This example demonstrates a Keybase proof-of-ownership verification workflow, showing how a user’s GitHub identity is cryptographically linked to their Keybase account. The visualization would depict the JSON signing process, the Merkle root hash, and the signature verification steps. It uses the Keybase Go client and GitHub API to fetch and display the public key, signature, and identity metadata. The rendering highlights the structured data fields (e.g., `body`, `merkle_root`, `prev`) and the final verification result, making the cryptographic binding explicit through a clear, code-driven diagram.

DDylanFM

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

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

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

85% match

Loading thumbnail…

Gist de38d64005a8c46715b22c5b4b4a6cc5

This example verifies a Keybase identity claim by presenting a signed JSON message and its PGP signature. It demonstrates how to prove ownership of a GitHub account through a public gist, using the Keybase API to fetch and display the cryptographic proof. The visualization shows the verification data in a raw, text-based format, highlighting the fingerprint, username, and signature blocks. The code relies on the `keybase` command-line tool and JSON parsing to validate the signed object, emphasizing the transparency of web service bindings. The rendering approach is plain-text oriented, making the cryptographic details immediately readable.

BBrideau

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

85% match