Gist 22c21fedfe1389197d55288d2e2be93d

100%

Gist 22c21fedfe1389197d55288d2e2be93d

✓ Published0🌍 Public

Last edited Feb 17, 2021

Created on Feb 17, 2021

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.

AI-generated description

Similar vizzes

Loading thumbnail…

Random Secret 32 bytes using Bouncy Castle

This visualization demonstrates the generation and encoding of a 33-byte random secret key using the Bouncy Castle cryptography provider in Scala. The code retrieves a secure random number generator via `SecureRandom.getInstance("DEFAULT", "BC")`, fills a byte array with `nextBytes`, and then converts the raw bytes into a Base64 string using `Base64.toBase64String`. The data source is the randomly generated key itself, with the final output being a text-based representation of the encoded secret, showcasing the provider’s integration with the Java security API.

CCarlos-Augusto

64% match

Loading thumbnail…

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.

CCarlos-Augusto

60% match

Loading thumbnail…

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.

CCarlos-Augusto

57% match

Loading thumbnail…

Gist d8122161cee20af6219aa00b744ec60e

This example decodes a JSON Web Token (JWT) in Scala, showing the three components of the token: header, payload, and signature. It uses the `pdi.jwt` library to encode a claim with a secret key and the HS256 algorithm, then decodes it back with `Jwt.decodeRawAll`. The payload contains issuer, audience, expiration, and a custom role claim, serialized via `org.json4s`.

CCarlos-Augusto

55% match

Loading thumbnail…

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

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

53% match

Loading thumbnail…

Gist 4be22b7cae64ca396e86b0b86edb8e7c

This example verifies a GitHub user’s identity by displaying a signed Keybase proof as a static gist. It shows the full cryptographic JSON object, including the public key, signature, and timestamps, alongside instructions for command-line verification. The rendering relies on the Keybase API and GitHub’s gist hosting, with the signature presented as raw text for auditability. The visualization is not graphical; instead, it presents the proof’s structure and content as the primary display.

NNYCSwan

53% match

Loading thumbnail…

Gist 1578582fcbde7fceab08672a7e12d8b1

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.

JJoeYerardi

52% match