Cipher Algorithms in TheAlgorithms/Python

Caesar cipher's weakness is that every letter shifts by the same amount, so frequency analysis breaks it quickly. Vigenere's fix is to vary the shift by cycling through a keyword. The key_index variable tracks which keyword character to use next. For each plaintext letter, LETTERS.find(key[key_index]) gives the shift value for this position, and the result is reduced modulo 26. After each alphabetic character is processed, key_index advances and wraps at the keyword length, so a six-letter keyword like HDarji produces six different shifts cycling A-H, B-D, C-a, and so on. Non-alphabet characters such as spaces and punctuation are appended untouched and do not advance the key index. This single shared function handles both encryption and decryption based on the mode argument.

RSA's security rests on the difficulty of factoring the product of two large primes. The public key is the pair (n, e) where n is that product and e is the public exponent. Encryption is a single line: pow(block, e, n) raises the message block to the power e modulo n. Python's built-in pow with three arguments uses fast modular exponentiation, so even with 1024-bit numbers this completes quickly. The block conversion step before this function splits the string into fixed-size integer blocks. Decryption uses the same pow(block, d, n) operation with the private exponent d. The mathematical guarantee is that (m^e)^d mod n == m for any message integer m. For the full key generation and decryption flow, see the deeper tour.

Diffie-Hellman solves the problem of two parties agreeing on a shared secret over an insecure channel without transmitting that secret. Alice's public key is g^a mod p where g is the group generator, a is her private key, and p is the prime. Bob's public key is g^b mod p. When Alice receives Bob's public key and applies her own private key she gets (g^b)^a mod p. Bob gets (g^a)^b mod p. Both expressions equal g^(ab) mod p, so both parties hold the same value without ever transmitting it. The is_valid_public_key guard uses the Legendre symbol check from NIST SP 800-56 to reject invalid keys that could leak the private exponent. The shared secret is then hashed with SHA-256 before use.

Playfair, developed by Charles Wheatstone in 1854, encrypts two letters at a time rather than one. This makes single-letter frequency analysis ineffective. The key generates a 5x5 table of the 25 letters (I and J are merged). For each pair, divmod(table.index(char), 5) extracts the row and column. Three rules govern substitution: if both letters are in the same row, each shifts right one column with wrap; if in the same column, each shifts down one row with wrap; otherwise the letters form the corners of a rectangle and are replaced by the opposite corners. The rectangle rule on lines 115-116 swaps columns: each letter takes its row but the other letter's column. Decryption reverses the directional shifts. The guard against repeated-letter pairs in prepare_input is why an X sometimes appears in decrypted output.

Hill cipher applies linear algebra to cryptography: the key is an NxN matrix and each plaintext batch of N characters becomes a column vector. The encryption step is key_matrix dot text_vector mod 36. The result vector is mapped back to characters. This makes Hill cipher a polyalphabetic substitution where each output character depends on N input characters simultaneously, not one at a time. The doctest shows that encrypting 'hello' with a 2x2 key matrix produces '85FF00', six characters because process_text pads the input to an even length. Digits appear in the output because the implementation uses a 36-character alphabet (26 letters plus 10 digits) to make the key matrix invertible modulo 36. Decryption requires the modular inverse of the key matrix, which is why the determinant must be coprime with 36.

The Enigma machine's security came from the combination of three substitution layers applied in sequence. Each rotor is a fixed permutation of the 26-letter alphabet. A letter enters rotor 1 at an offset determined by the rotor's current position, passes through its permutation, then continues to rotor 2 and rotor 3 the same way. The reflector on line 261 maps every letter to a partner, ensuring the path is reversible. After the reflector, the signal passes back through all three rotors in reverse order using index() instead of subscript access. The comment on line 259 explains the key property: because the reflector maps every letter to a different letter, encrypting the ciphertext with the same rotor settings recovers the plaintext without needing a separate decryption mode. Rotor positions advance after each letter, so the same plaintext letter encodes differently each time.