Szyfr Cezara: jak działa, kod w Pythonie i jak go złamać

Szyfr Cezara zamienia każdą literę na literę przesuniętą o stałą liczbę miejsc w alfabecie, więc nawet z polskim alfabetem uzupełnionym o Q, V i X ma tylko 34 klucze, które coś zmieniają, i da się go złamać w ułamku sekundy. Wystarczy sprawdzić wszystkie klucze albo policzyć, które litery w szyfrogramie występują najczęściej. W naszym teście program porównujący częstości liter z “Quo vadis” trafiał we właściwy klucz w 94 procentach prób już przy 20 literach szyfrogramu. Przy 5 literach mylił się częściej, niż trafiał. Kod w Pythonie, C++ i JavaScripcie z tego tekstu obsługuje ą, ę, ł i resztę polskich liter, których większość przykładów z alfabetem A–Z nie zna.

Spis treści

1. Definicja i wzór
2. Co pisze Swetoniusz
3. Szyfrowanie ręcznie
4. Polskie litery
5. Kod w Pythonie, C++ i JavaScripcie
6. Jak złamać szyfr
7. ROT13, Vigenère i szyfry harcerskie
8. Od Cezara do Enigmy
9. Matura z informatyki
10. Najczęstsze pytania

Szyfr Cezara: definicja i wzór

Szyfr Cezara to szyfr podstawieniowy, w którym każdą literę tekstu zastępuje się literą leżącą o stałą liczbę miejsc dalej w alfabecie. Tę liczbę nazywa się kluczem albo przesunięciem. Gdy przesunięcie wychodzi poza ostatnią literę, liczymy dalej od początku alfabetu, jak na tarczy zegara.

Jeśli ponumerujemy litery od zera, szyfrowanie i odszyfrowanie zapisuje się dwoma wzorami:

• E(x) = (x + k) mod n, gdzie x to numer litery, k to klucz, a n to liczba liter w alfabecie,
• D(y) = (y − k) mod n, czyli przesunięcie w drugą stronę.

Działanie mod to reszta z dzielenia. Opisujemy ją dokładniej przy algorytmie Euklidesa, który na resztach z dzielenia opiera się w całości. W szyfrze Cezara reszta pilnuje, żeby numer litery nie wyszedł poza alfabet.

Wynik zależy od tego, jaki alfabet przyjmiemy. W łacińskim alfabecie 26 liter przesunięcie o 3 zamienia A na D. W polskim alfabecie ta sama trójka zamienia A na C, bo po drodze stoją jeszcze Ą i B. Nadawca i odbiorca muszą więc uzgodnić klucz i alfabet.

Skąd nazwa: co o szyfrze Cezara pisze Swetoniusz

Nazwa pochodzi od opisu w “Żywotach cezarów” Swetoniusza, rzymskiego biografa z przełomu I i II wieku. W życiorysie Juliusza Cezara (rozdział 56) Swetoniusz pisze, że Cezar w listach do przyjaciół, gdy miał coś do przekazania w tajemnicy, “per notas scripsit”, czyli pisał szyfrem. Kto chciał taki list odczytać, miał według niego podstawiać “quartam elementorum litteram, id est D pro A”, czyli czwartą literę alfabetu, D w miejsce A, i tak samo pozostałe. To przesunięcie o 3.

W życiorysie Augusta (rozdział 88) ten sam autor podaje wariant z przesunięciem o jedno miejsce. Cesarz pisał B zamiast A, C zamiast B i tak dalej, a zamiast X stawiał podwójne A. Na końcu alfabetu August dopisywał więc dodatkowy znak. Oba życiorysy, Juliusza i Augusta, są po łacinie i w angielskim przekładzie w serwisie LacusCurtius Uniwersytetu Chicagowskiego. Swetoniusz opisuje, jak Cezar szyfru używał, i nie wspomina, kto go wymyślił.

