Java Program for AMSCO Cipher with Variable Length Columnar Transposition

Introduction

The AMSCO cipher java is a variant of columnar transposition that uses variable length segments to break the regular structure of the standard columnar transposition cipher. It was published by the Italian cryptographer A. M. Scott in the early twentieth century and is sometimes called the AMSCO cipher after the initials of its inventor. The cipher alternates between single character and double character entries in the transposition grid, which makes the ciphertext harder to attack than a plain columnar transposition. This amsco cipher java tutorial walks through the construction of the alternating grid, the keyed column read-off, and the reverse process for decryption.

The AMSCO cipher is interesting because it is the simplest example of a variable length transposition cipher. Most transposition ciphers use a fixed cell size (one character per cell), but the AMSCO cipher alternates between one character and two characters per cell, which produces a non-rectangular grid that is harder to attack with standard columnar transposition techniques.

What is the AMSCO Cipher?

The AMSCO cipher is a columnar transposition cipher with variable length entries. The plaintext is split into alternating single and double character segments, with the first segment being a single character, the second being a double character, the third being a single character again, and so on. The segments are written into a grid with one column per key letter, and the columns are read off in the order determined by sorting the key alphabetically.

Compared to a plain columnar transposition, the AMSCO cipher uses variable length entries, which means the grid is not rectangular. This breaks the regular structure that standard columnar transposition attacks rely on.

Compared to a double columnar transposition, the AMSCO cipher is a single transposition, but the variable length entries make it more resistant to attack than a single fixed length columnar transposition.

How the AMSCO Cipher Works Step by Step

Step 1: Choose a key. We use ZEBRA as the key. The key length determines the number of columns in the transposition grid.

Step 2: Clean the plaintext. We use HELLO WORLD as the plaintext. After cleaning, the plaintext is HELLOWORLD.

Step 3: Split the plaintext into alternating single and double character segments. Starting with a single character: H, EL, L, OW, O, RL, D. The segments are H, EL, L, OW, O, RL, D. If the plaintext length does not divide evenly into the alternating pattern, the last segment may be a single character.

Step 4: Write the segments into the transposition grid row by row. The grid has 5 columns (one per key letter). The first row is H EL L OW O (5 segments). The second row is RL D (2 segments). The grid looks like: Z E B R A H EL L OW O RL D - - -

Step 5: Sort the key alphabetically. ZEBRA sorts to A B E R Z (the column indices in sorted order are 4, 2, 1, 3, 0). Read off the columns in this sorted order to produce the ciphertext.

Step 6: Decrypt by reversing the columnar transposition. The receiver knows the key and the alternating pattern, so they can reconstruct the grid dimensions and the order in which the columns were read.

Java Program for AMSCO Cipher

import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;

public class AmscoCipher {

    public static String clean(String s) {
        return s.toUpperCase().replaceAll("[^A-Z]", "");
    }

    public static List<String> splitSegments(String plain) {
        List<String> segments = new ArrayList<>();
        int i = 0;
        boolean single = true;
        while (i < plain.length()) {
            int len = single ? 1 : 2;
            if (i + len > plain.length()) len = plain.length() - i;
            segments.add(plain.substring(i, i + len));
            i += len;
            single = !single;
        }
        return segments;
    }

    public static Integer[] sortedOrder(String key) {
        int cols = key.length();
        Integer[] order = new Integer[cols];
        for (int i = 0; i < cols; i++) order[i] = i;
        Arrays.sort(order, (a, b) -> {
            int cmp = Character.compare(key.charAt(a), key.charAt(b));
            return cmp != 0 ? cmp : Integer.compare(a, b);
        });
        return order;
    }

    public static String encrypt(String plain, String key) {
        plain = clean(plain);
        key = clean(key);
        List<String> segments = splitSegments(plain);
        int cols = key.length();
        // Fill grid row by row
        List<List<String>> grid = new ArrayList<>();
        int idx = 0;
        while (idx < segments.size()) {
            List<String> row = new ArrayList<>();
            for (int c = 0; c < cols && idx < segments.size(); c++) {
                row.add(segments.get(idx++));
            }
            grid.add(row);
        }
        Integer[] order = sortedOrder(key);
        StringBuilder sb = new StringBuilder();
        for (int c : order) {
            for (List<String> row : grid) {
                if (c < row.size()) sb.append(row.get(c));
            }
        }
        return sb.toString();
    }

