[Crittografia] Cifrario di Cesare

Oggi vediamo uno dei più antichi (e probabilmente conosciuti) sistemi di crittografia: il cifrario di Cesare!

Innanzitutto un pò di storia: Il cifrario di Cesare è effettivamente uno dei più antichi sistemi crittografici di cui si abbia traccia.

Deriva dall’ imperatore Giulio Cesare, e veniva utilizzato in ambito militare per scambiare messaggi con i dislocamenti delle sue truppe in tutta sicurezza: è infatti noto il fatto che i suoi nemici fossero analfabeti, quindi figuriamoci pensare solamente di riuscire ad interpretare un messaggio criptato.

Ed inoltre, nessun metodo di criptanalisi risulta da quel periodo e sembra quasi incredibile la potenza che ha avuto questo cifrario, nonostante la sua estrema semplicità.

Il cifrario di Cesare è un sistema di criptografia chiamato a sostituzione monoalfabetica: in pratica, ogni lettera dell’alfabeto viene fatta scorrere di una (o N) posizione/i.

Quindi, dal nostro alfabeto( italiano):

a,b,c,d,…z

Avremo:

z,a,b,c,….v

Essendo le lettere 26, si capisce che possiamo effettuare 26 traslazioni prima di ritornare alla configurazione iniziale.

Non a caso infatti, possiamo esprimere questo sistema di crittografia con una formula matematica: prima mettiamo in relazione biunivoca l’alfabeto con i numeri, dopodichè applichiamo:

C = (N + X) mod 26

mentre per decriptare:

D = (N – X) mod 26

Dove:

• N è la nostra chiave, ovvero lo spostamento,
• X invece è una lettera generica che farà parte della frase che vogliamo criptare,
• Mod 20 è proprio quello che dicevamo poco fà, grazie a lui contiamo in modulo 21.

Certo è chiaro che all’ epoca di Giulio Cesare certi inghippi matematici ancora non erano pensati, infatti per passare dal messaggio crittografato al testo in chiaro e vice-versa, si utilizzava un oggetto del genere:

Come è intuibile, se la nostra chiave è 5 basterà ruotare di 5 posizioni il cerchio più esterni per vedere immediatamente a cosa corrisponde ogni criptogramma.

Criptanalisi del Cifrario di Cesare

Ovvero: come possiamo trovare il testo in chiaro?

Ebbene ci possiamo trovare in due possibili soluzioni:

• L’ attaccante sà che è stato utilizzato un sistema di cifratura monoalfabetica ma non conosce quale,
• L’attaccante sà che è stato utilizzato un sistema di cifratura di Cesare.

Nel primo caso, all’attaccante basterà effettuare una analisi di frequenza: in pratica, sapendo che nella lingua italiana le lettere più comuni sono:

E, A, O, I, L, N, R, S, T

E le meno usate sono:

B, F, Q, Z

Allora, gli basterà appunto analizzare i criptogrammi per riuscire a stabilire in base alla ripetizione che lettere stanno osservando.

Il secondo metodo, forse più lungo ma sicuramente più semplice, si basa su un semplice attacco Brute Force: l’attaccante, tenenedo a mente la storia che abbiamo accennato poco del limite di 20 spostamenti, si farà una semplice lista dove di volta in volta proverà a ruotare di +1 il criptogramma che vuol decifrare:

Se per esempio abbiamo  la parola “emcq”, l’attaccante comincerà:

• emcq spostato di -1: dlbp Niente.
• emcq spostato di -2: ciao Trovato!

Perciò la chiave era 2.

Dove trovarlo

Al giorno d’oggi? Probabilmente, da nessuna parte. E’ infatti noto che questo sistema da 1000 anni a questa parte è diventato sempre meno sicuro, e quindi viene usato al massimo per gli indovinelli. Vedremo comunque in seguito, altri sistemi di criptazione derivati da questo.

Ad ogni modo, se volessimo provare ad implementarlo, sarebbe decisamente scomodo metterci a criptare un lungo messaggio a mano, ecco quindi che ci arriva in aiuto la programmazione 🙂

Implementazione in Python

Quì di seguito trovate la mia versione in Python: se volete, pure per esercizio, implementatelo nel linguaggio che conoscete e inviatecelo dalla pagina info & contatti 🙂

Phyton:

import string

def caesar_cypher(text,n):
    text = list(text)
    cod = []
    ret = ''
    for a in text: #Traduco il testo in codice Unicode
        if a.isalpha():
            c = ord(a)
            n = ((n + 26)%26)
            c += n          
            if c > 123:
                n = 97 +(c - 123)
                c =  n
            d = chr(c)
            ret += d
        else:
            ret += a
    return ret
print caesar_cypher('Ciao', 2)

Altra versione presa dai commenti meno intuitiva e meno robusta ( le lettere si trasformano in simboli anche e non in altre lettere):

def caesar_cypher():
    try:
        inp=raw_input("Inserire stringa: ")
    except:
        print("Errore!")
    try:
        key=input("Inserire chiave: ")
    except:
        print("Errore!")
    y=len(inp)
    print "La lunghezza della stringa e': ", y
    b=""
    for i in range(len(inp)):
        b += chr(ord(inp[i]) + key)
    print b

Java:

<

pre>/*
* @title CeaserCypher
* @description The Ceaser Cypher implemented in Java. Info: http://blog.informaticalab.com/crittografia-cifrario-di-cesare/
*/

public class CeaserCypher {
/*
* @param text Text to encrypt in CeaserCypher.
* @param key Value of the key to encrypt the text.
* @return Text Encrypted
*/
public static String crypt(String text, int key) {
String textCrypted = “”;
for (int i = 0; i < text.length(); i++) {
int ascii = (int) text.charAt(i);

        if (key > 23)
                    { 
                        while (key > 23)
                        {
                             key = (key % 23); //Se key >23, allora conto in modulo 23 finchè non ho un numero 123
                        }
                    }
                     newchar = 97+(newchar-123); //Se il risultato è >123 allora conto in modulo in modo da avere una lettera compresa fra 97<x