Na zdjęciu wyróżniającym: portret Juliusza Cezara z Tusculum w Muzeum Starożytności w Turynie. Fot. Marie-Lan Taÿ Pamart, Wikimedia Commons, licencja CC BY 4.0, kadr.

Szyfrowanie i odszyfrowanie ręcznie: przykład z kluczem 3

Do ręcznego szyfrowania wystarczą dwa wiersze alfabetu, jeden pod drugim:

1. Wypisz alfabet, którego używacie, na przykład polski z Q, V i X.
2. Pod spodem wypisz ten sam alfabet przesunięty o klucz. Przy kluczu 3 dolny wiersz zaczyna się od C.
3. Każdą literę wiadomości znajdź w górnym wierszu i zastąp literą spod niej. Spacje i znaki interpunkcyjne przepisz bez zmian.
4. Odszyfrowanie robisz w drugą stronę: szukasz litery w dolnym wierszu i bierzesz tę nad nią.

Słowa Cezara przy przekraczaniu Rubikonu, które Swetoniusz zapisał jako “Iacta alea est”, po polsku “Kości zostały rzucone”, po zaszyfrowaniu kluczem 3 w polskim alfabecie wyglądają tak: “Mqvel aquwcńż taxeqóg”. W szyfrogramie pojawiają się Q i V, choć w tekście jawnym ich nie było. Tak działa alfabet z 35 literami: O przesunięte o 3 trafia na Q, a Ś na V.

Zamiast dwóch wierszy można zrobić tarczę z dwóch kół, które obracają się względem siebie. Ustawienie kół to klucz.

Polskie litery w szyfrze Cezara: alfabet 32 czy 35 liter

Polski alfabet ma 32 litery: a, ą, b, c, ć, d, e, ę, f, g, h, i, j, k, l, ł, m, n, ń, o, ó, p, r, s, ś, t, u, w, y, z, ź, ż. Taki sam zestaw podaje baza Unicode CLDR z danymi o językach dla programistów. Litery Q, V i X są tam na liście pomocniczej, obok liter z wyrazów obcych, takich jak ä czy ç.

Od wyboru alfabetu zależy liczba kluczy. Klucz 0 i klucz równy długości alfabetu niczego nie zmieniają, więc użytecznych kluczy jest zawsze o jeden mniej niż liter:

My przyjmujemy 35 liter, żeby szyfrować także słowa takie jak “Quo vadis”. Wielkie litery zostają wielkie, a spacje, cyfry i interpunkcja przechodzą bez zmian. To wygodne, ale zdradza długość słów, co ułatwia łamanie.

Popularny skrót z kursów programowania, czyli liczenie na kodach znaków, z polskimi literami nie działa. Litera a ma kod 97, z ma 122, ale ą ma kod 261, a ż 380, bo polskie litery leżą w innym bloku Unicode niż łacińskie. Szczegóły są w tekście o kodach ASCII i tabeli znaków. Dlatego w kodzie niżej numerem litery jest jej pozycja w napisie z alfabetem.

Frontend Master 2026 · Kodożercy

Pisz kod, nie tylko prompty

Frontend Master 2026 to pakiet sześciu kursów Kodożerców (HTML, CSS, JavaScript, Git) w polskim wideo z 12-miesięcznym dostępem. Fundamenty frontu od pierwszej linijki kodu do deploy.

Wchodzę w to →

Kod w Pythonie, C++ i JavaScripcie

Wszystkie trzy wersje robią to samo: szukają litery w napisie z alfabetem, przesuwają jej numer o klucz i biorą resztę z dzielenia przez 35. Każdy przykład uruchomiliśmy 17 października 2026 roku. Wyniki poniżej są skopiowane z konsoli.

Szyfr Cezara w Pythonie

ALFABET = "aąbcćdeęfghijklłmnńoópqrsśtuvwxyzźż"

