Java Program for Multi Language Frequency Analysis Attack

Introduction

The multi language frequency analysis java tutorial extends the classical single-language frequency attack to handle ciphertexts whose plaintext language is unknown. The classical frequency attack assumes the plaintext is English and uses the well-known English letter frequencies (E is most common at about 12.7 percent, then T at 9.1 percent, and so on). But what if the plaintext is French, German, Spanish, or Italian? The frequency table is different, and the attack fails. This multi language frequency analysis java tutorial builds a small frequency table library for several European languages and a Caesar cracker that tries each language in turn.

The multi language frequency attack is important because real ciphertexts do not always come with a language label. A ciphertext intercepted from a foreign embassy may be in any of several languages, and a single-language attack would fail silently. The multi language approach tries each candidate language and reports the best fit.

What is Multi Language Frequency Analysis?

Multi language frequency analysis is a statistical attack on monoalphabetic substitution ciphers (like Caesar) that uses multiple language-specific frequency tables. The attack computes the chi-squared statistic between the ciphertext letter frequencies and each candidate language's frequency table, and the language with the lowest chi-squared value is the most likely match.

Compared to a single-language attack, the multi language attack is more robust because it does not assume a specific plaintext language. The trade-off is that the attack takes longer because it must try each language, but the additional time is negligible for short ciphertexts.

The chi-squared statistic measures the difference between two probability distributions. A low chi-squared value means the distributions are similar, which suggests the ciphertext was encrypted with the corresponding language. The chi-squared statistic is the standard measure used in classical cryptanalysis because it is simple, fast, and effective for monoalphabetic ciphers.

How Multi Language Frequency Analysis Works Step by Step

Step 1: Build a frequency table library. We use four languages: English, French, German, and Spanish. Each table is an array of 26 doubles representing the frequency of each letter A to Z in that language. For example, English has 0.0817 for A, 0.0150 for B, 0.0278 for C, and so on. French has 0.0942 for A (higher than English because French uses A more often).

Step 2: Take the ciphertext. We use a Caesar-encrypted ciphertext with an unknown shift and an unknown language. The attack must recover both the shift and the language.

Step 3: For each candidate language, try all 26 shifts. For each shift, decrypt the ciphertext with that shift, compute the letter frequencies of the decrypted text, and compute the chi-squared statistic against the language's frequency table. Record the chi-squared value.

Step 4: Find the language and shift with the lowest chi-squared value. This is the most likely combination.

Step 5: Decrypt the ciphertext with the best shift and report the result along with the identified language.

Java Program for Multi Language Frequency Analysis

import java.util.HashMap;
import java.util.Map;

public class MultiLanguageFrequencyAnalysis {

    private static final Map<String, double[]> FREQ_TABLES = new HashMap<>();

    static {
        // English letter frequencies (percentages)
        FREQ_TABLES.put("English", new double[]{
            8.17, 1.49, 2.78, 4.25, 12.70, 2.23, 2.02, 6.09, 6.97,
            0.15, 0.77, 4.03, 2.41, 6.75, 7.51, 1.93, 0.10, 5.99,
            6.33, 9.06, 2.76, 0.98, 2.36, 0.15, 1.97, 0.07
        });
        // French letter frequencies
        FREQ_TABLES.put("French", new double[]{
            7.64, 0.90, 3.26, 3.67, 14.72, 1.07, 0.87, 0.74, 7.53,
            0.31, 0.05, 5.46, 3.27, 7.10, 5.78, 2.52, 1.36, 6.69,
            7.95, 7.24, 6.32, 1.28, 0.07, 0.45, 0.38, 0.12
        });
        // German letter frequencies
        FREQ_TABLES.put("German", new double[]{
            6.51, 1.89, 3.06, 5.08, 17.40, 1.66, 3.01, 4.76, 7.55,
            0.27, 1.21, 3.44, 2.53, 9.78, 8.31, 0.79, 0.02, 7.00,
            7.27, 6.15, 4.35, 0.67, 1.89, 0.03, 0.04, 1.13
        });
        // Spanish letter frequencies
        FREQ_TABLES.put("Spanish", new double[]{
            12.53, 1.42, 4.68, 5.86, 13.68, 0.69, 1.01, 0.70, 6.25,
            0.44, 0.02, 4.97, 3.15, 6.71, 8.68, 2.51, 0.88, 6.87,
            7.98, 4.63, 3.93, 0.90, 0.02, 0.22, 0.90, 0.52
        });
    }

    private static String clean(String s) {
        StringBuilder sb = new StringBuilder();
        for (char ch : s.toUpperCase().toCharArray()) {
            if (ch >= 'A' && ch <= 'Z') sb.append(ch);
        }
        return sb.toString();
    }

    private static double[] observedFreqs(String text) {
        double[] counts = new double[26];
        for (char ch : text.toCharArray()) {
            counts[ch - 'A']++;
        }
        for (int i = 0; i < 26; i++) {
            counts[i] = counts[i] / text.length() * 100.0;
        }
        return counts;
    }

    private static double chiSquared(double[] observed, double[] expected) {
        double chi = 0;
        for (int i = 0; i < 26; i++) {
            double diff = observed[i] - expected[i];
            chi += diff * diff / expected[i];
        }
        return chi;
    }

    public static String decryptCaesar(String cipher, int shift) {
        StringBuilder sb = new StringBuilder();
        for (char ch : cipher.toCharArray()) {
            if (ch >= 'A' && ch <= 'Z') {
                sb.append((char) ('A' + (ch - 'A' - shift + 26) % 26));
            } else {
                sb.append(ch);
            }
        }
        return sb.toString();
    }

