Szyfry symetryczne w języku C++

Szyfry symetryczne dzielimy na dwie grupy: szyfry strumieniowe i szyfry blokowe. W szyfrze blokowym wiadomość dzieli się na bloki o określonej długości, a następnie fragmenty te są szyfrowane z użyciem klucza. W szyfrze strumieniowym natomiast klucz używany jest do wygenerowania strumienia bitów, który wykorzystuje się do zaszyfrowania jednego bitu/bajtu informacji na raz. W tym e‑materiale zaimplementujemy oba rodzaje szyfru symetrycznego.

Szyfr strumieniowy

Stosując szyfry strumieniowe, należy pamiętać, że okres generowanego strumienia powinien być możliwie długi (termin okres w tym kontekście odnosi się do okresu ciąguokres ciąguokresu ciągu). Dlatego ważny jest algorytm generowania strumienia.

W implementacjach szyfru strumieniowego stosowane są najczęściej generatory liczb pseudolosowych, np. funkcja rand(), dostępna w języku C++ w bibliotece standardowej.

Przeanalizujemy przykładową implementację szyfru strumieniowego w języku C++. Zaszyfrujemy, a później – w ramach sprawdzenia – odszyfrujemy wybrany ciąg znaków.

Specyfikacja problemu:

Dane:

• kluczGlowny – wykorzystywany w procesie szyfrowania klucz, na podstawie którego generowany jest strumień bitów; liczba całkowita

• slowoDoZaszyfrowania – tekst jawny przekazany do zakodowania; ciąg znaków

Wynik:

• zaszyfrowaneSlowo – zaszyfrowany tekst jawny; ciąg znaków

• odszyfrowaneSlowo – odszyfrowany szyfrogram; ciąg znaków

W celu szyfrowania bitów wiadomości możemy posłużyć się różnymi operacjami. Wykorzystamy operator XOR.

Do szyfrowania pojedynczych bajtów informacji wykorzystamy funkcję zaszyfrujZnak(), która jako parametry przyjmuje zmienne znak oraz klucz. Zdefiniujemy również tablicę o nazwie ustring do przechowywania zmiennych typu unsigned char, co pozwoli na zapisywanie wartości w zakresie <0; 255>.

typedef basic_string<unsigned char> ustring;

unsigned char zaszyfrujZnak(unsigned char znak, unsigned char klucz) {
	return znak ^ klucz;
}

Funkcja ta będzie przydatna w implementacji szyfru blokowego i strumieniowego.

Proces szyfrowania rozpoczynamy od przygotowania klucza szyfrującego oraz inicjalizacji zmiennej przechowującej tekst jawny ciągiem znaków DodaDodaDodatki. Następnie tworzymy kolejną zmienną zaszyfrowaneSlowo, która zawierać będzie szyfrogram złożony jedynie z liter „x”.

int main() {
	int kluczGlowny = 1234567890; //przykładowy klucz, za pomocą którego kodujemy i dekodujemy wiadomość
	srand(kluczGlowny); //ustawienie ziarna i "wyzerowanie generatora liczb pseudolosowych"
	string slowoDoZaszyfrowania = "DodaDodaDodatki";
	string zaszyfrowaneSlowo(slowoDoZaszyfrowania.size(), 'x');
	cout << "Slowo do zaszyfrowania: " << endl;
    
	for(int i = 0; i < slowoDoZaszyfrowania.size(); i++) {
		cout << slowoDoZaszyfrowania[i];
	}
    
	cout << endl;
	cout << "Tablica, w ktorej bedzie zaszyfrowane slowo:" << endl;
    
	for(int i = 0; i < zaszyfrowaneSlowo.size(); i++) {
		cout << zaszyfrowaneSlowo[i];
	}
    
	cout << endl;
}

Po implementacji opisanych operacji możemy przejść do samego szyfrowania. Wykorzystujemy przygotowaną wcześniej funkcję zaszyfrujZnak.

for(int i = 0; i < zaszyfrowaneSlowo.size(); i++) {
	zaszyfrowaneSlowo[i] = zaszyfrujZnak(slowoDoZaszyfrowania[i], rand());
}
    
