Cifra de César¶

A Cifra de César é um dos métodos de criptografia mais antigos e simples, pertencente à categoria de cifras de substituição por deslocamento. Foi atribuída a Júlio César, que a utilizava para comunicar-se secretamente com seus generais durante as Guerras Gálicas (século I a.C.).

Conceito Básico¶

A cifra funciona substituindo cada letra do texto original por outra letra que está um número fixo de posições à frente no alfabeto. Por exemplo, com um deslocamento de 3:

A → D
B → E
C → F
...
X → A (wrap-around)
Y → B
Z → C

Exemplo Prático¶

Com uma chave de deslocamento k = 3:

Letra Original	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
Letra Criptografada	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z	A	B	C

Texto: "HELLO WORLD" Criptografado (k=3): "KHOOR ZRUOG"

Implementação em Java¶

public class CaesarCipher {
    private final int key; // Chave de deslocamento

    public CaesarCipher(int key) {
        this.key = key % 26;
        if (this.key < 0) {
            this.key += 26;
        }
    }

    /**
     * Criptografa um texto usando a Cifra de César.
     */
    public String encrypt(String plaintext) {
        StringBuilder ciphertext = new StringBuilder();

        for (char c : plaintext.toCharArray()) {
            if (Character.isLetter(c)) {
                char base = Character.isUpperCase(c) ? 'A' : 'a';
                int offset = c - base;
                char encryptedChar = (char) (base + (offset + key) % 26);
                ciphertext.append(encryptedChar);
            } else {
                ciphertext.append(c); // Mantém caracteres não-alfabéticos inalterados
            }
        }

        return ciphertext.toString();
    }

    /**
     * Descriptografa um texto criptografado.
     */
    public String decrypt(String ciphertext) {
        return encrypt(ciphertext, -key); // Usa o mesmo método com chave negativa
    }
}

Análise de Segurança¶

Pontos Fracos¶

Espaço de Chave Pequeno: Apenas 26 possibilidades (uma para cada letra do alfabeto), tornando-a vulnerável a ataques por força bruta.
Análise de Frequência: Como é uma substituição monoalfabética, preserva as frequências relativas das letras. Em inglês:
E é a letra mais frequente (~12.7%)
T, A, O, I, N são também muito comuns

Um atacante pode analisar o texto criptografado e identificar padrões de frequência para quebrar a cifra.

Exemplo de Análise de Frequência¶

public class FrequencyAnalysis {
    public static void analyze(String text) {
        int[] frequency = new int[26];

        for (char c : text.toCharArray()) {
            if (Character.isLetter(c)) {
                char lower = Character.toLowerCase(c);
                frequency[lower - 'a']++;
            }
        }

        // Ordenar por frequência e mostrar as 5 mais comuns
        int[] sorted = Arrays.copyOf(frequency, 26);
        Arrays.sort(sorted);

        System.out.println("Top 5 letras mais frequentes:");
        for (int i = 25; i >= 20 && i >= 0; i--) {
            char letter = (char) ('a' + i);
            double percentage = sorted[i] * 100.0 / text.length();
            System.out.printf("%c: %.1f%% (%d ocorrências)%n", 
                letter, percentage, sorted[i]);
        }
    }
}

Cifra de Vigenère (Generalização)¶

A Cifra de Vigenère é uma evolução da Cifra de César que usa múltiplos deslocamentos baseados em uma palavra-chave. Isso a torna mais resistente à análise de frequência simples.

Como Funciona¶

Com a chave "KEY" e o texto "ATTACK AT DAWN":

Posição	0	1	2	3	4	5	6	7	8	9
Texto	A	T	T	A	C	K	(A)	T	D	A
Chave	K	E	Y	K	E	Y	K	E	Y	K
Valor	0	19	19	0	2	10	0	19	3	0
+ Chave	10	4	24	10	4	24	10	4	25	10
Resultado	R	Y	C	K	G	Y	K	W	Z	K

Criptograma: "RYCKGYKWZK"

Implementação em Java¶

public class VigenereCipher {
    private final String key;

    public VigenereCipher(String key) {
        this.key = normalizeKey(key);
    }

    private String normalizeKey(String key) {
        return key.toUpperCase().replaceAll("[^A-Z]", "");
    }

    /**
     * Criptografa um texto usando a Cifra de Vigenère.
     */
    public String encrypt(String plaintext) {
        StringBuilder ciphertext = new StringBuilder();

        for (int i = 0; i < plaintext.length(); i++) {
            char c = plaintext.charAt(i);
            if (Character.isLetter(c)) {
                int textValue = Character.toLowerCase(c) - 'a';
                int keyIndex = i % key.length();
                int keyValue = key.charAt(keyIndex) - 'a';

                char encryptedChar = (char) ('A' + (textValue + keyValue) % 26);
                ciphertext.append(encryptedChar);
            } else {
                ciphertext.append(c);
            }
        }

        return ciphertext.toString();
    }

    /**
     * Descriptografa um texto criptografado.
     */
    public String decrypt(String ciphertext) {
        StringBuilder plaintext = new StringBuilder();

        for (int i = 0; i < ciphertext.length(); i++) {
            char c = ciphertext.charAt(i);
            if (Character.isLetter(c)) {
                int cipherValue = Character.toLowerCase(c) - 'a';
                int keyIndex = i % key.length();
                int keyValue = key.charAt(keyIndex) - 'a';

                char decryptedChar = (char) ('A' + (cipherValue - keyValue + 26) % 26);
                plaintext.append(decryptedChar);
            } else {
                plaintext.append(c);
            }
        }

        return plaintext.toString();
    }
}

Ataques à Cifra de Vigenère¶

Análise de Coincidência de Índice (Kasiski)¶

Este método identifica repetições no criptograma para estimar o comprimento da chave:

Encontrar todas as ocorrências de sequências repetidas no texto cifrado
Calcular as distâncias entre essas ocorrências
O MDC (Máximo Divisor Comum) dessas distâncias revela o comprimento provável da chave

Exemplo¶

Criptograma: "KHOOR ZRUOG" com chave "HELLO"

Se encontrarmos repetições em posições 0, 15 e 30, o MDC(15, 30) = 15 sugere que a chave tem comprimento 15 ou um divisor de 15.

Aplicações Históricas e Modernas¶

Histórico¶

Usada por militares europeus durante séculos
Considerada inviolável até o século XIX
Quebrada pelos franceses na Guerra Franco-Prussiana (1870) usando análise de frequência

Uso Moderno¶

Educativo: Excelente para ensinar conceitos básicos de criptografia
Steganografia: Usada em alguns sistemas modernos como camada adicional de segurança
Cifras Polialfabéticas Modernas: Base para algoritmos mais complexos como Enigma e AES

Conclusão¶

A Cifra de César e Vigenère são fundamentais para entender a evolução da criptografia:

César: Introduz o conceito de substituição sistemática
Vigenère: Mostra como múltiplos deslocamentos podem aumentar a segurança

Embora inseguras para uso moderno, elas fornecem uma base sólida para compreender conceitos mais avançados como: - Substituição monoalfabética vs. polialfabética - Análise de frequência - Espaços de chave e complexidade computacional

Para proteção real de dados hoje, utilize algoritmos modernos como AES (Criptografia Simétrica) ou RSA/ECC (Criptografia Assimétrica).