Klasa 4 · rozdział 7 · lekcje 40–45 · II okres

Szyfrowanie

Cezar przesuwa litery. Podstawieniowy wymienia je według klucza. Przestawieniowy zostawia te same litery i zmienia kolejność. Wspólna baza Szyfr ma szyfruj i deszyfruj. Poza zakresem zostają RSA i inne szyfry z kluczem publicznym.

Po tym rozdziale powinieneś umieć

  • nazwać tekst jawny, szyfrogram i klucz;
  • zaszyfrować i odszyfrować Cezara z zawijaniem alfabetu;
  • zastosować podstawienie 26 liter i przestawienie parami;
  • zostawić znaki spoza a–z i A–Z bez zmian;
  • ująć szyfr w klasie z metodami, bez cin w środku;
  • porównać siłę szkolną: Cezar ma 25 sensownych kluczy, podstawienie — znacznie więcej.

1. Tekst jawny, szyfr, klucz

Tekst jawny to wiadomość przed zaszyfrowaniem. Szyfrogram to wynik. Klucz mówi, jak przekształcić. Deszyfrowanie tym samym kluczem (albo kluczem wyliczonym z niego) ma oddać tekst jawny. Na lekcji alfabet to 26 liter łacińskich, osobno małe i wielkie. Cyfry, spacje i polskie znaki zostają bez zmian — takie jest ustalenie tego podręcznika.

Dwie rodziny. Podstawienie zmienia która litera stoi na danym miejscu (Cezar jest jego szczególnym przypadkiem: każda litera idzie o stałą liczbę pozycji). Przestawienie zmienia gdzie litera stoi, a zestaw liter zostaje ten sam.

2. Szyfr Cezara

Klucz to przesunięcie 0…25. Litera c idzie na pozycję (c - 'a' + k) % 26 w swoim alfabecie. Klucz 1: Abc → Bcd. Klucz 0 nic nie zmienia. Deszyfrowanie to przesunięcie o 26 - (k % 26), albo o -k po sprowadzeniu reszty do 0…25.

char przesun(char c, int k) {
    k %= 26;
    if (k < 0) k += 26;
    if (c >= 'a' && c <= 'z')
        return 'a' + (c - 'a' + k) % 26;
    if (c >= 'A' && c <= 'Z')
        return 'A' + (c - 'A' + k) % 26;
    return c;
}

string cezar(const string& tekst, int k) {
    string w = tekst;
    for (int i = 0; i < (int)w.size(); i++)
        w[i] = przesun(w[i], k);
    return w;
}

cezar("Abc z!", 1) → Bcd a!. Wykrzyknik i spacja stoją. cezar(cezar("Abc z!", 1), -1) wraca do Abc z!. Pusty napis zostaje pusty. Klucz 27 działa jak 1, bo k % 26.

Atak siłowy na Cezara Sensownych przesunięć jest 25 (zero nic nie robi). Pętla 1…25 wypisuje wszystkie szyfrogramy. To ćwiczenie na celujący, nie „łamanie RSA”. Pokazuje, czemu stałe przesunięcie jest słabe: mało kluczy i widać powtarzalny wzór.

3. Szyfr podstawieniowy

Klucz to 26 liter — obraz alfabetu. Pozycja 0 mówi, na co idzie a, pozycja 1 — na co idzie b. Wielkie litery idą tym samym obrazem, z zachowaniem wielkości. Deszyfrowanie szuka litery w kluczu i wraca do pozycji w alfabecie. Klucz musi być permutacją: każda litera dokładnie raz, inaczej deszyfrowanie jest niejednoznaczne.

string podstaw(const string& tekst, const string& klucz, bool szyfruj) {
    string w = tekst;
    for (int i = 0; i < (int)w.size(); i++) {
        char c = w[i];
        bool wielka = c >= 'A' && c <= 'Z';
        char mala = wielka ? c - 'A' + 'a' : c;
        if (mala < 'a' || mala > 'z') continue;
        int poz;
        if (szyfruj) poz = mala - 'a';
        else {
            poz = (int)klucz.find(mala);
            if (poz < 0) continue;
        }
        char n = szyfruj ? klucz[poz] : char('a' + poz);
        w[i] = wielka ? n - 'a' + 'A' : n;
    }
    return w;
}

Klucz qwertyuiopasdfghjklzxcvbnm (26 znaków, każda litera raz). a idzie na q, b na w. ab → qw. Deszyfrowanie szuka q w kluczu (pozycja 0) i wraca do a. Cezar z kluczem 1 da się zapisać jako podstawienie bcdefghijklmnopqrstuvwxyza — jeden mechanizm, szczególny klucz.

4. Szyfr przestawieniowy

Litery się nie zmieniają, zmieniają się miejsca. Wersja z lekcji zamienia sąsiednie pary: pozycje (0,1), (2,3), … Ostatnia litera nieparzystego tekstu zostaje. Ta sama funkcja szyfruje i deszyfruje, bo druga zamiana par wraca do układu początkowego.

string pary(string s) {
    for (int i = 0; i + 1 < (int)s.size(); i += 2) {
        char tmp = s[i];
        s[i] = s[i + 1];
        s[i + 1] = tmp;
    }
    return s;
}