def szyfruj(tekst, klucz):
    wynik = []
    for znak in tekst:
        mala = znak.lower()
        if mala in ALFABET:
            nowa = ALFABET[(ALFABET.index(mala) + klucz) % len(ALFABET)]
            wynik.append(nowa.upper() if znak.isupper() else nowa)
        else:
            wynik.append(znak)
    return "".join(wynik)

def odszyfruj(tekst, klucz):
    return szyfruj(tekst, -klucz)

szyfr = szyfruj("Kości zostały rzucone", 3)
print(szyfr)
print(odszyfruj(szyfr, 3))
print(szyfruj("Zażółć gęślą jaźń", 3))

Wynik w Pythonie 3.14.3:

Mqvel aquwcńż taxeqóg
Kości zostały rzucone
Acbrńę jhvnć łcąp

Odszyfrowanie to szyfrowanie kluczem ujemnym. W Pythonie to działa od ręki, bo operator % zwraca wynik ze znakiem dzielnika: -1 % 35 daje 34. Krótszą wersję da się zbudować na gotowej tabeli zamian z str.maketrans:

def szyfruj_tabela(tekst, klucz):
    k = klucz % len(ALFABET)
    przesuniety = ALFABET[k:] + ALFABET[:k]
    tabela = str.maketrans(ALFABET + ALFABET.upper(), przesuniety + przesuniety.upper())
    return tekst.translate(tabela)

Wywołanie szyfruj_tabela("Kości zostały rzucone", 3) zwraca ten sam szyfrogram co pierwsza wersja. Przy polskich literach w plikach pamiętaj o kodowaniu UTF-8, o którym piszemy przy zmianach w Pythonie 3.15.

Szyfr Cezara w C++

W C++ std::string przechowuje bajty. W UTF-8 polska litera zajmuje dwa bajty, dlatego w przykładzie używamy std::u32string, w którym każda litera to jeden element. Wynik zamieniamy z powrotem na UTF-8 do wypisania:

#include <iostream>
#include <string>

const std::u32string ALFABET = U"aąbcćdeęfghijklłmnńoópqrsśtuvwxyzźż";
const std::u32string WIELKIE = U"AĄBCĆDEĘFGHIJKLŁMNŃOÓPQRSŚTUVWXYZŹŻ";

// zamiana tekstu UTF-32 na UTF-8, żeby wypisać go w konsoli
std::string utf8(const std::u32string& tekst) {
    std::string wynik;
    for (char32_t z : tekst) {
        if (z < 0x80) {
            wynik += static_cast<char>(z);
        } else if (z < 0x800) {
            wynik += static_cast<char>(0xC0 | (z >> 6));
            wynik += static_cast<char>(0x80 | (z & 0x3F));
        } else {
            wynik += static_cast<char>(0xE0 | (z >> 12));
            wynik += static_cast<char>(0x80 | ((z >> 6) & 0x3F));
            wynik += static_cast<char>(0x80 | (z & 0x3F));
        }
    }
    return wynik;
}

std::u32string szyfruj(const std::u32string& tekst, int klucz) {
    const int n = static_cast<int>(ALFABET.size());
    std::u32string wynik;
    for (char32_t z : tekst) {
        auto i = ALFABET.find(z);
        auto j = WIELKIE.find(z);
        if (i != std::u32string::npos) {
            wynik += ALFABET[((static_cast<int>(i) + klucz) % n + n) % n];
        } else if (j != std::u32string::npos) {
            wynik += WIELKIE[((static_cast<int>(j) + klucz) % n + n) % n];
        } else {
            wynik += z;
        }
    }
    return wynik;
}

int main() {
    std::u32string szyfr = szyfruj(U"Kości zostały rzucone", 3);
    std::cout << utf8(szyfr) << "\n";
    std::cout << utf8(szyfruj(szyfr, -3)) << "\n";
    std::cout << -1 % 35 << " " << ((-1 % 35) + 35) % 35 << "\n";
}

Wynik po kompilacji g++ -std=c++17 (GCC 14.4.0):

