Kryptologia to dziedzina, która jest nierozłącznie kojarzona z informatyką. Jest tak nie bez powodu – m.in. to właśnie dzięki wszelakiej maści szyfrom, dbamy o bezpieczeństwo naszych danych. Zagłębianie się w tematykę kryptologii warto rozpocząć od zapoznania się z jednym z wielu szyfrów, którym może być chociażby szyfr Playfair.
Trochę historii
Szyfr Playfair został opracowany przez Charlesa Wheatstone – angielskiego wynalazcę. Szyfr ten zawdzięcza swoją nazwę baronowi Lyonowi Playfair, który stał za jego popularyzacją. Korzysta on z jednego klucza do szyfrowania i deszyfrowania wiadomości, należy więc do grupy szyfrów symetrycznych. Jest to także pierwszy z szyfrów, w którym tekst szyfrowany dzielony jest nie na pojedyncze litery (jak chociażby w szyfrze cezara), a na pary liter, zwane digrafami.
Szyfr Playfair był wykorzystywany przez brytyjską armię podczas wojny burskiej. Jest on stosunkowo prosty w użyciu, dzięki czemu nadawał się idealnie do zastosowań polowych.
Szyfr Playfair – zasada działania
Przejdźmy jednak do meritum, jakim jest zasada działania szyfru. Do rozpoczęcia działania potrzebujemy klucza oraz tekstu do szyfrowania. Za klucz przyjmijmy słowo „binary”, a naszym tekstem jawnym będzie słowo „programowanie”.
W pierwszej kolejności potrzebujemy stworzyć kwadrat szyfrowania, który jest niczym innym jak tablicą o wymiarach 5×5. W kolejnym kroku wpisujemy litery klucza w kolejne komórki tablicy, pomijając wpisane już znaki (przykładowo klucz „binarnie” zostałby zapisany jako „binare”).
Następnie wpisujemy do tablicy pozostałe, nie wpisane jeszcze litery alfabetu (pomijając literę „j”, która zmieniana jest na literę „i”, ze względu na ograniczony rozmiar tablicy).2
Mając już gotową tablicę, możemy przystąpić do szyfrowania. Pierwszy krok, który musimy wykonać, to podzielenie szyfrowanego tekstu na pary liter. W naszym przypadku, otrzymamy: pr-og-ra-mo-wa-ni-e. Ze względu na nieparzystą liczbę liter w naszym tekście, dodajemy na koniec tekstu literę „z”, otrzymując: pr-og-ra-mo-wa-ni-ez. Szyfrowanie digrafów podzielone jest na kilka przypadków:
1)Obie litery są w tej samej kolumnie – W tym przypadku, zamieniamy litery, na te znajdujące się pod nimi. Przykładowo OG, zamienia się UO. W przypadku gdy którakolwiek z liter którą mamy zamienić, znajduje się na końcu kolumny, podczas zamiany bierzemy literę znajdującą się na początku tej samej kolumny
2)Obie litery są w tym samym wierszu – Analogicznie do przypadku pierwszego, zamieniamy litery na te sąsiadujące z nimi po prawej stronie. Jeśli któraś z liter znajduje się na końcu wiersza, bierzemy pierwszą literę znajdującą się na początku wiersza. Przykładowo dwuznak RA, zostanie zamieniony na BR.
3)Pozostałe przypadki – Gdy litery nie znajdują się w tej samej kolumnie ani wierszu, należy zlokalizować obie litery w tablicy. Następnie pierwszą literę zamieniamy ze znakiem znajdującym się na przecięciu wiersza litery pierwszej z kolumną litery drugiej. Przykładowo w digrafie PR, litera „p” zostanie zamieniona na literę „t”.
Druga z liter, zostaje natomiast zastąpiona znakiem znajdującym się na przecięciu kolumny litery pierwszej, z wierszem litery drugiej. Litera „r”, z tego samego dwuznaku zostanie więc zastąpiona literą „i”. Digraf PR zostanie więc przekształcony w TI.
Przechodząc przez cały proces, słowo „programowanie” zaszyfrowane przy użyciu klucza „binary”, będzie miało postać „tiuobrgtxnanfx”.
Odszyfrowywanie wiadomości znając procedurę szyfrowania nie należy do najtrudniejszych zadań – procedura jest zwyczajnie odwracana. Jeśli obie litery są w tej samej kolumnie, zamieniamy je na litery znajdujące się nad nimi. W przypadku gdy są w tym samym wierszu czytamy litery sąsiadujące z nimi po lewej stronie. W przypadku gdy litery znajdują się w innych kolumnach i wierszach, tak jak w przypadku szyfrowania szukamy przecięć, w kolejności wiersza litery pierwszej z kolumną litery drugiej, a następnie kolumny litery pierwszej, z wierszem litery drugiej.
Szyfr Playfair – implementacje
Implementacja szyfru Playfair podzielona jest na kilka funkcji. W pierwszej kolejności należy przygotować odpowiednio klucz oraz tekst jawny. Z obu należy usunąć znaki białe i zamienić je na małe, bądź wielkie litery.
C++
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
void przygotowanie(string &klucz, string &tekstJawny) { if (klucz.length() == 0) { klucz = "binary"; } if (tekstJawny.length() == 0) { tekstJawny = "programowanie"; } //Usuniecie spacji klucz.erase(std::remove(klucz.begin(), klucz.end(), ' '), klucz.end()); tekstJawny.erase(std::remove(tekstJawny.begin(), tekstJawny.end(), ' '), tekstJawny.end()); //Zmiana wszystkich liter na male transform(klucz.begin(), klucz.end(), klucz.begin(), ::tolower); transform(tekstJawny.begin(), tekstJawny.end(), tekstJawny.begin(), ::tolower); //zamiana liter j na i replace(klucz.begin(), klucz.end(), 'j', 'i'); replace(tekstJawny.begin(), tekstJawny.end(), 'j', 'i'); //Jesli liczba liter jest nieparzysta dodajemy 'z' do tekstu jawnego if (tekstJawny.length() % 2 != 0) { tekstJawny += 'z'; } } |
Java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
private static String prepare(String wyraz) { //Usuniecie spacji wyraz = wyraz.replaceAll(" ", ""); //Zmiana wszystkich liter na male wyraz = wyraz.toLowerCase(); //zamiana liter j na i wyraz = wyraz.replaceAll("j", "i"); return wyraz; } private static String przygotowanieKlucza(String wyraz) { if (wyraz.length() == 0) { wyraz = "binary"; } return prepare(wyraz); } private static String przygotowanieTekstuJawnego(String wyraz) { if (wyraz.length() == 0) { wyraz = "programowanie"; } wyraz = prepare(wyraz); if(wyraz.length() % 2 != 0) { wyraz = wyraz + "z"; } return wyraz; } |
Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
def prepareWord(word): word = str(word) word = word.replace(" ", "") word = word.lower() word.replace("j", "i") return word def prepareKey(key): if len(key) == 0: key = "binary" return prepareWord(key) def prepareText(text): if len(text) == 0: key = "programowanie" text = prepareWord(text) if len(text) % 2 != 0: text = text + "z" return text |
Następnie generować będziemy tablicę szyfrowania o wymiarach 5×5. Następnie wykonujemy wszystkie kroki generowania tablicy. W poniższej implementacji korzystamy z pomocniczego stringa w celu sprawdzania, czy dane litery znajdują się już w tablicy. Wykonywane jest to przy pomocy metody find().
C++
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
void generowanieTablicy(string klucz, char tablicaSzyfru[5][5]) { string kontrolny = ""; string alfabet = "abcdefghiklmnopqrstuvwxyz"; int x = 0, y = 0; size_t pozycja; //Korzystajac z zaawansowanej petli przechodzimy przez kolejne znaki w kluczu for (char znak : klucz) { //Sprawdzamy czy dodany znak znajduje się już w tablicy pozycja = kontrolny.find(znak); //Jesli nie dodajemy do tablicy i stringa kontrolnego if (pozycja == string::npos) { if (y == 5) { //Jesli tekscie jawnym znajduja sie inne znaki oprocz liter //wielkosc tablicy zostanie przekroczona - program nie moze wykonac swojego dzialania cout << "BLAD PODCZAS SZYFROWANIA! - Za duza ilosc znakow w tablicy" << endl; return; } //Dodajemy znak do kontrolnego stringa i tablicy kontrolny += znak; tablicaSzyfru[x][y] = znak; x++; //Jesli doszlismy do konca wiersza przechodzimy do kolejnego if (x == 5) { x = 0; y++; } } } for (char znak : alfabet) { pozycja = kontrolny.find(znak); if (pozycja == string::npos) { if (y == 5) { cout << "BLAD PODCZAS SZYFROWANIA! - Za duza ilosc znakow w tablicy" << endl; return; } kontrolny += znak; tablicaSzyfru[x][y] = znak; x++; if (x == 5) { x = 0; y++; } } } cout << "Tablica szyfrowania:" << endl; printTab(tablicaSzyfru); } |
Java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
private static void generowanieTablicy(String klucz, char[][] tablicaSzyfru) { String kontrolny = ""; String alfabet = "abcdefghiklmnopqrstuvwxyz"; int x = 0, y = 0; int pozycja; //Korzystajac z zaawansowanej petli przechodzimy przez kolejne znaki w kluczu for (char znak : klucz.toCharArray()) { //Sprawdzamy czy dodany znak znajduje się już w tablicy pozycja = kontrolny.indexOf(znak); //Jesli nie dodajemy do tablicy i stringa kontrolnego if (pozycja == -1) { if (y == 5) { //Jesli tekscie jawnym znajduja sie inne znaki oprocz liter //wielkosc tablicy zostanie przekroczona - program nie moze wykonac swojego dzialania System.out.println("BLAD PODCZAS SZYFROWANIA! - Za duza ilosc znakow w tablicy"); return; } //Dodajemy znak do kontrolnego stringa i tablicy kontrolny += znak; tablicaSzyfru[x][y] = znak; x++; //Jesli doszlismy do konca wiersza przechodzimy do kolejnego if (x == 5) { x = 0; y++; } } } for (char znak : alfabet.toCharArray()) { pozycja = kontrolny.indexOf(znak); if (pozycja == -1) { if (y == 5) { System.out.println("BLAD PODCZAS SZYFROWANIA! - Za duza ilosc znakow w tablicy"); return; } kontrolny += znak; tablicaSzyfru[x][y] = znak; x++; if (x == 5) { x = 0; y++; } } } System.out.println("Tablica szyfrowania:"); printTab(tablicaSzyfru); } |
Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
def generate(key, tab): kontrolny = "" alfabet = "abcdefghiklmnopqrstuvwxyz" x = 0 y = 0 pozycja = 0 for znak in key: # Korzystajac z petli przechodzimy przez kolejne znaki w kluczu pozycja = kontrolny.find(znak) # Sprawdzamy czy dodany znak znajduje się już w tablicy if pozycja == -1: # Jesli nie dodajemy do tablicy i stringa kontrolnego if y == 5: # Jesli tekscie jawnym znajduja sie inne znaki oprocz liter print("BLAD PODCZAS SZYFROWANIA! - Za duza ilosc znakow w tablicy") return # wielkosc tablicy zostanie przekroczona - program nie moze wykonac swojego dzialania kontrolny += znak tab[x][y] = znak x += 1 if x == 5: x = 0 y += 1 for znak in alfabet: pozycja = kontrolny.find(znak) if pozycja == -1: if y == 5: print("BLAD PODCZAS SZYFROWANIA! - Za duza ilosc znakow w tablicy") return kontrolny += znak tab[x][y] = znak x += 1 if x == 5: x = 0 y += 1 print("Tablica szyfrowania:") printTab(tab) |
Po wygenerowaniu tablicy korzystamy z funkcji pomocniczej do jej wyświetlenia.
C++
|
1 2 3 4 5 6 7 8 9 10 |
void printTab(char tab[5][5]) { cout << endl; for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { cout << tab[j][i] << " | "; } cout << endl; } cout << endl; } |
Java
|
1 2 3 4 5 6 7 8 |
private static void printTab(char[][] tablicaSzyfru) { for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { System.out.print(tablicaSzyfru[j][i] + " | "); } System.out.println(); } } |
Python
|
1 2 3 4 5 6 7 |
def printTab(tab): print() for x in range(5): for y in range(5): print(tab[x][y], end=" | ") print() print() |
Oprócz funkcji wyświetlającej zawartość tablicy stworzona została struktura point przechowująca współrzędne punktu, która to wykorzystana zostaje w funkcji wyszukującej koordynaty danego znaku.
C++
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
//Struktura przechowująca pozycje znaku struct point { int x; int y; }; point* znajdzKoordynatyZnaku(char znak, char tablica[5][5]) { for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { if (tablica[j][i] == znak) { point* koordynaty = new point; koordynaty->x = j; koordynaty->y = i; return koordynaty; } } } return nullptr; } |
Java
|
1 2 3 4 5 6 7 8 9 10 11 12 |
private static SimpleEntry<Integer, Integer> znajdzKoordynatyZnaku(char znak, char[][] tablica) { //wykorzystujemy istniejaca juz klase SimpleEntry z biblioteki java.util.AbstractMap for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { if (tablica[j][i] == znak) { SimpleEntry<Integer, Integer> koordynaty = new SimpleEntry<Integer, Integer>(j, i); return koordynaty; } } } return null; } |
Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
class Point(): x = 0 y = 0 def __init__(self, a, b): self.x = a self.y = b def findCoords(znak, tab): for i in range(5): for j in range(5): if tab[j][i] == znak: p = Point(j, i) return p return None |
Po przygotowaniu tablicy szyfrowania, przystępujemy do właściwego szyfrowania. Każdy krok szyfrowania rozpoczynamy od znalezienia współrzędnych obu rozpatrywanych znaków. Następnie przyrównując do siebie koordynaty x i y, odpowiadające za pozycję w wierszu i kolumnie, określamy przypadek. Nowe znaki z tablicy, zostają dodane do zaszyfrowanego ciągu znaków, według standardowych zasad.
C++
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
string szyfrowanie(string tekstJawny, char tablicaSzyfru[5][5]) { char pierwszyZnak, drugiZnak; point* koordynatyPierwszego; point* koordynatyDrugiego; string tekstZaszyfrowany = ""; //Rozpoczynamy szyfrowanie zakladajac parzysta liczbe znakow w tekscie jawnym for (int x = 0; x < tekstJawny.length(); x += 2) { //Wyszukiwanie koordynatow obu znakow digrafu koordynatyPierwszego = znajdzKoordynatyZnaku(tekstJawny.at(x), tablicaSzyfru); koordynatyDrugiego = znajdzKoordynatyZnaku(tekstJawny.at(x + 1), tablicaSzyfru); if (koordynatyPierwszego == nullptr || koordynatyDrugiego == nullptr) { cout << "NIE ZNALEZIONO ZNAKU W TABLICY! - Zakonczenie pracy" << endl; return ""; } //Pierwszy przypadek if (koordynatyPierwszego->x == koordynatyDrugiego->x) { //Jesli znaki sa w tej samej kolumnie zamieniamy je na znaki znajdujace sie nizej //Dzialanie modulo 5 jest potrzebne, aby uchronic sie od wyjscia poza zakres tablicy //w przypadku znaku bedacego ostatnim znakiem w kolumnie tekstZaszyfrowany += tablicaSzyfru[koordynatyPierwszego->x][(koordynatyPierwszego->y + 1) % 5]; tekstZaszyfrowany += tablicaSzyfru[koordynatyDrugiego->x][(koordynatyDrugiego->y + 1) % 5]; } //Drugi przypadek else if (koordynatyPierwszego->y == koordynatyDrugiego->y) { //Jesli znaki sa w tym samym wierszu zamieniamy je na znaki znajdujace znajdujace sie po prawej //Dzialanie modulo 5 jest potrzebne, aby uchronic sie od wyjscia poza zakres tablicy //w przypadku znaku bedacym ostatnim znakiem w wierszu tekstZaszyfrowany += tablicaSzyfru[(koordynatyPierwszego->x + 1) % 5][koordynatyPierwszego->y]; tekstZaszyfrowany += tablicaSzyfru[(koordynatyDrugiego->x + 1) % 5][koordynatyDrugiego->y]; } //Pozostale przypadki else { //Szukamy znakow na przecieciu wiersza znaku pierwszego z kolumna drugiego oraz //przeciecia wiersza drugiego z kolumna pierwszego tekstZaszyfrowany += tablicaSzyfru[koordynatyDrugiego->x][koordynatyPierwszego->y]; tekstZaszyfrowany += tablicaSzyfru[koordynatyPierwszego->x][koordynatyDrugiego->y]; } } return tekstZaszyfrowany; } |
Java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
private static String szyfrowanie(String tekstJawny, char[][] tablicaSzyfru) { SimpleEntry<Integer, Integer> koordynatyPierwszego; SimpleEntry<Integer, Integer> koordynatyDrugiego; String tekstZaszyfrowany = ""; //Rozpoczynamy szyfrowanie zakladajac parzysta liczbe znakow w tekscie jawnym for (int x = 0; x < tekstJawny.length(); x += 2) { //Wyszukiwanie koordynatow obu znakow digrafu koordynatyPierwszego = znajdzKoordynatyZnaku(tekstJawny.charAt(x), tablicaSzyfru); koordynatyDrugiego = znajdzKoordynatyZnaku(tekstJawny.charAt(x + 1), tablicaSzyfru); if (koordynatyPierwszego == null || koordynatyDrugiego == null) { System.out.println("NIE ZNALEZIONO ZNAKU W TABLICY! - Zakonczenie pracy"); return ""; } //Pierwszy przypadek if (koordynatyPierwszego.getKey() == koordynatyDrugiego.getKey()) { //Jesli znaki sa w tej samej kolumnie zamieniamy je na znaki znajdujace sie nizej //Dzialanie modulo 5 jest potrzebne, aby uchronic sie od wyjscia poza zakres tablicy //w przypadku znaku bedacego ostatnim znakiem w kolumnie tekstZaszyfrowany += tablicaSzyfru[koordynatyPierwszego.getKey()][(koordynatyPierwszego.getValue() + 1) % 5]; tekstZaszyfrowany += tablicaSzyfru[koordynatyDrugiego.getKey()][(koordynatyDrugiego.getValue() + 1) % 5]; } //Drugi przypadek else if (koordynatyPierwszego.getValue() == koordynatyDrugiego.getValue() ) { //Jesli znaki sa w tym samym wierszu zamieniamy je na znaki znajdujace znajdujace sie po prawej //Dzialanie modulo 5 jest potrzebne, aby uchronic sie od wyjscia poza zakres tablicy //w przypadku znaku bedacym ostatnim znakiem w wierszu tekstZaszyfrowany += tablicaSzyfru[(koordynatyPierwszego.getKey() + 1) % 5][koordynatyPierwszego.getValue()]; tekstZaszyfrowany += tablicaSzyfru[(koordynatyDrugiego.getKey() + 1) % 5][koordynatyDrugiego.getValue()]; } //Pozostale przypadki else { //Szukamy znakow na przecieciu wiersza znaku pierwszego z kolumna drugiego oraz //przeciecia wiersza drugiego z kolumna pierwszego tekstZaszyfrowany += tablicaSzyfru[koordynatyDrugiego.getKey()][koordynatyPierwszego.getValue()]; tekstZaszyfrowany += tablicaSzyfru[koordynatyPierwszego.getKey()][koordynatyDrugiego.getValue()]; } } return tekstZaszyfrowany; } |
Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
def szyfrowanie(text, tab): coordsFirst = Point(0, 0) coordsSecond = Point(0, 0) encryptedText = "" for x in range(0, len(text), 2): #Rozpoczynamy szyfrowanie zakladajac parzysta liczbe znakow w tekscie jawnym coordsFirst = findCoords(text[x], tab) #Wyszukiwanie koordynatow obu znakow digrafu coordsSecond = findCoords(text[x + 1], tab) if coordsFirst == None or coordsSecond == None: print("NIE ZNALEZIONO ZNAKU ", text[x], " W TABLICY! - Zakonczenie pracy") return "" if coordsFirst.x == coordsSecond.x: #Pierwszy przypadek encryptedText += tab[coordsFirst.x][coordsFirst.y + 1] #Jesli znaki sa w tej samej kolumnie zamieniamy je na znaki znajdujace sie nizej encryptedText += tab[coordsSecond.x][(coordsSecond.y + 1) % 5] #Dzialanie modulo 5 jest potrzebne, aby uchronic sie od wyjscia poza zakres tablicy else: #Drugi przypadek; Jesli znaki sa w tym samym wierszu zamieniamy je na znaki znajdujace znajdujace sie po prawej if coordsFirst.y == coordsSecond.y: #Dzialanie modulo 5 jest potrzebne, aby uchronic sie od wyjscia poza zakres tablicy encryptedText += tab[(coordsFirst.x + 1) % 5][coordsFirst.y] encryptedText += tab[(coordsSecond.x + 1) % 5][coordsSecond.y] else: #Pozostale przypadki encryptedText += tab[coordsSecond.x][coordsFirst.y] #Szukamy znakow na przecieciu wiersza znaku pierwszego z kolumna drugiego oraz encryptedText += tab[coordsFirst.x][coordsSecond.y] #przeciecia wiersza drugiego z kolumna pierwszego return encryptedText |
Funkcja odszyfrowywania odwraca kolejność działań. Całość programu ma więc postać:
C++
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 |
//program wykonujacy //szyfrowanie i deszyfrowanie Playfair //Jan Żwirek #include <iostream> #include <algorithm> #include <string> using namespace std; //Struktura przechowująca pozycje znaku struct point { int x; int y; }; void przygotowanie(string &klucz, string &tekstJawny); void generowanieTablicy(string klucz, char tablicaSzyfru[5][5]); string szyfrowanie(string tekstJawnym, char tablicaSzyfru[5][5]); string odszyfrowywanie(string tekstZaszyfrowany, char tablicaSzyfru[5][5]); void printTab(char tab[5][5]); point* znajdzKoordynatyZnaku(char znak, char tablica[5][5]); int main() { string klucz, tekst, tekstZaszyfrowany; char tablicaSzyfru[5][5]; cout << "Podwaj klucz i tekst jawny bez liczb oraz znakow specjalych!" << endl; cout << "Wprowadz klucz: "; std::getline(std::cin, klucz); cout << "Wprowadz tekst do zaszyfrowania: "; std::getline(std::cin, tekst); cout << "\nTekst jawny: " << tekst << endl; cout << "Klucz: " << klucz << endl; przygotowanie(klucz, tekst); generowanieTablicy(klucz, tablicaSzyfru); tekstZaszyfrowany = szyfrowanie(tekst, tablicaSzyfru); cout << "Tekst zaszyfrowany: " << tekstZaszyfrowany << endl; cout << "Tekst odszyfrowany: " << odszyfrowywanie(tekstZaszyfrowany, tablicaSzyfru) << endl; } void przygotowanie(string &klucz, string &tekstJawny) { if (klucz.length() == 0) { klucz = "binary"; } if (tekstJawny.length() == 0) { tekstJawny = "programowanie"; } //Usuniecie spacji klucz.erase(std::remove(klucz.begin(), klucz.end(), ' '), klucz.end()); tekstJawny.erase(std::remove(tekstJawny.begin(), tekstJawny.end(), ' '), tekstJawny.end()); //Zmiana wszystkich liter na male transform(klucz.begin(), klucz.end(), klucz.begin(), ::tolower); transform(tekstJawny.begin(), tekstJawny.end(), tekstJawny.begin(), ::tolower); //zamiana liter j na i replace(klucz.begin(), klucz.end(), 'j', 'i'); replace(tekstJawny.begin(), tekstJawny.end(), 'j', 'i'); //Jesli liczba liter jest nieparzysta dodajemy 'z' do tekstu jawnego if (tekstJawny.length() % 2 != 0) { tekstJawny += 'z'; } } void generowanieTablicy(string klucz, char tablicaSzyfru[5][5]) { string kontrolny = ""; string alfabet = "abcdefghiklmnopqrstuvwxyz"; int x = 0, y = 0; size_t pozycja; //Korzystajac z zaawansowanej petli przechodzimy przez kolejne znaki w kluczu for (char znak : klucz) { //Sprawdzamy czy dodany znak znajduje się już w tablicy pozycja = kontrolny.find(znak); //Jesli nie dodajemy do tablicy i stringa kontrolnego if (pozycja == string::npos) { if (y == 5) { //Jesli tekscie jawnym znajduja sie inne znaki oprocz liter //wielkosc tablicy zostanie przekroczona - program nie moze wykonac swojego dzialania cout << "BLAD PODCZAS SZYFROWANIA! - Za duza ilosc znakow w tablicy" << endl; return; } //Dodajemy znak do kontrolnego stringa i tablicy kontrolny += znak; tablicaSzyfru[x][y] = znak; x++; //Jesli doszlismy do konca wiersza przechodzimy do kolejnego if (x == 5) { x = 0; y++; } } } for (char znak : alfabet) { pozycja = kontrolny.find(znak); if (pozycja == string::npos) { if (y == 5) { cout << "BLAD PODCZAS SZYFROWANIA! - Za duza ilosc znakow w tablicy" << endl; return; } kontrolny += znak; tablicaSzyfru[x][y] = znak; x++; if (x == 5) { x = 0; y++; } } } cout << "Tablica szyfrowania:" << endl; printTab(tablicaSzyfru); } string szyfrowanie(string tekstJawny, char tablicaSzyfru[5][5]) { char pierwszyZnak, drugiZnak; point* koordynatyPierwszego; point* koordynatyDrugiego; string tekstZaszyfrowany = ""; //Rozpoczynamy szyfrowanie zakladajac parzysta liczbe znakow w tekscie jawnym for (int x = 0; x < tekstJawny.length(); x += 2) { //Wyszukiwanie koordynatow obu znakow digrafu koordynatyPierwszego = znajdzKoordynatyZnaku(tekstJawny.at(x), tablicaSzyfru); koordynatyDrugiego = znajdzKoordynatyZnaku(tekstJawny.at(x + 1), tablicaSzyfru); if (koordynatyPierwszego == nullptr || koordynatyDrugiego == nullptr) { cout << "NIE ZNALEZIONO ZNAKU W TABLICY! - Zakonczenie pracy" << endl; return ""; } //Pierwszy przypadek if (koordynatyPierwszego->x == koordynatyDrugiego->x) { //Jesli znaki sa w tej samej kolumnie zamieniamy je na znaki znajdujace sie nizej //Dzialanie modulo 5 jest potrzebne, aby uchronic sie od wyjscia poza zakres tablicy //w przypadku znaku bedacego ostatnim znakiem w kolumnie tekstZaszyfrowany += tablicaSzyfru[koordynatyPierwszego->x][(koordynatyPierwszego->y + 1) % 5]; tekstZaszyfrowany += tablicaSzyfru[koordynatyDrugiego->x][(koordynatyDrugiego->y + 1) % 5]; } //Drugi przypadek else if (koordynatyPierwszego->y == koordynatyDrugiego->y) { //Jesli znaki sa w tym samym wierszu zamieniamy je na znaki znajdujace znajdujace sie po prawej //Dzialanie modulo 5 jest potrzebne, aby uchronic sie od wyjscia poza zakres tablicy //w przypadku znaku bedacym ostatnim znakiem w wierszu tekstZaszyfrowany += tablicaSzyfru[(koordynatyPierwszego->x + 1) % 5][koordynatyPierwszego->y]; tekstZaszyfrowany += tablicaSzyfru[(koordynatyDrugiego->x + 1) % 5][koordynatyDrugiego->y]; } //Pozostale przypadki else { //Szukamy znakow na przecieciu wiersza znaku pierwszego z kolumna drugiego oraz //przeciecia wiersza drugiego z kolumna pierwszego tekstZaszyfrowany += tablicaSzyfru[koordynatyDrugiego->x][koordynatyPierwszego->y]; tekstZaszyfrowany += tablicaSzyfru[koordynatyPierwszego->x][koordynatyDrugiego->y]; } } return tekstZaszyfrowany; } string odszyfrowywanie(string tekstZaszyfrowany, char tablicaSzyfru[5][5]) { char pierwszyZnak, drugiZnak; point* koordynatyPierwszego; point* koordynatyDrugiego; string tekstJawny = ""; //Rozpoczynamy szyfrowanie zakladajac parzysta liczbe znakow w tekscie jawnym for (int x = 0; x < tekstZaszyfrowany.length(); x += 2) { //Wyszukiwanie koordynatow obu znakow digrafu koordynatyPierwszego = znajdzKoordynatyZnaku(tekstZaszyfrowany.at(x), tablicaSzyfru); koordynatyDrugiego = znajdzKoordynatyZnaku(tekstZaszyfrowany.at(x + 1), tablicaSzyfru); if (koordynatyPierwszego == nullptr || koordynatyDrugiego == nullptr) { cout << "NIE ZNALEZIONO ZNAKU W TABLICY! - Zakonczenie pracy" << endl; return ""; } //Pierwszy przypadek if (koordynatyPierwszego->x == koordynatyDrugiego->x) { //Jesli znaki sa w tej samej kolumnie zamieniamy je na znaki znajdujace sie wyzej //Jesli znak znajduje sie na poczatku kolumny, bierzemy ostatni znak z tej kolumny if (koordynatyPierwszego->y - 1 < 0) { tekstJawny += tablicaSzyfru[koordynatyPierwszego->x][4]; } else { tekstJawny += tablicaSzyfru[koordynatyPierwszego->x][koordynatyPierwszego->y - 1]; } if (koordynatyDrugiego->y - 1 < 0) { tekstJawny += tablicaSzyfru[koordynatyDrugiego->x][4]; } else { tekstJawny += tablicaSzyfru[koordynatyDrugiego->x][koordynatyDrugiego->y - 1]; } } //Drugi przypadek else if (koordynatyPierwszego->y == koordynatyDrugiego->y) { //Jesli znaki sa w tym samym wierszu zamieniamy je na znaki znajdujace znajdujace sie po lewej //Jesli znak znajduje sie na poczatku wiersza, bierzemy ostatni znak z tego wiersza if (koordynatyPierwszego->x - 1 < 0) { tekstJawny += tablicaSzyfru[4][koordynatyPierwszego->y]; } else { tekstJawny += tablicaSzyfru[koordynatyPierwszego->x - 1][koordynatyPierwszego->y]; } if (koordynatyDrugiego->x - 1 < 0) { tekstJawny += tablicaSzyfru[4][koordynatyDrugiego->y]; } else { tekstJawny += tablicaSzyfru[koordynatyDrugiego->x - 1][koordynatyDrugiego->y]; } } //Pozostale przypadki else { //Szukamy znakow na przecieciu wiersza znaku pierwszego z kolumna drugiego oraz //przeciecia wiersza drugiego z kolumna pierwszego tekstJawny += tablicaSzyfru[koordynatyDrugiego->x][koordynatyPierwszego->y]; tekstJawny += tablicaSzyfru[koordynatyPierwszego->x][koordynatyDrugiego->y]; } } return tekstJawny; } void printTab(char tab[5][5]) { cout << endl; for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { cout << tab[j][i] << " | "; } cout << endl; } cout << endl; } point* znajdzKoordynatyZnaku(char znak, char tablica[5][5]) { for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { if (tablica[j][i] == znak) { point* koordynaty = new point; koordynaty->x = j; koordynaty->y = i; return koordynaty; } } } return nullptr; } |
Java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 |
package matura; import java.util.AbstractMap.SimpleEntry; import java.util.Scanner; public class Main { private static String prepare(String wyraz) { //Usuniecie spacji wyraz = wyraz.replaceAll(" ", ""); //Zmiana wszystkich liter na male wyraz = wyraz.toLowerCase(); //zamiana liter j na i wyraz = wyraz.replaceAll("j", "i"); return wyraz; } private static String przygotowanieKlucza(String wyraz) { if (wyraz.length() == 0) { wyraz = "binary"; } return prepare(wyraz); } private static String przygotowanieTekstuJawnego(String wyraz) { if (wyraz.length() == 0) { wyraz = "programowanie"; } wyraz = prepare(wyraz); if(wyraz.length() % 2 != 0) { wyraz = wyraz + "z"; } return wyraz; } private static void generowanieTablicy(String klucz, char[][] tablicaSzyfru) { String kontrolny = ""; String alfabet = "abcdefghiklmnopqrstuvwxyz"; int x = 0, y = 0; int pozycja; //Korzystajac z zaawansowanej petli przechodzimy przez kolejne znaki w kluczu for (char znak : klucz.toCharArray()) { //Sprawdzamy czy dodany znak znajduje się już w tablicy pozycja = kontrolny.indexOf(znak); //Jesli nie dodajemy do tablicy i stringa kontrolnego if (pozycja == -1) { if (y == 5) { //Jesli tekscie jawnym znajduja sie inne znaki oprocz liter //wielkosc tablicy zostanie przekroczona - program nie moze wykonac swojego dzialania System.out.println("BLAD PODCZAS SZYFROWANIA! - Za duza ilosc znakow w tablicy"); return; } //Dodajemy znak do kontrolnego stringa i tablicy kontrolny += znak; tablicaSzyfru[x][y] = znak; x++; //Jesli doszlismy do konca wiersza przechodzimy do kolejnego if (x == 5) { x = 0; y++; } } } for (char znak : alfabet.toCharArray()) { pozycja = kontrolny.indexOf(znak); if (pozycja == -1) { if (y == 5) { System.out.println("BLAD PODCZAS SZYFROWANIA! - Za duza ilosc znakow w tablicy"); return; } kontrolny += znak; tablicaSzyfru[x][y] = znak; x++; if (x == 5) { x = 0; y++; } } } System.out.println("Tablica szyfrowania:"); printTab(tablicaSzyfru); } private static void printTab(char[][] tablicaSzyfru) { for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { System.out.print(tablicaSzyfru[j][i] + " | "); } System.out.println(); } } private static SimpleEntry<Integer, Integer> znajdzKoordynatyZnaku(char znak, char[][] tablica) { //wykorzystujemy istniejaca juz klase SimpleEntry z biblioteki java.util.AbstractMap for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { if (tablica[j][i] == znak) { SimpleEntry<Integer, Integer> koordynaty = new SimpleEntry<Integer, Integer>(j, i); return koordynaty; } } } return null; } private static String szyfrowanie(String tekstJawny, char[][] tablicaSzyfru) { SimpleEntry<Integer, Integer> koordynatyPierwszego; SimpleEntry<Integer, Integer> koordynatyDrugiego; String tekstZaszyfrowany = ""; //Rozpoczynamy szyfrowanie zakladajac parzysta liczbe znakow w tekscie jawnym for (int x = 0; x < tekstJawny.length(); x += 2) { //Wyszukiwanie koordynatow obu znakow digrafu koordynatyPierwszego = znajdzKoordynatyZnaku(tekstJawny.charAt(x), tablicaSzyfru); koordynatyDrugiego = znajdzKoordynatyZnaku(tekstJawny.charAt(x + 1), tablicaSzyfru); if (koordynatyPierwszego == null || koordynatyDrugiego == null) { System.out.println("NIE ZNALEZIONO ZNAKU W TABLICY! - Zakonczenie pracy"); return ""; } //Pierwszy przypadek if (koordynatyPierwszego.getKey() == koordynatyDrugiego.getKey()) { //Jesli znaki sa w tej samej kolumnie zamieniamy je na znaki znajdujace sie nizej //Dzialanie modulo 5 jest potrzebne, aby uchronic sie od wyjscia poza zakres tablicy //w przypadku znaku bedacego ostatnim znakiem w kolumnie tekstZaszyfrowany += tablicaSzyfru[koordynatyPierwszego.getKey()][(koordynatyPierwszego.getValue() + 1) % 5]; tekstZaszyfrowany += tablicaSzyfru[koordynatyDrugiego.getKey()][(koordynatyDrugiego.getValue() + 1) % 5]; } //Drugi przypadek else if (koordynatyPierwszego.getValue() == koordynatyDrugiego.getValue() ) { //Jesli znaki sa w tym samym wierszu zamieniamy je na znaki znajdujace znajdujace sie po prawej //Dzialanie modulo 5 jest potrzebne, aby uchronic sie od wyjscia poza zakres tablicy //w przypadku znaku bedacym ostatnim znakiem w wierszu tekstZaszyfrowany += tablicaSzyfru[(koordynatyPierwszego.getKey() + 1) % 5][koordynatyPierwszego.getValue()]; tekstZaszyfrowany += tablicaSzyfru[(koordynatyDrugiego.getKey() + 1) % 5][koordynatyDrugiego.getValue()]; } //Pozostale przypadki else { //Szukamy znakow na przecieciu wiersza znaku pierwszego z kolumna drugiego oraz //przeciecia wiersza drugiego z kolumna pierwszego tekstZaszyfrowany += tablicaSzyfru[koordynatyDrugiego.getKey()][koordynatyPierwszego.getValue()]; tekstZaszyfrowany += tablicaSzyfru[koordynatyPierwszego.getKey()][koordynatyDrugiego.getValue()]; } } return tekstZaszyfrowany; } private static String odszyfrowywanie(String tekstZaszyfrowany, char[][] tablicaSzyfru) { SimpleEntry<Integer, Integer> koordynatyPierwszego; SimpleEntry<Integer, Integer> koordynatyDrugiego; String tekstJawny = ""; //Rozpoczynamy szyfrowanie zakladajac parzysta liczbe znakow w tekscie jawnym for (int x = 0; x < tekstZaszyfrowany.length(); x += 2) { //Wyszukiwanie koordynatow obu znakow digrafu koordynatyPierwszego = znajdzKoordynatyZnaku(tekstZaszyfrowany.charAt(x), tablicaSzyfru); koordynatyDrugiego = znajdzKoordynatyZnaku(tekstZaszyfrowany.charAt(x + 1), tablicaSzyfru); if (koordynatyPierwszego == null || koordynatyDrugiego == null) { System.out.println("NIE ZNALEZIONO ZNAKU W TABLICY! - Zakonczenie pracy"); return ""; } //Pierwszy przypadek if (koordynatyPierwszego.getKey() == koordynatyDrugiego.getKey()) { //Jesli znaki sa w tej samej kolumnie zamieniamy je na znaki znajdujace sie wyzej //Jesli znak znajduje sie na poczatku kolumny, bierzemy ostatni znak z tej kolumny if (koordynatyPierwszego.getValue() - 1 < 0) { tekstJawny += tablicaSzyfru[koordynatyPierwszego.getKey()][4]; } else { tekstJawny += tablicaSzyfru[koordynatyPierwszego.getKey()][koordynatyPierwszego.getValue() - 1]; } if (koordynatyDrugiego.getValue() - 1 < 0) { tekstJawny += tablicaSzyfru[koordynatyDrugiego.getKey()][4]; } else { tekstJawny += tablicaSzyfru[koordynatyDrugiego.getKey()][koordynatyDrugiego.getValue() - 1]; } } //Drugi przypadek else if (koordynatyPierwszego.getValue() == koordynatyDrugiego.getValue()) { //Jesli znaki sa w tym samym wierszu zamieniamy je na znaki znajdujace znajdujace sie po lewej //Jesli znak znajduje sie na poczatku wiersza, bierzemy ostatni znak z tego wiersza if (koordynatyPierwszego.getKey() - 1 < 0) { tekstJawny += tablicaSzyfru[4][koordynatyPierwszego.getValue()]; } else { tekstJawny += tablicaSzyfru[koordynatyPierwszego.getKey() - 1][koordynatyPierwszego.getValue()]; } if (koordynatyDrugiego.getKey() - 1 < 0) { tekstJawny += tablicaSzyfru[4][koordynatyDrugiego.getValue()]; } else { tekstJawny += tablicaSzyfru[koordynatyDrugiego.getKey() - 1][koordynatyDrugiego.getValue()]; } } //Pozostale przypadki else { //Szukamy znakow na przecieciu wiersza znaku pierwszego z kolumna drugiego oraz //przeciecia wiersza drugiego z kolumna pierwszego tekstJawny += tablicaSzyfru[koordynatyDrugiego.getKey()][koordynatyPierwszego.getValue()]; tekstJawny += tablicaSzyfru[koordynatyPierwszego.getKey()][koordynatyDrugiego.getValue()]; } } return tekstJawny; } public static void main(String[] args){ String tekstJawny = ""; String klucz = ""; Scanner sc = new Scanner(System.in); System.out.println("Program szyfrujacy metoda PlayFair."); System.out.println("Podaj klucz (bez polskich znakow, cyfr i znakow specjalnych):"); klucz = sc.nextLine(); System.out.println("Podaj tekst do zaszyfrowania (bez polskich znakow, cyfr i znakow specjalnych):"); tekstJawny = sc.nextLine(); System.out.println("Klucz: " + klucz); System.out.println("Tekst do szyfrowania: " + tekstJawny); klucz = przygotowanieKlucza(klucz); tekstJawny = przygotowanieTekstuJawnego(tekstJawny); char[][] tab = new char[5][5]; generowanieTablicy(klucz, tab); String tekstZaszyfrowany = szyfrowanie(tekstJawny, tab); String tekstOdszyfrowany = odszyfrowywanie(tekstZaszyfrowany, tab); System.out.println("Tekst zaszyfrowany: " + tekstZaszyfrowany); System.out.println("Tekst odszyfrowany: " + tekstOdszyfrowany); sc.close(); } } |
Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 |
class Point(): x = 0 y = 0 def __init__(self, a, b): self.x = a self.y = b def findCoords(znak, tab): for i in range(5): for j in range(5): if tab[j][i] == znak: p = Point(j, i) return p return None def prepareWord(word): word = str(word) word = word.replace(" ", "") word = word.lower() word.replace("j", "i") return word def prepareKey(key): if len(key) == 0: key = "binary" return prepareWord(key) def prepareText(text): if len(text) == 0: key = "programowanie" text = prepareWord(text) if len(text) % 2 != 0: text = text + "z" return text def printTab(tab): print() for x in range(5): for y in range(5): print(tab[x][y], end=" | ") print() print() def generate(key, tab): kontrolny = "" alfabet = "abcdefghiklmnopqrstuvwxyz" x = 0 y = 0 pozycja = 0 for znak in key: # Korzystajac z petli przechodzimy przez kolejne znaki w kluczu pozycja = kontrolny.find(znak) # Sprawdzamy czy dodany znak znajduje się już w tablicy if pozycja == -1: # Jesli nie dodajemy do tablicy i stringa kontrolnego if y == 5: # Jesli tekscie jawnym znajduja sie inne znaki oprocz liter print("BLAD PODCZAS SZYFROWANIA! - Za duza ilosc znakow w tablicy") return # wielkosc tablicy zostanie przekroczona - program nie moze wykonac swojego dzialania kontrolny += znak tab[x][y] = znak x += 1 if x == 5: x = 0 y += 1 for znak in alfabet: pozycja = kontrolny.find(znak) if pozycja == -1: if y == 5: print("BLAD PODCZAS SZYFROWANIA! - Za duza ilosc znakow w tablicy") return kontrolny += znak tab[x][y] = znak x += 1 if x == 5: x = 0 y += 1 print("Tablica szyfrowania:") printTab(tab) def szyfrowanie(text, tab): coordsFirst = Point(0, 0) coordsSecond = Point(0, 0) encryptedText = "" for x in range(0, len(text), 2): #Rozpoczynamy szyfrowanie zakladajac parzysta liczbe znakow w tekscie jawnym coordsFirst = findCoords(text[x], tab) #Wyszukiwanie koordynatow obu znakow digrafu coordsSecond = findCoords(text[x + 1], tab) if coordsFirst == None or coordsSecond == None: print("NIE ZNALEZIONO ZNAKU ", text[x], " W TABLICY! - Zakonczenie pracy") return "" if coordsFirst.x == coordsSecond.x: #Pierwszy przypadek encryptedText += tab[coordsFirst.x][coordsFirst.y + 1] #Jesli znaki sa w tej samej kolumnie zamieniamy je na znaki znajdujace sie nizej encryptedText += tab[coordsSecond.x][(coordsSecond.y + 1) % 5] #Dzialanie modulo 5 jest potrzebne, aby uchronic sie od wyjscia poza zakres tablicy else: #Drugi przypadek; Jesli znaki sa w tym samym wierszu zamieniamy je na znaki znajdujace znajdujace sie po prawej if coordsFirst.y == coordsSecond.y: #Dzialanie modulo 5 jest potrzebne, aby uchronic sie od wyjscia poza zakres tablicy encryptedText += tab[(coordsFirst.x + 1) % 5][coordsFirst.y] encryptedText += tab[(coordsSecond.x + 1) % 5][coordsSecond.y] else: #Pozostale przypadki encryptedText += tab[coordsSecond.x][coordsFirst.y] #Szukamy znakow na przecieciu wiersza znaku pierwszego z kolumna drugiego oraz encryptedText += tab[coordsFirst.x][coordsSecond.y] #przeciecia wiersza drugiego z kolumna pierwszego return encryptedText def odszyfrowanie(encrypted, tab): first = Point(0, 0) second = Point(0, 0) finalText = "" for x in range(0, len(encrypted), 2): first = findCoords(encrypted[x], tab) second = findCoords(encrypted[x+1], tab) if first == None or second == None: print("NIE ZNALEZIONO ZNAKU ", encrypted[x], " W TABLICY! - Zakonczenie pracy") return "" if first.x == second.x: if first.y - 1 < 0: finalText += tab[first.x][4] else: finalText += tab[first.x][first.y-1] if second.y - 1 < 0: finalText += tab[second.x][4] else: finalText += tab[second.x][second.y - 1] else: if first.y == second.y: if first.x - 1 < 0: finalText += tab[4][first.x] else: finalText += tab[first.x - 1][first.y] if second.x - 1 <0: finalText += tab[4][second.y] else: finalText += tab[second.x - 1][second.y] else: finalText += tab[second.x][first.y] finalText += tab[first.x][second.y] return finalText print("Program szyfrujacy metoda Playfair") print("Podaj klucz (bez polskich znakow, cyfr i znakow specjalnych):") klucz = input() print("Podaj tekst do zaszyfrowania (bez polskich znakow, cyfr i znakow specjalnych):") tekstJawny = input() print("Klucz " + klucz) print("Tekst do szyfrowania " + tekstJawny) klucz = prepareKey(klucz) tekstJawny = prepareText(tekstJawny) tablica = [[0 for x in range(5)] for y in range(5)] generate(klucz, tablica) encrypted = szyfrowanie(tekstJawny, tablica) print("Tekst zaszyfrowany: " + encrypted) print("Tekst odszyfrowany: " + odszyfrowanie(encrypted, tablica)) |
Podsumowanie
Szyfry to zagadnienie ciekawe same w sobie, lecz również przydatne w nauce do matury z informatyki. Jeśli chcecie powiększyć swoją wiedzę informatyczną i przygotować się jak najlepiej do matury, zapraszamy Was do naszej grupy Facebookowej, którą znajdziecie po kliknięciu w poniższą grafikę:
Chcę wam również pogratulować, ponieważ właśnie poznaliście zasadę działania szyfru Playfaira oraz jego implementację. Dobrnęliście także do końca tego obszernego tekstu. Do zobaczenia niedługo!
