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

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

• jako alfabetu jawnego 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 od zapisania metody szyfruj.

Metoda przyjmie dwa argumenty – tekst oraz klucz.

public static String szyfruj(String tekst, int klucz) {

}

Pierwszy argument przyjmowany przez funkcję to łańcuch znaków, który mamy zaszyfrować, 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 – dzięki temu sprowadzimy go do takiej postaci, że będzie należał do przedziału $⟨0; 25⟩$.

Jak zostało powiedziane, nie musimy rozpisywać dodatkowych instrukcji, ponieważ doprowadziliśmy do normalizacji wartości klucza – zawsze znajduje się w zakresie $⟨0; 25⟩$.

public static String szyfruj(String tekst, int klucz) {
	klucz = (klucz % 26 + 26) % 26;
}

Tworzymy obiekt StringBuilder. Pozwoli stworzyć łańcuch znaków, który można modyfikować podczas działania programu. To ważne, ponieważ standardowo łańcuchy znaków w języku Java nie pozwalają na modyfikację po ich utworzeniu.

public static String szyfruj(String tekst, int klucz) {
	klucz = (klucz % 26 + 26) % 26;
    
	StringBuilder sb = new StringBuilder();
	
}

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.

public static String szyfruj(String tekst, int klucz) {
	klucz = (klucz % 26 + 26) % 26;
    
	StringBuilder sb = new StringBuilder();
    
    for (int i = 0; i < tekst.length(); i++) {
            char znak = tekst.charAt(i);
            if (znak >= 'a' && znak <= 'z') {
                znak -= 32;
            }
    }
}

Wykorzystamy pętlę for. Przejrzymy wszystkie znaki w szyfrowanym tekście, by sprawdzić, które z nich są małymi literami. Tworzymy zmienną znak i inicjalizujemy ją, przypisując jej wartość i-tego elementu łańcucha znaków tekst.

W instrukcji warunkowej sprawdzimy, czy wartość kodu ASCII danego znaku szyfrowanego łańcucha znaków 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ę. 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ę.

Nasz program ma szyfrować wyłącznie litery, zatem inne znaki (spacje, znaki interpunkcyjne oraz cyfry) nie powinny być szyfrowane. Zapiszemy instrukcję warunkową, która będzie sprawdzać, czy dany znak jest wielką literą. Jeśli tak, będzie szyfrowany z użyciem podanego klucza.

Jeśli znak nie będzie wielką literą, czyli jego kod numeryczny nie będzie zawierał się w przedziale kodów numerycznych znaków $⟨A; Z⟩$, nie zostanie zaszyfrowany.

Jeśli natomiast szyfrowany znak jest literą, konieczne jest sprawdzenie wartości klucza, za pomocą którego zostanie zaszyfrowany.

W instrukcji warunkowej rozważamy dwa przypadki.

Pierwszy z nich to sytuacja, w której dodanie wartości klucza do znaku nie przekroczy wartości kodu ASCII litery Z, czyli nie wyjdziemy poza alfabet. W takiej sytuacji klucz jest dodawany do wartości kodu ASCII tego znaku.

public static String szyfruj(String tekst, int klucz) {
	klucz = (klucz % 26 + 26) % 26;
    
	StringBuilder sb = new StringBuilder();
    
    for (int i = 0; i < tekst.length(); i++) {
		char znak = tekst.charAt(i);
		if (znak >= 'a' && znak <= 'z') {
			znak -= 32;
		}
		if (znak >= 'A' && znak <= 'Z') {
			if (znak + klucz <= 'Z')
				znak = (char)(znak + klucz);
		}
    }
}

Natomiast jeżeli dodanie wartości klucza do znaku przekroczy wartość kodu ASCII litery Z (wyjdziemy z alfabetu), to dodajemy wartość klucza, ale odejmujemy również liczbę $26$ (liczbę liter w alfabecie) od wyniku.

public static String szyfruj(String tekst, int klucz) {
	klucz = (klucz % 26 + 26) % 26;
    
	StringBuilder sb = new StringBuilder();
    
    for (int i = 0; i < tekst.length(); i++) {
		char znak = tekst.charAt(i);
		if (znak >= 'a' && znak <= 'z') {
			znak -= 32;
		}
		if (znak >= 'A' && znak <= 'Z') {
			if (znak + klucz <= 'Z')
				znak = (char)(znak + klucz);
			else
				znak = (char)(znak + klucz - 26);
		}
    }
}

