Skip to main content
100%

Generate an instance of OpenSSL::PKey::RSA from `n` and `e` in OpenSSL 3 on Ruby

✓ Published0🌍 Public
WWilliamNHarvey
Last edited May 5, 2023
Created on May 5, 2023

This example shows how to reconstruct an OpenSSL RSA public key from the raw modulus and exponent values found in a JWKS well-known endpoint, such as Google’s certificate feed. It defines a `create_rsa_key` method that builds an ASN.1 DER structure using `OpenSSL::ASN1::Sequence` and `OpenSSL::ASN1::Integer`, then instantiates an `OpenSSL::PKey::RSA` object from that DER. The helper `base64_to_long` converts URL-safe Base64 strings like the provided `n` and `e` into Ruby integers via unpacking bytes and hex conversion, allowing the key to be generated programmatically from typical JSON data.

AI-generated description

Similar vizzes

Loading thumbnail…

generating SSL keys and Certificate Signing Requests for Heroku / Nginx / RapidSSL

This example shows a step-by-step terminal transcript of generating an SSL key and certificate signing request, then unlocking, combining, and uploading the certificate to Heroku. The process uses the OpenSSL command-line API (`openssl genrsa`, `openssl req`, `openssl rsa`, `cat` for concatenation) and Heroku’s CLI (`heroku ssl:add`, `heroku addons:add`). The text-based log traces the flow from key creation through DNS activation, with shell prompts and command outputs as the visual data.

RRandomEtc
53% match
Loading thumbnail…

Using Node-Jose to for RSA jwt with key store

This example demonstrates how to sign and verify a JSON Web Token (JWT) using RSA keys managed through the `node-jose` keystore. It generates a fresh RSA 2048-bit key pair, stores it as a JSON keystore file, and then signs a payload with `JWS.createSign` using the `RS256` algorithm. The code also verifies the token with `JWS.createVerify`, converts the JWK to PEM via `jwk-to-pem`, and validates it again with the `jsonwebtoken` library’s `jwt.verify`. The keystore is loaded from or saved to `.cert/keystore.json`.

AAnsonT
50% match
Loading thumbnail…

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.

CCarlos-Augusto
47% match
Loading thumbnail…

Gist 5c4aad6bd3947d114e739c67638c219e

This example demonstrates how to set up an SSH connection from a ChromeBook or Chrome OS device to a server using RSA key authentication. It shows the server-side key generation process with `ssh-keygen`, the manual transfer of the private key to the ChromeBook’s download directory, and the step-by-step crosh shell commands (`ssh`, `host`, `user`, `key`, `connect`) needed to establish the session. The content also includes a direct macOS terminal command (`ssh <username>@<host> -i <key file path>`) as an alternative login method, with notes on the roles of `authorized_keys` and `known_hosts` files.

VVioletVivirand
47% match
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
45% 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
44% 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
44% match
Loading thumbnail…

Gist c283ab406d45a37dc94f0df43c6a9d19

This example loads a private SSH key file, parses its metadata, and visualizes the key’s structure with D3’s `d3.forceSimulation` for node placement and `d3.select` for SVG rendering. It shows the distribution of key segments and their relationships, drawing nodes and links based on the base64-decoded data. The rendering approach uses a custom JavaScript parser to extract header and body components, then maps each line of the key into a force-directed graph. The visualization relies on standard D3 APIs like `d3.forceLink` and `d3.forceManyBody` to arrange elements interactively.

PPeleke
43% match