Mqvel aquwcńż taxeqóg
Kości zostały rzucone
-1 34

Ostatnia linijka pokazuje pułapkę. W C++ dzielenie liczb całkowitych obcina wynik w stronę zera, więc według cppreference reszta ma znak dzielnej i -1 % 35 daje −1, podczas gdy Python zwraca 34. Przy odszyfrowaniu kluczem ujemnym numer litery wyszedłby wtedy poza napis. Zapis ((x % n) + n) % n zawsze daje liczbę od 0 do n − 1. Liczby 0x80, 0xC0 i 0x3F w funkcji utf8 to maski bitowe zapisane szesnastkowo, czyli w systemie liczbowym o podstawie 16.

Wersja w JavaScripcie

const ALFABET = "aąbcćdeęfghijklłmnńoópqrsśtuvwxyzźż";

function szyfruj(tekst, klucz) {
  const n = ALFABET.length;
  return [...tekst].map((znak) => {
    const mala = znak.toLowerCase();
    const i = ALFABET.indexOf(mala);
    if (i === -1) return znak;
    const nowa = ALFABET[((i + klucz) % n + n) % n];
    return znak === mala ? nowa : nowa.toUpperCase();
  }).join("");
}

const szyfr = szyfruj("Kości zostały rzucone", 3);
console.log(szyfr);
console.log(szyfruj(szyfr, -3));
console.log(-1 % 35, ((-1 % 35) + 35) % 35);
console.log(ALFABET[(0 - 3) % 35]);

Wynik w Node.js 22.11.0:

Mqvel aquwcńż taxeqóg
Kości zostały rzucone
-1 34
undefined

JavaScript ma tę samą pułapkę co C++. Według MDN reszta zawsze przyjmuje znak dzielnej. Odwołanie do litery o numerze −3 bez żadnego błędu zwraca undefined. W wersji bez poprawki takie litery po cichu znikają przy łączeniu napisu przez join, a przy wielkiej literze wywołanie toUpperCase() kończy się błędem TypeError. Wszystkie polskie litery mieszczą się w jednym znaku UTF-16, więc rozbicie napisu przez [...tekst] działa bez dodatkowych bibliotek.

Jak złamać szyfr Cezara

Taki szyfr łamie się na dwa sposoby: siłą, sprawdzając wszystkie 34 klucze, albo analizą częstości liter, która wskazuje klucz automatycznie. Pierwszy wymaga człowieka, który przeczyta wyniki. Drugi działa bez czytania, ale potrzebuje dłuższego tekstu.

Metoda siłowa: wszystkie klucze po kolei

Przy 34 kluczach wystarczy pętla, która odszyfruje wiadomość każdym z nich. Używamy funkcji szyfruj z wersji w Pythonie:

szyfrogram = "Azxbsivqn zżfę uxąlqn x ądqlqn"
for klucz in range(1, len(ALFABET)):
    print(klucz, szyfruj(szyfrogram, -klucz))

Fragment wyniku (pełny ma 34 wiersze):

9 Trpvłbokf rśżź ńpudkf p uykdkf
10 Śqóuląńję qsźz nótćję ó txjćję
11 Spotkanie przy moście o świcie
12 Róńśjżmhd óqyx łńsbhd ń svhbhd
13 Qonsiźłgć opxw lnrągć n rugągć

Wiadomość ukryta kluczem 11 wyskakuje od razu, bo tylko jeden wiersz jest po polsku. Komputer sprawdzi tak 34 klucze w ułamku sekundy, a człowiek z kartką w kilkanaście minut.

Analiza częstości liter w polskim tekście

Analiza częstości korzysta z tego, że w każdym języku niektóre litery występują znacznie częściej niż inne. Policzyliśmy to na “Quo vadis” Henryka Sienkiewicza z Wolnych Lektur (utwór w domenie publicznej, 872 968 liter). Najczęstsze są I (9,5 procent), A (8,1), E (7,6), O (6,8) i Z (6,5). Po szyfrowaniu te same proporcje przesuwają się o klucz. Po szyfrowaniu kluczem 3 najwyższe słupki stoją przy L, C, G i Q, a odległość od I do L zdradza przesunięcie.