cout << "Zaszyfrowane slowo:" << endl;
    
for(int i = 0; i < zaszyfrowaneSlowo.size(); i++) {
	cout << zaszyfrowaneSlowo[i];
}
    
cout << endl;

Dodatkowo program możemy uzupełnić o deszyfrowanie utworzonego szyfrogramu. Ponownie wymagane będzie wykorzystanie funkcji zaszyfrujZnak.

string odszyfrowaneSlowo(zaszyfrowaneSlowo.size(), 'x');    
srand(kluczGlowny); //Ponowne ustawienie generatora liczb pseudolosowych kluczem
    
for(int i = 0; i < odszyfrowaneSlowo.size(); i++) {
	odszyfrowaneSlowo[i] = zaszyfrujZnak(zaszyfrowaneSlowo[i], rand());
}
    
cout << "Odszyfrowane slowo:" << endl;
    
for(int i = 0; i < odszyfrowaneSlowo.size(); i++) {
	cout << odszyfrowaneSlowo[i];
}

Gotowy program wygląda następująco:

#include <iostream>
#include <cstdlib> 
#include <string>

using namespace std;

typedef basic_string<unsigned char> ustring;

unsigned char zaszyfrujZnak(unsigned char znak, unsigned char klucz) {
	return znak ^ klucz;
}

int main() {
	int kluczGlowny = 1234567890; //przykładowy klucz, za pomocą którego kodujemy i dekodujemy wiadomość
	srand(kluczGlowny); //ustawienie ziarna i "wyzerowanie generatora liczb pseudolosowych"
	string slowoDoZaszyfrowania = "DodaDodaDodatki";
	ustring zaszyfrowaneSlowo(slowoDoZaszyfrowania.size(), 'x');
	cout << "Slowo do zaszyfrowania: " << endl;
    
	for(int i = 0; i < slowoDoZaszyfrowania.size(); i++) {
		cout << slowoDoZaszyfrowania[i];
	}
    
	cout << endl;
	cout << "Tablica, w ktorej bedzie zaszyfrowane slowo:" << endl;
    
	for(int i = 0; i < zaszyfrowaneSlowo.size(); i++) {
		cout << zaszyfrowaneSlowo[i];
	}
    
	cout << endl;
    
	for(int i = 0; i < zaszyfrowaneSlowo.size(); i++) {
		zaszyfrowaneSlowo[i] = zaszyfrujZnak(slowoDoZaszyfrowania[i], rand());
	}
    
	cout << "Zaszyfrowane slowo:" << endl;
    
	for(int i = 0; i < zaszyfrowaneSlowo.size(); i++) {
		cout << zaszyfrowaneSlowo[i];
	}
    
	cout << endl;
	ustring odszyfrowaneSlowo(zaszyfrowaneSlowo.size(), 'x');    
	srand(kluczGlowny); //Ponowne ustawienie generatora liczb pseudolosowych kluczem
    
	for(int i = 0; i < odszyfrowaneSlowo.size(); i++) {
		odszyfrowaneSlowo[i] = zaszyfrujZnak(zaszyfrowaneSlowo[i], rand());
	}
    
	cout << "Odszyfrowane slowo:" << endl;
    
	for(int i = 0; i < odszyfrowaneSlowo.size(); i++) {
		cout << odszyfrowaneSlowo[i];
	}

	return 0;
}

A oto przykładowy wynik pracy programu:

Slowo do zaszyfrowania:
DodaDodaDodatki
Tablica, w ktorej będzie zaszyfrowane slowo:
xxxxxxxxxxxxxxx
Zaszyfrowane slowo:
Ů%ďj╠╣5■ýN├Uą5
Odszyfrowane slowo:
DodaDodaDodatki

W przedstawionym przykładzie szyfrowaliśmy całe bajty informacji. Przypomnijmy, że każdy znak w Extended ASCII kodowany jest na jednym bajcie, czyli na zmiennej typu char.

Warto zwrócić uwagę, że choć w szyfrowanej wiadomości występują:

• trzy znaki D,

• trzy znaki o,

• trzy znaki d,

• trzy znaki a,

• jeden znak t,

• jeden znak k,

• jeden znak i,

