Uogólniony szyfr Cezara – implementacja w języku Python

W przedstawionej implementacji przyjmiemy następujące założenia:

• jako alfabetu będziemy używali alfabetu łacińskiego zawierającego $26$ liter zapisanych za pomocą kodu ASCIIASCIIASCII,

• nie uwzględniamy wielkości liter, przed zaszyfrowaniem zamienimy wprowadzony tekst na wielkie litery,

• podczas szyfrowania wszystkie znaki niebędące wielkimi literami pozostawiamy w szyfrogramieszyfrogramszyfrogramie,

• klucz może być dowolną liczbą całkowitą.

Specyfikacja algorytmu

Specyfikacja problemu:

Dane:

• tekst – ciąg znaków do zaszyfrowania

• klucz – liczba całkowita określająca przesunięcie

Wynik:

• ciąg znaków reprezentujący zaszyfrowany tekst

Zaczniemy zapisania nagłówka funkcji szyfruj.

def szyfruj(tekst, klucz):

Pierwszy argument przyjmowany przez funkcję to łańcuch znaków, który mamy zaszyfrować, a drugi – wartość przesunięcia. Pamiętajmy, że przesunięcie może być dowolną liczbą całkowitą.

Ponieważ klucz w wersji uogólnionej może być dowolną liczbą całkowitą, pierwszym krokiem będzie znormalizowanie go.

def szyfruj(tekst, klucz):
    klucz = (klucz % 26 + 26) % 26

Utworzymy również zmienną zaszyfrowany_tekst, która będzie przechowywać zaszyfrowany tekst. Przypisujemy jej pusty łańcuch znaków.

def szyfruj(tekst, klucz):
    klucz = (klucz % 26 + 26) % 26
	zaszyfrowany_tekst = ""

Założyliśmy, że program nie będzie uwzględniał wielkości liter, zatem przed przystąpieniem do szyfrowania musimy zamienić ewentualne małe litery na wielkie.

Wykorzystamy pętlę for.  Przeiterujemy przez wszystkie znaki w szyfrowanym tekście, by sprawdzić, które z nich są małymi literami. W instrukcji warunkowej sprawdzimy, czy wartość kodu ASCII danego znaku z szyfrowanego łańcucha zawiera się w zakresie, do którego należą kody ASCII małych liter alfabetu łacińskiego (czyli od a do z).

Jeżeli instrukcja warunkowa zwróci wartość true (warunek jest spełniony, czyli znak jest małą literą), kod zmienia małą literę na dużą literę.

Wykorzystamy funkcje ord oraz chr.

Funkcja ord(znak) zwraca wartość liczbową danego znaku przechowywanego w zmiennej znak.

Funkcja chr przeprowadza operację odwrotną – wartość liczbową zamienia na odpowiadający jej znak.

By zamienić małą literę na wielką, zaczniemy od przekształcenia znaku – jego wartość liczbową uzyskujemy, wykorzystując funkcję ord(znak). Następnie od uzyskanej wartości odejmujemy $32$. Robimy tak, ponieważ w tabeli kodów ASCII duże litery są dokładnie $32$ pozycje przed małymi literami, np. kod ASCII dla litery a to $97$, a dla A to $65$. Zatem odejmowanie $32$ od kodu małej litery zamienia ją na dużą literę.

W kolejnym kroku uzyskany kod ASCII przekształcamy na znak, wykorzystując funkcję chr.

def szyfruj(tekst, klucz):
    klucz = (klucz % 26 + 26) % 26
    zaszyfrowany_tekst = ""

    for znak in tekst:
        if 'a' <= znak <= 'z':
            znak = chr(ord(znak) - 32)

Program ma szyfrować wyłącznie litery, zatem inne znaki (spacje czy znaki interpunkcyjne oraz cyfry) nie powinny być szyfrowane. Zapiszemy zatem kolejną instrukcję warunkową.

Najpierw przekształcimy znak na wartość liczbową.

Naszą przykładową literą będzie litera $\text{Z}$. Jej wartość liczbowa to $90$.

Następnie odejmiemy od niej liczbę $65$. Dzięki temu wartość liczbowa znaku $\text{A}$ będzie wynosić $0$, $\text{B}$ – $1$, $\text{C}$ – $2$ itd.

Od $90$ odejmujemy $65$. Otrzymany wynik to $25$ – gdyby alfabet traktować jako tablicę znaków indeksowaną od $0$, litera $\text{Z}$ to element o indeksie $25$.

W kolejnym kroku dodamy do otrzymanego wyniku wartość zmiennej klucz, czyli przesunięcia.

Załóżmy, że nasz klucz (po normalizacji) wynosi $20$. Wiemy zatem, że litera $\text{Z}$ powinna zostać przekształcona na literę $\text{T}$. Do liczby $25$ dodajemy $20$. Otrzymany wynik to $45$.

Przedostatnim krokiem jest wykonanie operacji modulo $26$ – w ten sposób upewnimy się, że wartość zawiera się w zakresie od $0$ do $25$.

Operacja $45$ modulo $26$ daje $19$.

Na końcu dodamy liczbę $65$, tym samym przywracając wartość do zakresu kodów ASCII.

Suma liczb $19$ oraz $65$ wynosi $84$. Jest to kod ASCII zaszyfrowanego znaku. Po sprawdzeniu w tablicy ASCII wiemy, że jest to kod litery T, zatem szyfrowanie przebiegło poprawnie.