Dodajemy przetworzony znak do obiektu StringBuilder i powtarzamy proces dla wszystkich znaków w tekście

public static String szyfruj(String tekst, int klucz) {
	klucz = (klucz % 26 + 26) % 26;
    
	StringBuilder sb = new StringBuilder();
    
    for (int i = 0; i < tekst.length(); i++) {
		char znak = tekst.charAt(i);
		if (znak >= 'a' && znak <= 'z') {
			znak -= 32;
		}
		if (znak >= 'A' && znak <= 'Z') {
			if (znak + klucz <= 'Z')
				znak = (char)(znak + klucz);
			else
				znak = (char)(znak + klucz - 26);
		}
		sb.append(znak);
	}   
    return sb.toString();
}

Za pomocą metody toString() dokonujemy konwersji obiektu StrongBuilder, tworząc łańcuch znaków.

Zwracamy łańcuch znaków.

Kod programu

Zdefiniujmy klasę Main oraz metodę main.

Następnie zdefiniujmy i zainicjalizujmy dwie zmienne. Pierwsza zmienna jest typu tekstowego – tekst. Druga zmienna jest typu całkowitoliczbowego – klucz.

W kolejnym kroku wywołujemy metodę szyfruj, przekazując do niej zmienne tekst oraz klucz. Wyświetlamy zaszyfrowany tekst.

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

Cały kod programu:

public class Main {
	public static void main(String[] args) {
		String tekst = "Sklepy cynamonowe t. 2";
		int klucz = 5;

		tekst = szyfruj(tekst, klucz);

		System.out.println(tekst);
	}
    
	public static String szyfruj(String tekst, int klucz) {
		klucz = (klucz % 26 + 26) % 26;
    
		StringBuilder sb = new StringBuilder();
    
		for (int i = 0; i < tekst.length(); i++) {
			char znak = tekst.charAt(i);
			if (znak >= 'a' && znak <= 'z') {
				znak -= 32;
			}
			if (znak >= 'A' && znak <= 'Z') {
				if (znak + klucz <= 'Z')
					znak = (char)(znak + klucz);
				else
					znak = (char)(znak + klucz - 26);
			
			}
		sb.append(znak);
		}
    
	return sb.toString();   
	}  
	
}

Wynik działania programu: XPQJUD HDSFRTSTBJ Y. $2$

Deszyfrowanie

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:

public static String deszyfruj(String tekst, int klucz) {
	klucz = (klucz % 26 + 26) % 26; 

	StringBuilder sb = new StringBuilder();

	for (int i = 0; i < tekst.length(); i++) {
		char znak = tekst.charAt(i);
		if (znak >= 'A' && znak <= 'Z') {
			if (znak - klucz >= 'A')
				znak -= klucz;
			else
				znak = (char)(znak - klucz + 26);
		}
		sb.append(znak);
	}

	return sb.toString();
}

Jej wywołanie odbywa się z użyciem tego samego klucza, co w funkcji szyfrującej:

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

public class Main {
    public static void main(String[] args) {
        String tekst = "Sklepy cynamonowe t. 2";
        int klucz = 5;

        tekst = szyfruj(tekst, klucz);
        System.out.println("Zaszyfrowany tekst: " + tekst);
        
        tekst = deszyfruj(tekst, klucz);
        System.out.println("Odszyfrowany tekst: " + tekst);
    }

    public static String szyfruj(String tekst, int klucz) {
        klucz = (klucz % 26 + 26) % 26;

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < tekst.length(); i++) {
            char znak = tekst.charAt(i);
            if (znak >= 'a' && znak <= 'z') {
                znak -= 32;
            }
            if (znak >= 'A' && znak <= 'Z') {
                if (znak + klucz <= 'Z')
                    znak = (char)(znak + klucz);
                else
                    znak = (char)(znak + klucz - 26);
            }
            sb.append(znak);
        }

        return sb.toString();
    }
    
    public static String deszyfruj(String tekst, int klucz) {
        klucz = (klucz % 26 + 26) % 26; 

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < tekst.length(); i++) {
            char znak = tekst.charAt(i);
            if (znak >= 'A' && znak <= 'Z') {
                if (znak - klucz >= 'A')
                    znak -= klucz;
                else
                    znak = (char)(znak - klucz + 26);
            }
            sb.append(znak);
        }

        return sb.toString();
    }
}

Wynik działania programu:

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

Słownik