nie ma to jednak przełożenia na zaszyfrowaną wiadomość – wszystkie znaki występujące w szyfrogramie wydają się losowe.

Otrzymany ciąg znaków może różnić się w zależności od użytego standardu dekodowania. Ten z kolei zależy między innymi od wykorzystywanego systemu operacyjnego. Jeżeli w ramach swojej implementacji otrzymasz inne rozwiązanie, nie oznacza to, że jest ono błędne. W przypadku wątpliwości warto sprawdzić uzyskane kody w systemie dziesiętnym.

Szyfr blokowy

Szyfrowanie blokowe zaprezentujemy z wykorzystaniem trybu szyfrowania ECB (ang. Electronic Codebook). Tryb ten polega na szyfrowaniu po kolei bloków tekstu jawnego w kolejne bloki szyfrogramu. W ramach przedstawionej implementacji najpierw zaszyfrujemy, a później odszyfrujemy wybrany ciąg znaków.

Specyfikacja problemu:

Dane:

• kluczGlowny – klucz wykorzystywany w procesie szyfrowania; tablica trzech liczb całkowitych (składających się na klucz), które można przedstawić na ośmiu bitach

• slowoDoZaszyfrowania – tekst jawny przekazany do zakodowania; ciąg znaków

Wynik:

• zaszyfrowaneSlowo – zaszyfrowany tekst jawny; ciąg znaków

• odszyfrowaneSlowo – odszyfrowany szyfrogram; ciąg znaków

Podczas implementacji algorytmu dzielimy tekst jawny na bloki. Następnie każdy z bloków szyfrujemy kluczem, dzięki operatorowi XOR.

Jak pokazaliśmy w przykładzie, szyfr blokowy jest w stanie zaszyfrować jeden znak na wiele różnych znaków. Jednak aby tak się stało, klucz musi być dłuższy od jednego bajta.

Istnieje również możliwość szyfrowania blokowego z użyciem klucza o liczbie bitów niepodzielnej przez osiem. Jego implementacja jest jednak znacznie bardziej skomplikowana i nie będziemy się nią teraz zajmować.

Po analizie szyfrogramu z przykładu można zauważyć, że w wiadomości występuje kilka powtarzających się znaków. Podobnego efektu nie uzyskaliśmy w szyfrze strumieniowym oraz w szyfrze blokowym, wykorzystującym klucz dłuższy niż jeden bajt.

Trzy bajty klucza (przykład nr 2) w przypadku wiadomości wystarczyły do bezpiecznego jej zaszyfrowania. Przy szyfrowaniu dłuższych tekstów mogłoby się jednak okazać, że wybrany klucz jest zbyt krótki, by zapewnić pożądany poziom bezpieczeństwa (prawdopodobieństwo złamania szyfru byłoby wysokie).

ECB jest najprostszym koncepcyjnie algorytmem blokowym, którego jednak z tego właśnie powodu nie używa się w praktycznych zastosowaniach.

Przedstawiony program jest implementacją szyfru blokowego, opartego na szyfrowaniu tekstu jawnego kluczem o długości trzech bajtów (rozdzielonym na trzy liczby całkowite, gdzie każdą z nich możemy przedstawić za pomocą ośmiu bitów). Działa on podobnie do przedstawionego wcześniej algorytmu szyfrowania strumieniowego, z tą różnicą, że każdy blok wiadomości szyfrowany jest tym samym kluczem (a nie losowym strumieniem danych).

#include <iostream>
#include <cstdlib> 
#include <string>

using namespace std;

typedef basic_string<unsigned char> ustring;

unsigned char zaszyfrujZnak(unsigned char znak, int klucz) {
	return znak ^ klucz;
}

