Szyfr Cezara (szyfr przesuwający) jest jednym z najstarszych znanych szyfrów. Jest on zbudowany na zasadzie szyfru podstawieniowego gdzie każda litera, tekstu niezaszyfrowanego zastępowana jest oddaloną od niej o stałą liczbę pozycji w alfabecie inną literą. W szyfrze Cezara nie rozróżnia się dużych i małych liter.
Obecnie Szyfr Cezara nie gwarantuje żadnego bezpieczeństwa.
Zasada działania Szyfru Cezara jest bardzo prosta:

Każdą literę tekstu niezaszyfrowanego zastępujemy inną przesuniętą względem litery kodowanej o stałą liczbę pozycji w alfabecie. Na przykład dla litery „a” (kod ASCII 97) przy przesunięciu o 2, literą kodowaną będzie „c” (kod ASCII 99) itd.
Przeanalizujmy prosty program szyfrujący szyfrem Cezara. Aplikacja została napisana w języku C#:
using System;
class Program
{
public static void Main()
{
Console.WriteLine("Proszę wciskać dowolne klawisze.");
ConsoleKeyInfo keyInfo;
do
{
keyInfo = Console.ReadKey(true);
if (keyInfo.KeyChar >= 97 && keyInfo.KeyChar <= 122)
{
char znak = (char)(((keyInfo.KeyChar - 97 + 2) % 26) + 97);
Console.WriteLine(znak);
}
} while (keyInfo.Key != ConsoleKey.Escape);
}
}Głównym elementem programu, który odpowiedzialny jest za szyfrowanie jest ten fragment:
char znak = (char)(((keyInfo.KeyChar - 97 + 2) % 26) + 97);Działa on w następujący sposób:
- Najpierw pobieramy kod ASCII wprowadzonego znaku (
keyInfo.KeyChar), - Następnie odejmujemy 97 (kod ASCII litery „a”), aby zamienić literę na jej pozycję w alfabecie (0-25),
- do pozycji dodajemy wartość przesunięcia (tutaj: 2) i wykonujemy dzielenie modulo 26, czyli przez liczbę liter alfabetu – dzięki temu koniec alfabetu „zawija się” na jego początek,
- na końcu dodajemy z powrotem 97, aby otrzymać kod ASCII zaszyfrowanej litery.
Dzięki tak przygotowanemu algorytmowi każda litera zostanie odpowiednio zakodowana.
Szyfr Cezara w C++:
#include <iostream>
#include <string>
using namespace std;
void szyfrowanie(string &tekst)
{
int dlugosc = tekst.length();
for(int i=0;i<dlugosc;i++)
tekst[i] = (char)(((tekst[i] - 97 + 2) % 26) + 97);
}
int main() {
string tekst;
cout << "Podaj tekst:n";
cin >> tekst;
szyfrowanie(tekst);
cout << "Po zaszyfrowaniu:n";
cout << tekst;
return 0;
}Szyfr Cezara w Pythonie
Dla kompletu ta sama zasada zapisana w Pythonie. Tym razem przesunięcie przekazujemy jako parametr, obsługujemy też duże litery i pomijamy znaki, które nie są literami (spacje, cyfry, znaki interpunkcyjne):
def szyfruj(tekst, przesuniecie):
wynik = ""
for znak in tekst:
if znak.isalpha():
baza = ord('a') if znak.islower() else ord('A')
wynik += chr((ord(znak) - baza + przesuniecie) % 26 + baza)
else:
wynik += znak # spacje, cyfry itd. zostawiamy bez zmian
return wynik
print(szyfruj("Ala ma kota", 3)) # Dod pd nrwdDeszyfrowanie
Odszyfrowanie jest banalnie proste. Wystarczy przesunąć litery w drugą stronę, czyli o tę samą wartość ze znakiem minus. Możemy więc wykorzystać tę samą funkcję:
def deszyfruj(tekst, przesuniecie):
return szyfruj(tekst, -przesuniecie)
print(deszyfruj("Dod pd nrwd", 3)) # Ala ma kotaJak łamie się szyfr Cezara?
Jak wspomnieliśmy na początku, dziś szyfr Cezara nie daje żadnego bezpieczeństwa. Powód jest prosty. Przesunięć jest tylko 25, więc szyfr można złamać w kilka chwil, nawet bez znajomości klucza. Służą do tego dwie klasyczne metody.
Atak siłowy (brute force) polega po prostu na sprawdzeniu wszystkich możliwych przesunięć i wybraniu tego, które daje sensowny tekst:
szyfrogram = "Dod pd nrwd"
for przesuniecie in range(1, 26):
print(przesuniecie, "->", deszyfruj(szyfrogram, przesuniecie))
# jedno z 25 wyswietlen bedzie czytelnym tekstem: "Ala ma kota"Analiza częstości to metoda sprytniejsza, przydatna zwłaszcza przy długich tekstach. W każdym języku niektóre litery występują znacznie częściej niż inne (w polskim są to m.in. „a”, „i”, „o”, „e”, w angielskim „e”). Wystarczy więc policzyć, która litera pojawia się w szyfrogramie najczęściej, założyć, że odpowiada najczęstszej literze danego języka, i z tej różnicy odczytać przesunięcie. To właśnie dlatego proste szyfry podstawieniowe, mimo ogromnej liczby kombinacji, są w praktyce łatwe do złamania, a bezpieczeństwo współczesnej kryptografii opiera się na zupełnie innych fundamentach matematycznych.
Szyfr Cezara w Javie
Ta sama para funkcji w Javie. Dodatek + 26 w wyrażeniu zabezpiecza deszyfrowanie: w Javie reszta z dzielenia liczby ujemnej jest ujemna, więc bez niego przesunięcie wstecz wychodziłoby poza alfabet:
public class Main {
public static String szyfruj(String tekst, int przesuniecie) {
StringBuilder wynik = new StringBuilder();
for (char znak : tekst.toCharArray()) {
if (Character.isLetter(znak)) {
char baza = Character.isLowerCase(znak) ? 'a' : 'A';
wynik.append((char) (((znak - baza + przesuniecie) % 26 + 26) % 26 + baza));
} else {
wynik.append(znak); // spacje, cyfry itd. bez zmian
}
}
return wynik.toString();
}
public static String deszyfruj(String tekst, int przesuniecie) {
return szyfruj(tekst, -przesuniecie);
}
public static void main(String[] args) {
System.out.println(szyfruj("Ala ma kota", 3)); // Dod pd nrwd
System.out.println(deszyfruj("Dod pd nrwd", 3)); // Ala ma kota
}
}


// brak komentarzy — bądź pierwszy