Ostatnim krokiem jest przekształcenie kodu ASCII do znaku, który zostaje przypisany zmiennej zaszyfrowany_znak.

Dodajemy wartość zmiennej zaszyfrowany_znak na końcu łańcucha znaków zaszyfrowany_tekst.

Jeśli sprawdzany znak nie jest wielką literą alfabetu łacińskiego, w niezmienionej formie dodajemy go na końcu łańcucha znaków zaszyfrowany_tekst

Po zaszyfrowaniu wszystkich znaków zwracamy łańcuch znaków zaszyfrowany_tekst.

def szyfruj(tekst, klucz):
    klucz = (klucz % 26 + 26) % 26
    zaszyfrowany_tekst = ""

    for znak in tekst:
        if 'a' <= znak <= 'z':
            znak = chr(ord(znak) - 32)
        if 'A' <= znak <= 'Z':
            zaszyfrowany_znak = chr((ord(znak) - 65 + klucz) % 26 + 65)
            zaszyfrowany_tekst += zaszyfrowany_znak
        else:
            zaszyfrowany_tekst += znak

    return zaszyfrowany_tekst

Kod programu

Na koniec umieszczamy wywołania funkcji szyfruj.

Działanie programu przetestujemy dla łańcucha znaków Sklepy cynamonowe t. 2 oraz klucza o wartości $5$.

Cały kod programu:

def szyfruj(tekst, klucz):
    klucz = (klucz % 26 + 26) % 26
    zaszyfrowany_tekst = ""

    for znak in tekst:
        if 'a' <= znak <= 'z':
            znak = chr(ord(znak) - 32)
        if 'A' <= znak <= 'Z':
            zaszyfrowany_znak = chr((ord(znak) - 65 + klucz) % 26 + 65)
            zaszyfrowany_tekst += zaszyfrowany_znak
        else:
            zaszyfrowany_tekst += znak

    return zaszyfrowany_tekst

tekst = "Sklepy cynamonowe t. 2"
klucz = 5

tekst = szyfruj(tekst, klucz)
print(tekst)

Wynik działania programu: XPQJUD HDSFRTSTBJ Y. 2

Deszyfrowanie

Specyfikacja problemu:

Dane:

• zaszyfrowany_tekst – ciąg znaków do odszyfrowania

• klucz – liczba całkowita określająca przesunięcie

Wynik:

• ciąg znaków reprezentujący odszyfrowany tekst

Szyfr Cezara jest szyfrem symetrycznym – do szyfrowania i deszyfrowania używamy tego samego klucza, oraz podstawieniowym – polega na zastępowaniu znaku tekstu jawnegotekst jawnytekstu jawnego przesuniętym w zapętlonym alfabecie o długość klucza innym znakiem. Z tego wynika, że deszyfrowanie to operacja odwrotna do szyfrowania i polega na przesuwaniu znaku w zapętlonym alfabecie w odwrotnym kierunku niż podczas szyfrowania.

Funkcja deszyfrująca wygląda następująco:

def deszyfruj(zaszyfrowany_tekst, klucz):
    klucz = ((-klucz % 26 + 26) % 26)
    odszyfrowany_tekst = ""

    for znak in zaszyfrowany_tekst:
        if 'a' <= znak <= 'z':
            znak = chr(ord(znak) - 32)
        if 'A' <= znak <= 'Z':
            odszyfrowany_znak = chr((ord(znak) - 65 + klucz) % 26 + 65)
            odszyfrowany_tekst += odszyfrowany_znak
        else:
            odszyfrowany_tekst += znak

    return odszyfrowany_tekst

Jej wywołanie odbywa się z użyciem tego samego klucza, ale przesunięcie jest w kierunku przeciwnym, zatem przed wartością klucza dodajemy znak minusa.

Kompletny kod programu, który najpierw zaszyfruje łańcuch znaków, a następnie go odszyfruje:

def szyfruj(tekst, klucz):
    klucz = (klucz % 26 + 26) % 26
    zaszyfrowany_tekst = ""

    for znak in tekst:
        if 'a' <= znak <= 'z':
            znak = chr(ord(znak) - 32)
        if 'A' <= znak <= 'Z':
            zaszyfrowany_znak = chr((ord(znak) - 65 + klucz) % 26 + 65)
            zaszyfrowany_tekst += zaszyfrowany_znak
        else:
            zaszyfrowany_tekst += znak

    return zaszyfrowany_tekst

def deszyfruj(zaszyfrowany_tekst, klucz):
    klucz = ((-klucz % 26 + 26) % 26)
    odszyfrowany_tekst = ""

    for znak in zaszyfrowany_tekst:
        if 'a' <= znak <= 'z':
            znak = chr(ord(znak) - 32)
        if 'A' <= znak <= 'Z':
            odszyfrowany_znak = chr((ord(znak) - 65 + klucz) % 26 + 65)
            odszyfrowany_tekst += odszyfrowany_znak
        else:
            odszyfrowany_tekst += znak

    return odszyfrowany_tekst

tekst = "Sklepy cynamonowe t. 2"
klucz = 5

tekst = szyfruj(tekst, klucz)
print("Zaszyfrowany tekst:", tekst)

tekst = deszyfruj(tekst, klucz)
print("Odszyfrowany tekst:", tekst)

Wynik działania programu:

Zaszyfrowany tekst: XPQJUD HDSFRTSTBJ Y. 2
Odszyfrowany tekst: SKLEPY CYNAMONOWE T. 2

Słownik