pary("KOT") → OKT. pary("OKT") → KOT. pary("AB") → BA. Pusty napis i jedna litera nic nie zmieniają. To nie jest Cezar: K nie stało się następną literą alfabetu, tylko zamieniło się miejscem z O.

Po czym poznać rodzinę Posortuj litery tekstu jawnego i szyfrogramu. W przestawieniu multizbiór liter jest ten sam. W podstawieniu — zwykle nie. KOT i OKT mają te same litery. Abc i Bcd — nie.

5. Szyfr jako klasa

Wspólna umowa: każda pochodna umie zaszyfrować i odszyfrować. Baza jest abstrakcyjna. main trzyma Szyfr* i nie wie, czy to Cezar, czy pary. Metody nie wołają cin. Klucz Cezara jest polem prywatnym.

class Szyfr {
public:
    virtual string szyfruj(const string& tekst) const = 0;
    virtual string deszyfruj(const string& tekst) const = 0;
    virtual ~Szyfr() {}
};

class Cezar : public Szyfr {
    int klucz;
public:
    Cezar(int k) : klucz(k) {
        if (k < 0) throw invalid_argument("klucz");
    }
    string szyfruj(const string& tekst) const override {
        return cezar(tekst, klucz);
    }
    string deszyfruj(const string& tekst) const override {
        return cezar(tekst, -klucz);
    }
};

class Pary : public Szyfr {
public:
    string szyfruj(const string& tekst) const override { return pary(tekst); }
    string deszyfruj(const string& tekst) const override { return pary(tekst); }
};

Test obiektu: deszyfruj(szyfruj(tekst)) równa się tekst. Dotyczy pustego napisu, jednej litery, znaku spoza alfabetu i zwykłego słowa. Klucz ujemny w konstruktorze Cezara jest błędem umowy — wyjątek, nie „przesuń w drugą stronę po cichu”. Deszyfrowanie wolno liczyć ujemnym przesunięciem wewnątrz metody, bo to już nie wejście użytkownika.

6. Porównanie

CezarPodstawieniePary
Co się zmieniaLitera o stałąLitera według kluczaPozycja, nie litera
OdwracalnośćPrzesunięcie −kSzukanie w kluczuTa sama operacja drugi raz
Liczba kluczy szkolnie25 nietrywialnychpermutacje 26 literw tej wersji jeden schemat
Znaki spoza alfabetubez zmianbez zmianteż wędrują, bo to pozycje

Pary przesuwają także spację i cyfrę, bo nie patrzą na alfabet — patrzą na indeks. Cezar i podstawienie zostawiają je. To różnica, którą sprawdzasz testem "A!": Cezar z kluczem 1 daje "B!", pary dają "!A".

Ćwiczenia do samodzielnego wykonania

Folder: Dokumenty\cwiczenia-po\klasa-4\rozdzial-07.

Ćwiczenie 1. Cezar łatwe

Abc z! kluczem 1 → Bcd a!. Deszyfrowanie wraca do oryginału. Pusty napis zostaje pusty.

Ćwiczenie 2. Klucz 27 łatwe

Pokaż, że klucz 27 daje to samo co 1. W komentarzu: skąd % 26.

Ćwiczenie 3. Podstawienie średnie

Klucz 26 różnych liter. Zaszyfruj ab i odszyfruj. Znak ! zostaje.

Ćwiczenie 4. Pary średnie

KOT → OKT → KOT. Porównaj litery z Cezarem: w jednym zdaniu napisz, czemu to przestawienie.

Ćwiczenie 5. Klasa trudne

Cezar i Pary jako pochodne Szyfr. Wskaźnik do bazy. Test okrągły: deszyfruj(szyfruj(s)) == s, w tym "A!" i "".

Ćwiczenie 6. 25 kluczy trudne

Dla szyfrogramu Cezara wypisz 25 możliwych tekstów. Wskaż, który czyta się po polsku albo po angielsku. Napisz, czemu podstawienie nie da się tak przejść pętlą 1…25.

Sprawdź się

1. Cezar z kluczem 1 zamienia Abc na:
2. Znak ! przy Cezarze:
3. Przestawienie parami:
4. Deszyfrowanie Cezara kluczem k:
5. Klasa bazowa Szyfr:

Wymagania na ocenę

Dział 7 planu (lekcje 40–45), ocena roczna. Ocena wyższa zawiera wymagania na oceny niższe.

OcenaUczeń
2 Omawia ideę Cezara. Szyfruje krótki tekst przesunięciem z pomocą wzoru.
3 Programuje Cezara (szyfrowanie i deszyfrowanie). Omawia ideę podstawienia albo przestawienia.
4 Programuje wybrany szyfr przestawieniowy lub podstawieniowy. Wydziela szyfrowanie do funkcji. Znaki spoza alfabetu zostawia zgodnie z ustaleniem lekcji.
5 Programuje szyfr jako klasę z szyfruj i deszyfruj. Testuje pusty napis i znaki spoza alfabetu. Sprawdza, że deszyfrowanie wraca do tekstu jawnego.
6 Porównuje poznane szyfry (odwracalność, liczba kluczy). Może wypisać 25 wariantów Cezara i wskazać, czemu podstawienia tak nie przejdziesz.

Lista „już umiem”