Random Secret 32 bytes using Bouncy Castle

Gist 22c21fedfe1389197d55288d2e2be93d

This example demonstrates a Scala implementation of HMAC-SHA256 message authentication, showing how to generate a signed hash of the string "Hello World" using a hardcoded Base64-encoded secret key. It relies on the BouncyCastle cryptographic provider, added via `Security.addProvider`, and uses the Java Cryptography Architecture's `Mac` and `SecretKeySpec` classes to initialize the HMAC with the decoded key and the "HmacSHA256" algorithm. The code processes the input bytes through `mac.update` and finally outputs the resulting MAC as a Base64-encoded string, producing a specific authentication tag.

64% match

Gist c2007066af4a2f2b97d4293778f8af5d

This Scala example demonstrates a complete JWT (JSON Web Token) lifecycle, creating a signed token with custom claims and then verifying and decoding it. The code generates an ES256 key pair using `GeneratorKeyFactory` from the Ubirch crypto library, then encodes a token with `Jwt.encode` that includes tenant, device, UUID identifiers, and custom role claims, before decoding it back with `Jwt.decodeRawAll` to display the parsed header, payload, and signature. The visualized output is the `Try` result showing the extracted JSON claims alongside the cryptographic signature.

53% match

Gist 86a2162840809aa2b4e4890ec2ba7100

This example demonstrates how to create and validate a JSON Web Token (JWT) using the Scala library `pdi.jwt` with ES256 asymmetric encryption. It shows the complete token lifecycle: generating a key pair with `GeneratorKeyFactory` on the `PRIME256V1` curve, encoding claims (including custom fields like `role` and `env`), and finally decoding and verifying the token with the public key. The code serializes claims using `org.json4s` and `jackson.compactJson`, highlighting the interplay between JWT construction, cryptographic signing, and verification.

52% match

Dart PointyCastle Experiment

This example demonstrates the parsing and verification of a signed data envelope encoded in base64, using Dart’s `pointycastle` cryptography library. It unpacks a binary payload with a custom `Unpacker` class, extracts the signature and signed data, and confirms they match expected base64 strings. The code then decodes an ECDSA P-256 public key and constructs an elliptic curve point from its x and y coordinates using `ECCurve_prime256v1` and `ECPublicKey`, showcasing raw key material handling and point creation without performing verification.

52% match

How to create a CSR for the identity service

This example generates a certificate signing request (CSR) for an identity service using an Ed25519 key pair. It demonstrates how to construct a public key with validity dates and a hardware device ID, then output the key as a string. The code uses `GeneratorKeyFactory.getPrivKey` to decode and load the private key from a Base64 string, and `PublicKeyCreationHelpers.getPublicKey2` to build the key with the specified curve, timestamps, and device identifier. The result is printed via `println` after handling success or failure through a `toTry` match.

Encrypting Messages with Keybase

This example demonstrates the full range of encryption capabilities offered by Keybase, from messaging and file sharing to managing teams and serving websites. Screenshots illustrate the workflow across three interfaces—the website, desktop application, and command line—highlighting how a user creates a public/private key pair, asserts their identity via Twitter, and encrypts chats and git repositories. The visualizations are static images embedded directly into a Markdown file, relying on Keybase’s underlying NaCl cryptographic library and its CLI tools, with no custom JavaScript or D3 code involved.

CCliffordAnderson

Base64.js

This example demonstrates a compact implementation of Base64 encoding in JavaScript, showing how binary data can be converted into a six-bit character representation using the standard Base64 alphabet. The code defines a function, `encode`, that iterates over the input string’s character codes and constructs the output by bit-shifting values and selecting characters from a lookup string. It uses standard JavaScript string methods like `charCodeAt` and `charAt` alongside bitwise operators, with no external libraries or visualization components involved. The example serves as a clear, minimal demonstration of encoding logic rather than a data-driven graphic.

Mmbostock

Gist b88f2b268daaa2a9cf6e48fba8cd5a50

This visualization is a plain-text document containing a cryptographic signature. It demonstrates a Keybase proof, claiming ownership of a GitHub account through a web service binding. The markdown code block structures the JSON payload, which includes identity claims, a public key, and a digital signature string. The example uses no data visualization libraries; its format is purely a formatted text file, intended for auditable sharing as a gist. The rendering is static and displays the signed object, its signature, and verification instructions.

MMandyMeindersma