int main() {
	int kluczGlowny[3] = {234, 255, 165}; //przykładowy klucz, za pomocą którego kodujemy i dekodujemy wiadomość
	string slowoDoZaszyfrowania = "DodaDodaDodatki";
	ustring zaszyfrowaneSlowo(slowoDoZaszyfrowania.size(), 'x');
	cout << "Slowo do zaszyfrowania: " << endl;
    
	for(int i = 0; i < slowoDoZaszyfrowania.size(); i++) {
		cout << slowoDoZaszyfrowania[i];
	}
    
	cout << endl;
	cout << "Tablica, w ktorej bedzie zaszyfrowane slowo:" << endl;
    
	for(int i = 0; i < zaszyfrowaneSlowo.size(); i++) {
		cout << zaszyfrowaneSlowo[i];
	}
    
	cout << endl;
    
	for(int i = 0; i < zaszyfrowaneSlowo.size(); i++) {
		zaszyfrowaneSlowo[i] = zaszyfrujZnak(slowoDoZaszyfrowania[i], kluczGlowny[i % 3]);
	}
    
	cout << "Zaszyfrowane slowo:" << endl;
    
	for(int i = 0; i < zaszyfrowaneSlowo.size(); i++){
		cout << zaszyfrowaneSlowo[i];
	}
    
	cout << endl;
	ustring odszyfrowaneSlowo(zaszyfrowaneSlowo.size(), 'x');
    
	for(int i = 0; i < odszyfrowaneSlowo.size(); i++) {
		odszyfrowaneSlowo[i] = zaszyfrujZnak(zaszyfrowaneSlowo[i], kluczGlowny[i % 3]);
	}
    
	cout << "Odszyfrowane slowo:" << endl;
    
	for(int i = 0; i < odszyfrowaneSlowo.size(); i++) {
		cout << odszyfrowaneSlowo[i];
	}
    
	return 0;
}

Program na wyjściu standardowym wypisze:

Slowo do zaszyfrowania:
DodaDodaDodatki
Tablica, w ktorej bedzie zaszyfrowane slowo:
xxxxxxxxxxxxxxx
Zaszyfrowane slowo:
«É┴ő╗╩Ä×ßůŤ─×ö╠
Odszyfrowane slowo:
DodaDodaDodatki

Podobnie jak w przypadku szyfru strumieniowego, otrzymany wynik może się różnić w zależności od przyjętego typu kodowania.

Szyfr asymetryczny

Omówimy koncepcję szyfrów asymetrycznych, korzystając z protokołu Diffiego‑Hellmana. Jest on używany w protokole TLS/SSL, służącym do szyfrowania wiadomości wysyłanych drogą internetową, w celu asymetrycznego negocjowania sekretnego klucza.

W trakcie omawiania działania algorytmu użyjemy imion: Alicja i Bob – są to fikcyjne postacie, przywoływane podczas omawiania wielu algorytmów asymetrycznych. Z tymi imionami skojarzone są role dwóch osób, które chcą wymienić się wiadomością lub kluczem.

Algorytm można uprościć do następującej listy kroków:

1. Użytkownicy uzgadniają liczbę pierwszą $p$ i bazę $g$ – są to elementy publiczne i teoretycznie każdy może mieć do nich dostęp, co dla bezpieczeństwa szyfru nie stanowi żadnego problemu.

2. Alicja wybiera liczbę całkowitą $a$, a następnie przesyła Bobowi liczbę: 
   $A = g^a \bmod p$.

3. Bob wykonuje identyczną operację i również wybiera dowolną liczbę całkowitą $b$, a następnie wysyła liczbę $B = g^b \bmod p$.

4. Następnie Alicja oblicza liczbę $s = B^a \bmod p$. Bob oblicza tę samą liczbę: 
   $s = A^b\bmod p$.

Liczba $s$ jest wynegocjowanym sekretnym kluczem (znanym Alicji i Bobowi), który może być następnie wykorzystany do szyfrowania symetrycznego. Ponieważ szyfrowanie asymetryczne jest zbyt zasobo- i czasochłonne, wykorzystamy jedynie asymetryczny schemat do negocjacji klucza, używanego do szyfrowania symetrycznego. Możemy więc stwierdzić, że używamy schematów asymetrycznych do wynegocjowania klucza, aby był on tajny. Ale sam klucz stosujemy w algorytmie symetrycznym, aby ograniczyć czas procesu szyfrowania.

Równe wartości wyznaczonych tajnych kluczy możemy udowodnić matematycznie. Kluczowy jest fakt, że dzielenie ${\left(g^a\right)}^b$ i ${\left(g^b\right)}^a$ modulo $p$ zwróci w obu przypadkach tę samą wartość.

