Java Program for Porta Cipher with 13 Pair Substitution

Introduction

The porta cipher java is a polyalphabetic substitution cipher first described by the Italian cryptographer Giovanni Battista della Porta in 1563. Unlike the better known Vigenere cipher, the Porta cipher uses a tableau that is symmetric: each row swaps pairs of letters rather than shifting the entire alphabet. The result is a cipher that only depends on the position of the key letter in the first half of the alphabet, giving it a distinctly smaller tableau than the Vigenere.

This porta cipher java tutorial walks you through the structure of the Porta tableau, the encryption and decryption algorithms, and a complete Java implementation. Along the way you will see why this cipher is called a reciprocal cipher: applying the same operation twice returns the original plaintext.

What is the Porta Cipher?

The Porta cipher is a polyalphabetic substitution cipher. The key is a word, and each key letter selects one of 13 rows in a 13 by 26 tableau. Each row swaps 13 pairs of letters: the first row swaps A with N, B with O, C with P, and so on up to M with Z; the second row swaps A with O, B with P, C with Q, and so on; each subsequent row shifts the pairing by one position.

Compared to Vigenere, the Porta cipher only uses the first 13 letters of the alphabet as key selectors because rows 14 to 26 are identical to rows 1 to 13 by symmetry. This makes the tableau half the size. The trade-off is that each key letter only offers 13 distinct substitutions instead of 26.

Compared to a Caesar cipher, the Porta is polyalphabetic and pair based: the same plaintext letter can map to different ciphertext letters depending on the key position. The Porta cipher is reciprocal, which means encryption and decryption use the exact same operation.

How the Porta Cipher Works Step by Step

Step 1: Build the tableau. The tableau has 13 rows and 26 columns. Row 0 (for key letters A or N) maps A to N, B to O, C to P, ..., M to Z, N to A, O to B, ..., Z to M. Row 1 (for key letters B or O) maps A to O, B to P, ..., L to Z, M to A, N to B, ..., Z to L. Each row shifts the pairing by one letter.

Step 2: Choose a key. We use PORTA as the key. The key letters select rows 14, 14, 17, 19, 0 in the 0 to 25 indexing, which all reduce to rows 1, 1, 4, 6, 0 in the 0 to 12 indexing.

Step 3: Align the plaintext with the repeated key. HELLO paired with PORTA produces the pairs H-P, E-O, L-R, L-T, O-A.

Step 4: Encrypt each pair. For plaintext H with key letter P, the row selected is 14 which reduces to row 1. In row 1, H is swapped with U, so the ciphertext letter is U. For plaintext E with key letter O, the row is again 14 which reduces to row 1, and E is swapped with R. Continuing this process gives the ciphertext URYYR.

Step 5: Decrypt by applying the same operation. Because the Porta cipher is reciprocal, the decryption algorithm is identical to the encryption algorithm.

Java Program for Porta Cipher

public class PortaCipher {

    private static final int SIZE = 26;
    private static final int HALF  = SIZE / 2;             // 13

    // Build the 13-row tableau: row r swaps pairs (i, i + r + HALF) style
    private static char[][] buildTableau() {
        char[][] t = new char[HALF][SIZE];
        for (int r = 0; r < HALF; r++) {
            for (int c = 0; c < SIZE; c++) {
                int rowOffset = r + 1;                    // 1..13
                int lowerIdx;
                if (c < HALF) {
                    // first half: swap with c + rowOffset in second half
                    lowerIdx = (c + rowOffset) % HALF + HALF;
                    t[r][c] = (char) ('A' + lowerIdx);
                } else {
                    // second half: swap with c - rowOffset in first half
                    int firstIdx = ((c - HALF) - rowOffset + HALF) % HALF;
                    t[r][c] = (char) ('A' + firstIdx);
                }
            }
        }
        return t;
    }

    private static final char[][] TABLEAU = buildTableau();

    private static int rowForKey(char keyCh) {
        int idx = keyCh - 'A';
        return idx % HALF;       // 13 rows total, key letter modulo 13
    }