    public static String decrypt(String cipher, String key) {
        cipher = clean(cipher);
        key = clean(key);
        int cols = key.length();
        // Recreate the segment layout
        List<String> sampleSegments = splitSegments(
            "X".repeat(cipher.length()));   // template
        int rows = (sampleSegments.size() + cols - 1) / cols;
        // Determine each column's segment count
        Integer[] order = sortedOrder(key);
        int[] colSegCount = new int[cols];
        int segIdx = 0;
        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                if (segIdx < sampleSegments.size()) {
                    colSegCount[c]++;
                    segIdx++;
                }
            }
        }
        // Determine each column's character count
        int[] colCharCount = new int[cols];
        int s = 0;
        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                int idx = r * cols + c;
                if (idx < sampleSegments.size()) {
                    colCharCount[c] += sampleSegments.get(idx).length();
                }
            }
        }
        // Read cipher columns in sorted order
        int pos = 0;
        String[] colText = new String[cols];
        for (int c : order) {
            int len = colCharCount[c];
            colText[c] = cipher.substring(pos, pos + len);
            pos += len;
        }
        // Rebuild segments row by row using sampleSegments layout
        StringBuilder sb = new StringBuilder();
        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                int idx = r * cols + c;
                if (idx >= sampleSegments.size()) continue;
                int segLen = sampleSegments.get(idx).length();
                if (colText[c] == null || colText[c].length() < segLen) continue;
                sb.append(colText[c].substring(0, segLen));
                colText[c] = colText[c].substring(segLen);
            }
        }
        return sb.toString();
    }

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

Code Explanation Line by Line

The clean method uppercases the input and removes non-letter characters. This is the standard preparation for classical transposition ciphers.

The splitSegments method walks the plaintext and produces alternating single and double character segments. The boolean single starts true and toggles after each segment. The last segment may be truncated if the plaintext length does not divide evenly into the alternating pattern.

The sortedOrder method returns the column indices in the order they should be read, with ties broken by original column position to handle duplicate letters in the key.

The encrypt method splits the plaintext into segments, fills a grid row by row with the segments, and reads off the columns in the sorted order. The grid is a List of Lists of Strings, where each cell contains a one or two character segment. The ciphertext is the concatenation of all column reads.

The decrypt method reverses the process. It first builds a template of segments using the same alternating pattern, then computes the character count of each column from the template. It then reads the ciphertext into each column in the sorted order, and reassembles the segments row by row using the template lengths.

The decrypt method is more complex than the encrypt method because the variable length segments make the column read order non-trivial. The key insight is that the alternating pattern is deterministic, so the receiver can recreate the segment layout from the ciphertext length and the key length alone.

Sample Input and Output

Plain :  HELLO WORLD
Key   :  ZEBRA
Cipher:  (output of the program)
Back  :  HELLOWORLD

The plaintext HELLO WORLD is cleaned to HELLOWORLD and split into segments H, EL, L, OW, O, RL, D. The segments are arranged in a 5-column grid keyed by ZEBRA, and the columns are read off in the sorted order A, B, E, R, Z. The decrypted output matches the cleaned plaintext exactly.

Common Mistakes to Avoid

First, forgetting to alternate the segment length. If you always use single character segments, the cipher degenerates to a plain columnar transposition. If you always use double character segments, the cipher is a different (and weaker) variant.

Second, mishandling the last segment. If the plaintext length is odd, the last segment is a single character. If you forget to truncate the last segment, you will read past the end of the plaintext and throw an exception.

Third, handling duplicate letters in the key incorrectly. The AMSCO cipher uses the same sorted column order as the standard columnar transposition, with ties broken by original column position.

Fourth, computing the column character counts incorrectly during decryption. The decrypt method must compute the character count of each column from the alternating segment pattern, or the column reads will not align correctly.

Real-World Applications

The AMSCO cipher is not used in production today. Its security is weak by modern standards because the alternating pattern is deterministic and can be reconstructed from the ciphertext length and the key length.

However, the AMSCO cipher is a useful teaching example because it demonstrates how variable length entries can break the regular structure of a columnar transposition. The same principle is used by modern ciphers that operate on variable length blocks, such as stream ciphers that process input byte by byte rather than in fixed 16-byte blocks.

The AMSCO cipher is also a useful demonstration of the principle of confusion and diffusion. The keyed column read order provides confusion, and the variable length segments provide additional diffusion by breaking the regular grid structure. Modern block ciphers use the same two principles, with multiple rounds of substitution and permutation to achieve strong security.

In capture the flag events, the AMSCO cipher is sometimes used as a puzzle that requires the solver to recognize the alternating pattern. The hint is usually a ciphertext whose length is consistent with the alternating pattern given a specific key length.

The AMSCO cipher is also historically significant because it was one of the first ciphers to use variable length entries in a transposition cipher. This idea has been rediscovered many times in different forms, including in modern cryptographic constructions that use variable length encoding for efficiency reasons.

Conclusion

The AMSCO cipher is a variable length columnar transposition cipher. We split the plaintext into alternating single and double character segments, filled a keyed grid, and read off the columns in sorted order. Next you should study the standard columnar transposition cipher (which uses fixed length single character entries), the double columnar transposition cipher (which applies the columnar transposition twice), and the ADFGVX cipher (which combines fractionation with columnar transposition).