Alicja odbierająca wiadomość ma klucz publiczny składający się z trzech elementów: $p$, $g$ oraz $g^a\bmod p$. Dysponuje ona również kluczem prywatnym $a$ oraz wyznaczonym tajnym kluczem $s$.
Bob wysyłający wiadomość używa klucza publicznego, składającego się z trzech elementów: $p$, $g$ oraz $g^b\bmod p$. Ma on również klucz prywatny $b$ oraz wyznaczony tajny klucz $s$.

Przyjrzyjmy się implementacji opisanego algorytmu.

Specyfikacja problemu:

Dane:

• p – pierwszy element klucza publicznego Alicji; liczba pierwsza

• g – drugi element klucza publicznego Alicji – baza; liczba całkowita

• a – klucz prywatny Alicji; liczba całkowita

• b – klucz prywatny Boba; liczba całkowita

Wynik:

• s – obliczony sekretny klucz; liczba całkowita

Program rozpoczyna się od utworzenia trzech zmiennych: p, g oraz a, przechowujących opisane wcześniej wartości, czyli odpowiednio: liczbę pierwszą, bazę oraz liczbę całkowitą wybraną przez Alicję. Następnie obliczamy wartość zmiennej A według wzoru przedstawionego w drugim kroku przebiegu algorytmu.

#include <iostream>
#include <cmath>

using namespace std;

int main(int argc, char** argv) {
	int p = 29; //element klucza publicznego Alicji
	int g = 9; //element klucza publicznego Alicji
	int a = 7; //klucz prywatny Alicji
	unsigned int A = ((unsigned int)pow(g, a)) % p; //element klucza publicznego Alicji
    
	cout << "A Alicji wynosi: "<< A << endl;
}

Następnie tworzymy kolejną zmienną b, która przechowywać będzie liczbę całkowitą wybraną przez Boba. Wyliczamy także wartość zmiennej B (wzór w kroku trzecim opisu algorytmu).

int b = 3; //klucz prywatny Boba
unsigned int B = ((unsigned int)pow(g, b)) % p; //element klucza publicznego Boba, który obliczany jest na podstawie klucza publicznego Alicji
    
cout << "B Boba wynosi: "<< B << endl;

Ostatnim krokiem algorytmu jest wyznaczenie wartości zmiennej s, zarówno według wzoru wykorzystywanego przez Alicję, jak i przez Boba.

unsigned int s = ((unsigned int)pow(B, a)) % p; //Alicja oblicza s
    
cout << "s obliczone przez Alicje wynosi: " << s <<endl;
    
s = ((unsigned int)pow(A, b)) % p; //Bob oblicza s
    
cout << "s obliczone przez Boba wynosi: " << s << endl;

Gotowy program wygląda następująco:

#include <iostream>
#include <cmath>

using namespace std;

int main(int argc, char** argv) {
	int p = 29; //element klucza publicznego Alicji
	int g = 9; //element klucza publicznego Alicji
	int a = 7; //klucz prywatny Alicji
	unsigned int A = ((unsigned int)pow(g, a)) % p; //element klucza publicznego Alicji
    
	cout << "A Alicji wynosi: "<< A << endl;
    
	int b = 3; //klucz prywatny Boba
	unsigned int B = ((unsigned int)pow(g, b)) % p; //element klucza publicznego Boba, który obliczany jest na podstawie klucza publicznego Alicji
    
	cout << "B Boba wynosi: "<< B << endl;
    
	unsigned int s = ((unsigned int)pow(B, a)) % p; //Alicja oblicza s
    
	cout << "s obliczone przez Alicje wynosi: " << s <<endl;
    
	s = ((unsigned int)pow(A, b)) % p; //Bob oblicza s
    
	cout << "s obliczone przez Boba wynosi: " << s << endl;
    
	return 0;
}

Wynikiem działania programu byłoby wypisanie następujących wiadomości:

A Alicji wynosi: 28
B Boba wynosi: 4  
s obliczone przez Alicje wynosi: 28  
s obliczone przez Boba wynosi: 28

Słownik