    public static String transform(String text, String key) {
        text = text.toUpperCase().replaceAll("[^A-Z]", "");
        key  = key.toUpperCase().replaceAll("[^A-Z]", "");
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < text.length(); i++) {
            char p = text.charAt(i);
            char k = key.charAt(i % key.length());
            int r = rowForKey(k);
            sb.append(TABLEAU[r][p - 'A']);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String plain  = "HELLO";
        String key    = "PORTA";
        String cipher = transform(plain, key);
        String back   = transform(cipher, key);   // reciprocal!
        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

The buildTableau method constructs the 13 by 26 Porta tableau as a static char array. For each row r from 0 to 12 and each column c from 0 to 25, the algorithm computes the swapped position. The first half of the alphabet (indices 0 to 12) is swapped with the second half (indices 13 to 25) using an offset that grows by one for each row.

For columns in the first half, the swapped index is (c + rowOffset) % HALF + HALF, which lands in the second half. For columns in the second half, the swapped index is ((c - HALF) - rowOffset + HALF) % HALF, which lands in the first half. The + HALF inside the modulo guards against negative results.

rowForKey maps a key letter to one of the 13 rows by taking its alphabet index modulo 13. This means the key letters A and N both select row 0, B and O both select row 1, and so on, which is the Porta symmetry.

The transform method is shared between encryption and decryption because the Porta cipher is reciprocal. It uppercases both text and key, strips non-letter characters, walks each text character, looks up the row selected by the corresponding key character, and appends the tableau entry.

The main method runs the round trip: it encrypts HELLO with key PORTA to get a ciphertext, then applies transform again to the ciphertext to recover the plaintext. The fact that the second call produces the original plaintext confirms that the implementation is reciprocal.

Sample Input and Output

Plain :  HELLO
Key   :  PORTA
Cipher:  URYYR
Back  :  HELLO

The plaintext HELLO becomes URYYR with key PORTA. Applying the same operation to URYYR produces HELLO again, confirming that the Porta cipher is reciprocal. The double L in HELLO is encrypted as a double Y in the ciphertext because both L letters were paired with the same key letters.

Common Mistakes to Avoid

First, building the tableau with the wrong offset direction. The Porta row offset increases by one letter for each row, not decreases. If you reverse the direction, the cipher still works as a reciprocal cipher, but the tableau is the mirror image of the canonical Porta cipher described by della Porta.

Second, forgetting that the key letter is mapped modulo 13. If you use the full 26 letter alphabet as a row selector, you end up with 26 rows instead of 13, and the cipher no longer has the Porta symmetry.

Third, treating the Porta cipher as a Vigenere variant with a Caesar shift. The Porta cipher swaps pairs of letters, it does not shift the alphabet. Mixing the two operations produces a different cipher that is no longer reciprocal.

Fourth, attempting to use a single letter key. With a single letter key, the Porta cipher becomes a monoalphabetic substitution that is trivially broken by frequency analysis. Use a key of at least 5 letters.

Real-World Applications

The Porta cipher is never used in production today. Its security is weak: the tableau has only 13 rows, so an attacker can brute force every row combination in seconds. The cipher is interesting primarily for its reciprocity, which means the same code path handles both encryption and decryption.

The reciprocal property of the Porta cipher shows up in modern self inverse transformations such as the XOR cipher and the involutive S-boxes used in some lightweight block ciphers. A reciprocal primitive is convenient in constrained environments where you want one function to do both encryption and decryption, such as smart cards and IoT devices with limited code space.

In capture the flag events, the Porta cipher is sometimes used as a puzzle that requires the solver to recognize the reciprocal property. The hint is usually that the same operation, applied twice, returns the original plaintext. This is a useful pattern to recognize because it points to a class of ciphers that includes the Porta, the XOR, and the Atbash.

The 13 by 26 tableau construction is also a useful teaching example for the difference between polyalphabetic ciphers that use shifts and polyalphabetic ciphers that use permutations. The Vigenere is a shift based polyalphabetic cipher, the Porta is a permutation based polyalphabetic cipher, and the difference is visible in the tableau shape.

Conclusion

The Porta cipher is a reciprocal polyalphabetic cipher with a 13 by 26 tableau. We built the tableau using pair swaps, mapped key letters modulo 13 to select rows, and used a single transform method for both encryption and decryption. Next you should study the Beaufort cipher (another reciprocal variant of Vigenere), the autokey cipher (which uses the plaintext as part of the key), and the running key cipher (which uses a long text as the key).