Automatyczny wybór klucza testem chi-kwadrat

Program może sam ocenić, które odszyfrowanie najbardziej przypomina polski tekst. Dla każdego klucza liczy, ile razy wystąpiła każda litera, i porównuje to z liczbą oczekiwaną według częstości z “Quo vadis”. Miarą różnicy jest suma kwadratów odchyleń podzielonych przez wartość oczekiwaną, czyli statystyka chi-kwadrat. Najmniejsza suma wskazuje klucz.

from collections import Counter

def wzorzec_czestosci(tekst):
    litery = [z for z in tekst.lower() if z in ALFABET]
    licznik = Counter(litery)
    # +1, żeby żadna litera nie miała zerowej częstości
    return [(licznik[z] + 1) / (len(litery) + len(ALFABET)) for z in ALFABET]

def chi_kwadrat(tekst, wzorzec):
    litery = [z for z in tekst.lower() if z in ALFABET]
    n, licznik = len(litery), Counter(litery)
    return sum((licznik[z] - n * p) ** 2 / (n * p) for z, p in zip(ALFABET, wzorzec))

def zlam(szyfrogram, wzorzec):
    wyniki = {k: chi_kwadrat(szyfruj(szyfrogram, -k), wzorzec) for k in range(len(ALFABET))}
    return min(wyniki, key=wyniki.get)

wzorzec = wzorzec_czestosci(open("quo-vadis.txt", encoding="utf-8").read())
szyfrogram = szyfruj("Mimo posępne wróżby ludzi trzeźwo patrzących na rzeczy, sklep galanteryjny "
                     "pod firmą J. Mincel i S. Wokulski nie tylko nie upadł, ale nawet robił dobre interesa.", 7)
klucz = zlam(szyfrogram, wzorzec)
print(szyfrogram)
print("Klucz:", klucz)
print(szyfruj(szyfrogram, -klucz))
krotki = szyfruj("Kup chleb", 7)
k = zlam(krotki, wzorzec)
print("Krótki tekst, klucz:", k, "->", szyfruj(krotki, -k))

Plik quo-vadis.txt to wersja tekstowa powieści pobrana z Wolnych Lektur. Wynik:

Rńrt vtylvsk ąxuegc pżjćń źxćkdąt vęźxćfhchn sę xćkhćc, yópkv mępęsźkxcosc vtj łńxrf O. Rńshkp ń Y. Ątóżpyóń sńk źcpót sńk żvęjq, ępk sęąkź xtgńq jtgxk ńsźkxkyę.
Klucz: 7
Mimo posępne wróżby ludzi trzeźwo patrzących na rzeczy, sklep galanteryjny pod firmą J. Mincel i S. Wokulski nie tylko nie upadł, ale nawet robił dobre interesa.
Krótki tekst, klucz: 31 -> Scz lpśnk

Zdanie z “Lalki” Bolesława Prusa program złamał bez trudu. Dwa słowa “Kup chleb” już nie: w ośmiu literach jest za mało powtórzeń, żeby statystyka miała z czego wybierać. Sprawdziliśmy tę granicę na tysiącu losowych fragmentów pierwszego tomu “Lalki” dla każdej długości, z losowymi kluczami. Przy 5 literach test trafiał w 45 procentach prób, przy 10 literach w 77, przy 20 w 94, a od 50 liter prawie zawsze. Krótką wiadomość i tak przeczyta człowiek metodą siłową, bo spośród 34 wierszy tylko jeden będzie miał sens.

ROT13, szyfr Vigenère’a i szyfry harcerskie

Ten szyfr ma kilku krewnych, których łatwo pomylić, bo wszystkie zamieniają litery według prostej reguły.

