Java Program for Gronsfeld Cipher with Multiple Digit Key

Introduction

The Gronsfeld cipher java is a close cousin of the Vigenere cipher that uses a key consisting of decimal digits instead of letters. It was named after a Count Gronsfeld who reportedly used it in the seventeenth century, and it became popular because a digit key is easier to remember and to write on paper than a letter key. Each digit in the key selects one of ten Caesar shifts, which makes the cipher a strict subset of the Vigenere family: every Gronsfeld key is also a Vigenere key with letters A through J, but not vice versa.

This gronsfeld cipher java tutorial walks through the construction of the digit key, the encryption and decryption algorithms, and a complete Java program. Along the way you will see why the smaller keyspace makes the Gronsfeld cipher noticeably weaker than the full Vigenere, even though the algorithm is structurally identical.

What is the Gronsfeld Cipher?

The Gronsfeld cipher is a polyalphabetic substitution cipher. The key is a sequence of decimal digits from 0 to 9. The plaintext is aligned with the repeated key, and each plaintext letter is shifted by the value of the corresponding key digit modulo 26. Compared to the Vigenere cipher, the keyspace per character is only 10 instead of 26, so the cipher is strictly weaker against brute force.

Compared to the Caesar cipher, the Gronsfeld cipher is strictly stronger because each letter uses a different shift, which flattens the letter frequency distribution in the ciphertext. Compared to the running key cipher, the Gronsfeld is much weaker because the key is typically short and made of low entropy digits.

Because the key digits are restricted to 0 to 9, the cipher never wraps the alphabet in unusual ways. A digit of 3 shifts A to D, B to E, and so on, just like a Caesar cipher with shift 3. The repeated key produces a polyalphabetic effect that defeats the simplest frequency analysis attacks.

How the Gronsfeld Cipher Works Step by Step

Step 1: Choose a digit key. We use 31415, the first five digits of pi. The key can be any length, but lengths between 4 and 10 are typical.

Step 2: Align the plaintext with the repeated key. For HELLO WORLD with key 31415, the alignment is H E L L O W O R L D paired with 3 1 4 1 5 3 1 4 1 5.

Step 3: Apply each shift. H shifted by 3 becomes K. E shifted by 1 becomes F. L shifted by 4 becomes P. L shifted by 1 becomes M. O shifted by 5 becomes T. W shifted by 3 becomes Z. O shifted by 1 becomes P. R shifted by 4 becomes V. L shifted by 1 becomes M. D shifted by 5 becomes I. The ciphertext is KFPMTZPVMI.

Step 4: Decrypt by subtracting the key digit from each ciphertext letter, modulo 26. K minus 3 is H. F minus 1 is E. P minus 4 is L. And so on.

Step 5: Cycle the key as needed for longer plaintexts. The key length is 5, so the 6th plaintext letter uses the 1st key digit again, the 7th uses the 2nd, and so on.

Java Program for Gronsfeld Cipher

public class GronsfeldCipher {

    private static int[] parseKey(String key) {
        key = key.replaceAll("\s+", "");
        int[] digits = new int[key.length()];
        for (int i = 0; i < key.length(); i++) {
            char ch = key.charAt(i);
            if (ch < '0' || ch > '9') {
                throw new IllegalArgumentException(
                    "Key must be digits only, found: " + ch);
            }
            digits[i] = ch - '0';
        }
        return digits;
    }

    public static String encrypt(String plain, String key) {
        int[] k = parseKey(key);
        StringBuilder sb = new StringBuilder();
        int idx = 0;
        for (char ch : plain.toUpperCase().toCharArray()) {
            if (ch >= 'A' && ch <= 'Z') {
                int shift = k[idx % k.length];
                char shifted = (char) ('A' + (ch - 'A' + shift) % 26);
                sb.append(shifted);
                idx++;
            } else {
                sb.append(ch);   // pass spaces and punctuation unchanged
            }
        }
        return sb.toString();
    }