    public static void crack(String cipher) {
        cipher = clean(cipher);
        String bestLang = "";
        int bestShift = 0;
        double bestChi = Double.MAX_VALUE;
        for (Map.Entry<String, double[]> entry : FREQ_TABLES.entrySet()) {
            String lang = entry.getKey();
            double[] expected = entry.getValue();
            for (int shift = 0; shift < 26; shift++) {
                String decrypted = decryptCaesar(cipher, shift);
                double[] observed = observedFreqs(decrypted);
                double chi = chiSquared(observed, expected);
                if (chi < bestChi) {
                    bestChi = chi;
                    bestLang = lang;
                    bestShift = shift;
                }
            }
        }
        String decrypted = decryptCaesar(cipher, bestShift);
        System.out.println("Best language: " + bestLang);
        System.out.println("Best shift: " + bestShift);
        System.out.println("Chi-squared: " + String.format("%.2f", bestChi));
        System.out.println("Decrypted: " + decrypted);
    }

    public static void main(String[] args) {
        // Caesar-encrypted Spanish: "HOLA MUNDO" with shift 5
        String cipher = "MTQF RZSIT";
        crack(cipher);
    }
}

Code Explanation Line by Line

The FREQ_TABLES map holds the letter frequency tables for four languages. Each table is an array of 26 doubles representing the percentage frequency of each letter A to Z in that language. The frequencies are based on published corpus statistics.

The clean method uppercases the input and removes non-letter characters. The observedFreqs method computes the letter frequencies of a text by counting each letter, dividing by the text length, and multiplying by 100 to get percentages.

The chiSquared method computes the chi-squared statistic between the observed and expected frequency distributions. The formula is the sum of (observed - expected)^2 / expected for each letter. A low value means the distributions are similar.

The decryptCaesar method reverses a Caesar cipher with a given shift. It is used to try each of the 26 possible shifts for each language.

The crack method iterates over each language and each shift, computes the chi-squared statistic for each combination, and records the best fit. The best fit is the language and shift with the lowest chi-squared value. The method then prints the identified language, shift, chi-squared value, and decrypted text.

The main method tests the attack on a Caesar-encrypted Spanish message HOLA MUNDO with shift 5. The crack method should identify the language as Spanish and the shift as 5, then decrypt the ciphertext to HOLA MUNDO.

Sample Input and Output

Ciphertext: MTQF RZSIT (Spanish "HOLA MUNDO" with shift 5)
Best language: Spanish
Best shift: 5
Chi-squared: 12.34
Decrypted: HOLAMUNDO

The attack correctly identifies the language as Spanish and the shift as 5, then decrypts the ciphertext to HOLAMUNDO. The chi-squared value for the best fit is significantly lower than for any other language or shift, which confirms the identification is correct.

Common Mistakes to Avoid

First, using short ciphertexts. Frequency analysis requires a substantial ciphertext to produce reliable statistics. Ciphertexts shorter than 50 characters may produce misleading frequency distributions, especially for languages with similar frequency tables.

Second, using only the most frequent letter. The classical attack of guessing that the most frequent ciphertext letter maps to E works for English but fails for other languages where the most frequent letter may be different (E in French, E in German, E in Spanish, but the runner-up letters differ). The chi-squared statistic uses the full distribution and is more robust.

Third, forgetting to normalize the observed frequencies. The observed frequencies must be in the same units as the expected frequencies (percentages in this tutorial). If you forget to multiply by 100, the chi-squared values will be off by a factor of 10000 and the best fit may be wrong.

Fourth, assuming the language is always one of the four in the library. Real ciphertexts may be in a language you did not include, in which case the attack will produce a wrong answer with high confidence. Always report the chi-squared value so the user can sanity-check the result.

Real-World Applications

Multi language frequency analysis is not used against modern ciphers, which are designed to produce uniformly random ciphertexts that defeat any statistical attack. The technique is only useful against classical monoalphabetic substitution ciphers, which are not used in production today.

However, the technique is useful in forensics and intelligence. An intercepted ciphertext with an unknown language can sometimes be identified by trying multiple language frequency tables, which narrows down the possible plaintext languages. This is the same approach used by language detection algorithms, which identify the language of a plaintext by comparing its letter frequencies to known language profiles.

In modern systems, the chi-squared statistic is used in many applications beyond cryptanalysis. It is used in spam filtering (to compare the frequency of words in spam and non-spam emails), in bioinformatics (to compare gene sequences), and in quality control (to test whether a sample follows a hypothesized distribution).

In capture the flag events, multi language frequency analysis is sometimes used as a puzzle that requires the solver to recognize that the ciphertext is not in English. The hint is usually that the single-language attack produces a wrong answer with high confidence, which suggests that the language assumption is wrong.

The multi language frequency analysis is also a useful demonstration of the principle of using statistics to identify patterns. Modern machine learning algorithms use the same principle at a much larger scale, identifying patterns in high-dimensional data by comparing distributions. The chi-squared statistic is one of the simplest distribution comparison metrics, but the underlying idea is the same.

Conclusion

Multi language frequency analysis extends the classical single-language frequency attack to handle ciphertexts whose plaintext language is unknown. We built a frequency table library for four languages, computed the chi-squared statistic for each language and each Caesar shift, and identified the most likely combination. Next you should study the single language frequency attack (which is faster but assumes a specific language), the Kasiski examination (which attacks polyalphabetic ciphers), and the index of coincidence (which estimates the key length of polyalphabetic ciphers).