How RSA Encryption Works

The key file format is intentionally minimal: a single line with three comma-separated integers. The first integer is the key size in bits, which the caller uses to enforce the block-size limit. The second is the modulus n (the product of the two primes). The third is either the public exponent e (in the public key file) or the private exponent d (in the private key file). Both the encryption path and the decryption path call this same function; they pass different filenames. Line 66 splits on commas and line 67 converts each token to an integer. That simplicity is intentional: contributors can inspect a key file in a text editor and see all three components. A production key format like PKCS#8 carries metadata, algorithm identifiers, and encoding, none of which are needed for understanding the mathematical structure.

RSA encryption is one operation: raise each plaintext block to the public exponent e modulo n. Python's built-in pow(block, e, n) on line 46 does this efficiently with fast modular exponentiation (square-and-multiply), avoiding the need to compute the intermediate giant integer block**e before taking the remainder. Line 43 unpacks the 2-tuple key into n and e, matching the format that read_key_file returns after dropping the key-size field. get_blocks_from_text converts the message string into a list of integers, one per 128-byte chunk, by treating each byte as a positional digit in base 256. The result is a list of ciphertext integers, one per plaintext block. To decrypt, a holder of the private key d computes pow(ciphertext_block, d, n), which Euler's theorem guarantees recovers the original integer.

Decryption mirrors encryption in structure and is shorter in code. Line 57 unpacks the private key into n and d. The loop on lines 58 and 59 applies pow(block, d, n) to each ciphertext integer. Euler's theorem guarantees that if d is the modular inverse of e modulo phi(n), then pow(pow(m, e, n), d, n) == m. So each decrypted block recovers the original plaintext integer. Line 60 passes those integers to get_text_from_blocks along with the original message length, which is needed because the last block may be shorter than 128 bytes and the decoder uses the length to trim padding zeroes. Without the message length, the decoder cannot distinguish a trailing null byte that was part of the message from one introduced by block-size padding.

The block-size guard on line 77 is where the mathematical constraint is enforced in code. RSA requires that every plaintext integer be smaller than n. If a 128-byte block is 1024 bits and the key modulus is only 512 bits, the block integer can exceed n, and modular arithmetic breaks the round-trip. Line 77 multiplies the byte block size by 8 to get bits and compares it against the key size recorded in the key file. A mismatch exits with a diagnostic message rather than silently producing garbage ciphertext. Line 87 writes the output file in a self-describing format: message_length_block_size_comma_separated_blocks. The decryption path reads this prefix to know how many characters to recover and which block size was used, making the file independent of any external configuration.

The main function ties the file together and shows the full encrypt-decrypt cycle at the interactive level. Line 125 checks whether a public key file already exists before generating one; on the first run rkg.make_key_files("rsa", 1024) generates a 1024-bit keypair and writes two files, rsa_pubkey.txt and rsa_privkey.txt, to the current directory. Encryption reads the public key, encrypts the message, and writes the ciphertext to encrypted_file.txt. Decryption reads the private key and the ciphertext file, decrypts, and writes the result to rsa_decryption.txt. The file is explicit about what it is not: there is no certificate verification, no padding scheme, no key exchange, and no protection against timing attacks. Running this file is the fastest way to see RSA round-trip a message end to end at the integer level.