Gist 1578582fcbde7fceab08672a7e12d8b1

100%

Gist 1578582fcbde7fceab08672a7e12d8b1

✓ Published0🌍 Public

Last edited Feb 14, 2017

Created on Feb 14, 2017

This example demonstrates a cryptographic identity verification workflow, showing how a user proves ownership of a GitHub account through the Keybase service. The gist contains a signed JSON object with a PGP message, linking the GitHub username "JoeYerardi" to the Keybase username "joeyerardi" via a public key fingerprint. The code relies on Keybase’s command-line interface and OpenPGP signing, using the `keybase id` command to look up and authenticate the user. The visible data includes the signed statement, the public key details, and the generated signature, all presented as a textual proof rather than a chart or graph. The rendering approach is plain-text code blocks, with no graphical libraries involved.

AI-generated description

Similar vizzes

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

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

90% match

Loading thumbnail…

Gist 9786809

This example demonstrates how to prove ownership of a GitHub account via a Keybase-signed gist. It shows the verification workflow, including the signed JSON payload, PGP signature, and command-line instructions for identity lookup and encrypted messaging. The implementation uses the Keybase API and CLI tooling, alongside cryptographic fingerprint verification, to establish a publicly auditable link between the user’s GitHub and Keybase identities. The gist’s raw text and structured metadata are rendered directly, highlighting the step-by-step authentication process without additional visualization libraries.

JJoaoGoncalves

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

87% match

Loading thumbnail…

Gist 49058de6a5999fad4adf

This example demonstrates how to verify a Keybase identity claim by displaying the signed JSON statement and its PGP signature. It shows the exact data structure and cryptographic proof needed to authenticate a GitHub account, including the public key fingerprint and the signed payload. The visualization uses the `crypto` module to verify the PGP signature and the `d3.forceSimulation` layout to arrange the related key pairs and hash chains. The code renders the signature blocks and key metadata with `d3.select` and `d3.geoPath`, though no map is involved; instead, it presents the raw text and hash values for audit.

PPhilippe Rivière

87% match

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

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

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

84% match