ROT13 przesuwa litery o 13 w alfabecie z 26 liter, czyli dokładnie o połowę. Dlatego drugie zastosowanie przywraca tekst jawny. Python ma go wbudowanego:

import codecs

print(codecs.encode("Ave Caesar", "rot13"))
print(codecs.encode(codecs.encode("Ave Caesar", "rot13"), "rot13"))

Wynik to Nir Pnrfne, a potem z powrotem Ave Caesar. W polskim alfabecie z 35 liter takiej symetrycznej wersji nie ma, bo 35 jest liczbą nieparzystą. Przy 32 literach rolę ROT13 pełniłoby przesunięcie o 16.

Szyfr Vigenère’a

Szyfr Vigenère’a działa jak przesunięcie Cezara, tyle że klucz zmienia się co literę według hasła. Pierwsza litera przesuwa się o pozycję pierwszej litery hasła, druga o pozycję drugiej i tak dalej. Ta sama litera jawna zamienia się więc w różne litery szyfrogramu, a prosta analiza częstości przestaje działać. Taki szyfr z hasłem opisał w 1553 roku włoski kryptolog Giovan Battista Bellaso. Nazwisko Blaise’a de Vigenère’a przypisano mu dopiero w XIX wieku. Wersja na naszej funkcji szyfruj:

def vigenere(tekst, haslo, kierunek=1):
    wynik, j = [], 0
    for znak in tekst:
        if znak.lower() in ALFABET:
            przesuniecie = ALFABET.index(haslo[j % len(haslo)])
            wynik.append(szyfruj(znak, kierunek * przesuniecie))
            j += 1
        else:
            wynik.append(znak)
    return "".join(wynik)

szyfr = vigenere("Kości zostały rzucone", "rubikon")
print(szyfr)
print(vigenere(szyfr, "rubikon", -1))

Wynik: Ąiuls mąjńbtg ęlłxpvo, a po odszyfrowaniu znów Kości zostały rzucone.

Szyfr harcerski gaderypoluki

Gaderypoluki to szyfr podstawieniowy, w którym litery zamieniają się parami według klucza GA-DE-RY-PO-LU-KI. Litery spoza klucza zostają bez zmian. W Pythonie to jedna tabela zamian:

GADERYPOLUKI = str.maketrans("gaderypolukiGADERYPOLUKI", "agedyropulikAGEDYROPULIK")
print("Zbiórka o siódmej".translate(GADERYPOLUKI))

Wynik to Zbkóyig p skóemdj. Ponowne użycie tej samej tabeli przywraca tekst, tak jak w ROT13.

Od szyfru Cezara do Enigmy i HTTPS

Szyfr z jednym przesunięciem przegrywa, bo każda litera zawsze zamienia się w tę samą, a do sprawdzenia jest tylko kilkadziesiąt kluczy. Kolejne pokolenia szyfrów usuwały tę słabość. Vigenère zmieniał przesunięcie co literę według hasła. W Enigmie każde naciśnięcie klawisza przesuwało wirnik, więc ta sama litera za każdym razem zamieniała się w inną. Polscy kryptolodzy złamali ją matematyką, za pomocą teorii permutacji.

Dzisiejsze szyfrowanie w HTTPS i komunikatorach opiera się na publicznie opisanych algorytmach, a tajny jest tylko klucz. W RSA bezpieczeństwo opiera się na tym, że iloczyn dwóch dużych liczb pierwszych bardzo trudno rozłożyć na czynniki, co opisujemy przy liczbach pierwszych w szyfrowaniu RSA. O tym, jak przeglądarka sprawdza tożsamość serwera, piszemy przy certyfikatach SSL. Przygotowania do czasów komputerów kwantowych opisujemy w tekstach o szyfrowaniu postkwantowym w Google Meet i o Q-Day. Przesuwanie liter nie nadaje się do ochrony haseł ani danych, do tego służą menedżery haseł i weryfikacja dwuetapowa.