    public static String decrypt(String cipher, String key) {
        int[] k = parseKey(key);
        StringBuilder sb = new StringBuilder();
        int idx = 0;
        for (char ch : cipher.toUpperCase().toCharArray()) {
            if (ch >= 'A' && ch <= 'Z') {
                int shift = k[idx % k.length];
                char unshifted = (char) ('A' + (ch - 'A' - shift + 26) % 26);
                sb.append(unshifted);
                idx++;
            } else {
                sb.append(ch);
            }
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String plain  = "HELLO WORLD";
        String key    = "31415";
        String cipher = encrypt(plain, key);
        String back   = decrypt(cipher, key);
        System.out.println("Plain : " + plain);
        System.out.println("Key   : " + key);
        System.out.println("Cipher: " + cipher);
        System.out.println("Back  : " + back);
    }
}

Code Explanation Line by Line

parseKey strips whitespace from the key and converts each character into a digit 0 to 9. If any character is not a digit, an IllegalArgumentException is thrown. This guards against typos where a user types a letter or a separator into the key.

encrypt iterates over the uppercased plaintext. For each letter, it picks the next key digit using idx % k.length, applies the Caesar shift modulo 26, and increments idx. Non-letter characters are passed through unchanged, and crucially, the key index is only advanced for letters so that spaces and punctuation do not desynchronize the key.

decrypt is the mirror image. The expression (ch - 'A' - shift + 26) % 26 handles negative results correctly by adding 26 before taking the modulus. Without the +26, a negative numerator in Java would produce a negative modulus and break the decryption.

The main method demonstrates a round trip with the message HELLO WORLD and key 31415. The output verifies that the decrypted text matches the cleaned plaintext.

Note that the key index advances only for letters. This is the standard Vigenere convention and it ensures that the same plaintext always encrypts to the same ciphertext given the same key, regardless of where spaces appear.

Sample Input and Output

Plain :  HELLO WORLD
Key   :  31415
Cipher:  KFPMT ZPVMI
Back  :  HELLO WORLD

The plaintext HELLO WORLD becomes KFPMT ZPVMI with key 31415. The decrypted output matches the cleaned plain text. The space in the middle of the ciphertext is preserved from the input because spaces are passed through unchanged.

Common Mistakes to Avoid

First, advancing the key index for non-letter characters. If you increment idx for every character including spaces, the key will desynchronize between encryption and decryption when the input contains a different number of non-letter characters.

Second, forgetting the +26 in the decryption formula. Java's % operator can return negative values for negative numerators, so (ch - 'A' - shift) % 26 may produce a negative result and break the round trip.

Third, allowing key digits greater than 9. Some users try to use multi-digit shifts like 12, but the Gronsfeld key is a sequence of single decimal digits. If you want a shift of 12, use the digits 1 and 2 as two separate key positions.

Fourth, using a key of length 1. A single digit key degenerates to a Caesar cipher, which is trivially broken by frequency analysis. Use a key of at least 4 digits.

Real-World Applications

The Gronsfeld cipher is never used in production. Its keyspace is too small to resist modern attacks. Even with a key of length 10, the keyspace is only 10 to the 10th power, which is trivially brutable on a modern CPU.

However, the Gronsfeld cipher is a perennial favorite in puzzles, escape rooms, and capture the flag events. The digit key is intuitive, and the smaller alphabet of digits 0 to 9 makes hand encryption feasible. Many puzzle designers layer a Gronsfeld cipher on top of a transposition cipher to create a more challenging puzzle.

In modern systems, the principle of using a small alphabet for a key shows up in personal identification numbers, one time password tokens that use 6 digit codes, and the TOTP algorithm used by authenticator apps. The TOTP code itself is generated by HMAC, but the display format is decimal digits, echoing the Gronsfeld idea that digits are easier for humans to handle than letters.

The Gronsfeld is also a useful teaching step before the full Vigenere. Students who find the 26 by 26 Vigenere tableau intimidating can start with the 10 by 26 Gronsfeld version, which has the same polyalphabetic structure but a smaller key alphabet.

The digit key idea also appears in modern multi factor authentication. The seed value used by TOTP and HOTP tokens is a binary secret, but the user visible output is a six or eight digit decimal number. This choice of decimal digits over letters is the same as the Gronsfeld choice: digits are easier for humans to read, type, and remember than letters, even though the keyspace per character is smaller. The trade-off is identical to the one made by the Gronsfeld cipher four centuries ago.

In classroom settings, the Gronsfeld cipher is a perennial favorite for homework problems because the digit key is easy to verify by hand. A teacher can hand out a key like 31415 and ask students to encrypt a short message by hand. The student practices the polyalphabetic shift and the modulo wraparound without the cognitive load of working with a 26 by 26 tableau. The Gronsfeld also pairs well with frequency analysis exercises, because the smaller key alphabet makes the cipher easy to break with hand computed statistics, which teaches the student why longer keys are stronger.

Conclusion

The Gronsfeld cipher is a polyalphabetic cipher with a digit key. We implemented encrypt and decrypt using single digit shifts, careful key cycling, and the algebraic inverse formula. Next you should study the full Vigenere cipher with letter keys, the running key cipher with a long text key, and the one time pad with a key as long as the message.