RSA decryption from N, e and d

Overview & Cryptographic Context

An RSA key is nothing more than a few large integers. The modulus N = p × q and the public exponent e form the public key; the private exponent d with e · d ≡ 1 (mod λ(N)) completes the private key. Textbooks, standards and test vectors usually print exactly these three numbers, but cryptographic libraries want a key in a standard container such as PKCS#8.

This workflow closes that gap. RSA Key Encoder takes N, e and d, recovers the two prime factors from them (NIST SP 800-56B Rev. 2, Appendix C), checks that they multiply to N and that d inverts e, and writes a PKCS#8 private key. RSA Decrypt then removes the RSA-OAEP padding (RFC 8017, SHA-256, empty label) and returns the message.

The key is a throw-away 1024-bit test key generated for this example and used for nothing else. The ciphertext was produced by Node crypto (OpenSSL), an implementation independent of NodeCrypto, so a matching result confirms the whole chain. 1024 bits is too small for real use; it only keeps the numbers short enough to read.

Pipeline Architecture & Wiring Flow

1. Components and ciphertext ingress (Workflow Input): Supplies N, e, d and the Ciphertext as bytes, in big-endian order without leading zero bytes.
2. Key assembly (RSA Key Encoder): With keyType = "Private" the d input appears. The node computes p and q, derives the CRT values and outputs the PKCS#8 private key.
3. OAEP decryption (RSA Decrypt): Uses that key with hash = "SHA-256" and returns the original message.
4. Result (Workflow Output): Emits the recovered message on the Plaintext port: the 19 ASCII bytes of "RSA from N, e and d".

Nodes & Configuration

Node reference →

Inputs, Outputs & Test Vector Verification

Verification Source: Independent implementation check, Node crypto (OpenSSL RSA-OAEP, SHA-256) on a freshly generated 1024-bit test key (e = 65537) used for nothing else; no published vector

Inputs

Expected Outputs