Szyfrowanie metodą Cezara w podstawie programowej i na maturze

Ten szyfr jest w obowiązkowym programie informatyki w liceum i technikum. Podstawa programowa z 2018 roku wymienia wśród algorytmów na tekstach, które uczeń stosuje w zakresie podstawowym, “szyfrowania tekstu metodą Cezara i przestawieniową”. Zakres rozszerzony, zdawany na maturze rozszerzonej, obejmuje wszystkie wymagania podstawowe. Zmiany podstawy z kolejnych lat, aż do tej z 1 września 2026 roku, tego zapisu nie ruszały.

W zadaniu zawsze sprawdź, jaki alfabet podaje treść, bo od tego zależy wynik. Kod z tego tekstu przerobisz na alfabet A–Z, zmieniając jedną stałą ALFABET. Pętlę szyfrującą warto najpierw rozrysować jako schemat blokowy, jeśli zadanie tego wymaga. Uczniów technikum informatycznego i programistycznego czeka dodatkowo egzamin zawodowy z tworzenia stron i baz danych, który opisujemy w poradniku o egzaminie INF.03.

Najczęstsze pytania

Czy szyfr Cezara jest bezpieczny?

Nie. Ma tylko 34 klucze przy polskim alfabecie z Q, V i X, a komputer sprawdza je wszystkie w ułamku sekundy. Dłuższy tekst zdradza też częstość liter. Szyfr nadaje się do nauki programowania i zabaw. Do ochrony danych się nie nadaje.

Ile kluczy ma szyfr Cezara?

O jeden mniej, niż liter ma alfabet: 25 przy alfabecie A–Z, 31 przy 32 polskich literach i 34 przy polskim alfabecie z Q, V i X. Klucz 0 niczego nie zmienia, a klucz większy od długości alfabetu działa tak samo jak jego reszta z dzielenia przez tę długość.

Jak odszyfrować wiadomość bez klucza?

Odszyfruj wiadomość wszystkimi kluczami po kolei i wybierz jedyny wiersz, który ma sens. Przy dłuższym tekście klucz wskaże też analiza częstości liter: najczęstsza litera szyfrogramu to zwykle zaszyfrowane I, A albo E.

Czym różni się szyfr podstawieniowy od przestawieniowego?

Szyfr podstawieniowy zamienia litery na inne, a ich kolejność zostaje. Takie są szyfry Cezara, Vigenère’a i gaderypoluki. Szyfr przestawieniowy zostawia te same litery, ale zmienia ich kolejność, na przykład zapisuje tekst w wierszach tabeli i odczytuje kolumnami.

Podsumowanie

Szyfr Cezara przesuwa każdą literę o stałą liczbę miejsc w alfabecie według wzoru E(x) = (x + k) mod n. Swetoniusz opisał przesunięcie o 3 w listach Cezara i o 1 u Augusta. Z polskim alfabetem z Q, V i X szyfr ma 34 klucze, a wynik zależy od tego, jaki alfabet uzgodnią obie strony. W Pythonie reszta z dzielenia zachowuje się poprawnie dla kluczy ujemnych. W C++ i JavaScripcie trzeba ją poprawić wzorem ((x % n) + n) % n. Szyfr łamie się wszystkimi kluczami albo analizą częstości liter. Według naszego testu na “Quo vadis” i “Lalce” automatyczny wybór klucza trafia w 94 procentach przy 20 literach i prawie zawsze od 50. Do ochrony danych służą dziś publicznie opisane algorytmy z tajnym kluczem, takie jak te w HTTPS.

Mateusz Wojdalski

Specjalista SEO i content marketingu w Devstock. Zajmuję się strategią treści, automatyzacją procesów marketingowych i wdrożeniami AI w codziennej pracy. Badam nowe narzędzia, adaptuję je do realnych zadań i piszę o tym, co faktycznie działa.