WPROWADZENIE

Jasne, oto artykuł na temat Szyfru Gaderypoluki:

Szyfr Gaderypoluki – wprowadzenie i interaktywna eksploracja

Wprowadzenie

Szyfr Gaderypoluki to prosty szyfr harcerski, który polega na zamianie miejscami par liter według ustalonego klucza. Najczęściej używany klucz to „GA-DE-RY-PO-LU-KI”. Litery nie występujące w kluczu pozostają niezmienione. Szyfr ten jest łatwy do nauczenia i użycia, co czyni go popularnym wśród harcerzy i skautów.

Zasada działania

Klucz szyfru Gaderypoluki to ciąg par liter. Dla standardowego klucza „GA-DE-RY-PO-LU-KI” zamiana wygląda następująco:

• G zamieniane jest na A i A na G
• D zamieniane jest na E i E na D
• R zamieniane jest na Y i Y na R
• P zamieniane jest na O i O na P
• L zamieniane jest na U i U na L
• K zamieniane jest na I i I na K

Pozostałe litery alfabetu, które nie występują w kluczu, pozostają niezmienione.

Przykłady:

• Słowo „HARCERZ” staje się „HGYCDYZ”
• Słowo „LODY” staje się „UKDE”
• Słowo „ZUCH” staje się „ZUCH” (ponieważ Z, U, C i H nie występują w kluczu)

Szyfr Gaderypoluki, ze względu na swoją prostotę, nie zapewnia żadnego realnego poziomu bezpieczeństwa. Jest bardzo łatwy do złamania, nawet bez analizy częstości liter. Wystarczy znajomość klucza lub próba dopasowania par liter. Jego głównym celem jest edukacja i zabawa, a nie ochrona poufnych informacji.

Poniżej znajduje się kod w języku Python, który pozwala na zaszyfrowanie i odszyfrowanie wiadomości za pomocą szyfru Gaderypoluki.

KOD W JĘZYKU PYTHON

def szyfruj_gaderypoluki(tekst, klucz="GADERYPOLUKI"):
    klucz = klucz.upper()
    szyfr = {}
    for i in range(0, len(klucz), 2):
        if i + 1 < len(klucz): # Sprawdzamy, czy nie wychodzimy poza zakres
            szyfr[klucz[i]] = klucz[i + 1]
            szyfr[klucz[i + 1]] = klucz[i]
    wynik = ""
    for litera in tekst:
        litera_upper = litera.upper()
        if litera_upper in szyfr:
            if litera.islower():
                wynik += szyfr[litera_upper].lower()
            else:
                wynik += szyfr[litera_upper]
        else:
            wynik += litera
    return wynik

tekst_jawny = "HARCERZ"
tekst_zaszyfrowany = szyfruj_gaderypoluki(tekst_jawny)
print(f"Tekst jawny: {tekst_jawny}")
print(f"Tekst zaszyfrowany: {tekst_zaszyfrowany}")

tekst_odszyfrowany = szyfruj_gaderypoluki(tekst_zaszyfrowany)
print(f"Tekst odszyfrowany: {tekst_odszyfrowany}")

tekst_z_innym_kluczem = "LODY"
tekst_zaszyfrowany_inny_klucz = szyfruj_gaderypoluki(tekst_z_innym_kluczem)
print(f"Tekst jawny: {tekst_z_innym_kluczem}")
print(f"Tekst zaszyfrowany innym kluczem (domyślnym): {tekst_zaszyfrowany_inny_klucz}")

tekst_z_wieloma_literami = "Ala ma kota"
tekst_zaszyfrowany_wiele_liter = szyfruj_gaderypoluki(tekst_z_wieloma_literami)
print(f"Tekst jawny: {tekst_z_wieloma_literami}")
print(f"Tekst zaszyfrowany z wieloma literami: {tekst_zaszyfrowany_wiele_liter}")

⬆️⬆️⬆️ Zobacz w Google Colaboratory

JAK DZIAŁA PROGRAM?

Definicja funkcji:

• def szyfruj_gaderypoluki(tekst, klucz="GADERYPOLUKI"): Definiuje funkcję o nazwie szyfruj_gaderypoluki, która przyjmuje dwa argumenty:
  • tekst: Ciąg znaków (wiadomość), który ma być zaszyfrowany lub odszyfrowany.
  • klucz: Ciąg znaków reprezentujący klucz szyfrujący. Domyślnie ustawiony jest na „GADERYPOLUKI”, ale można podać inny.

Konwersja klucza na wielkie litery:

• klucz = klucz.upper(): Zamienia wszystkie litery w podanym kluczu na wielkie litery. Ułatwia to porównywanie niezależnie od wielkości liter w kluczu.

Inicjalizacja słownika szyfrującego:

• szyfr = {}: Tworzy pusty słownik (obiekt typu dict). Ten słownik będzie przechowywał pary liter do zamiany (np. 'G’: 'A’, 'A’: 'G’).

Tworzenie par liter w słowniku:

• for i in range(0, len(klucz), 2):: Rozpoczyna pętlę, która przechodzi przez klucz co dwa znaki (dzięki step=2). i będzie przyjmować wartości 0, 2, 4, itd.
• if i + 1 < len(klucz):: Sprawdza, czy istnieje kolejny znak w kluczu do stworzenia pary. Jest to zabezpieczenie, gdyby klucz miał nieparzystą liczbę znaków.
• szyfr[klucz[i]] = klucz[i + 1]: Dodaje do słownika wpis, gdzie kluczem jest pierwsza litera pary (klucz[i]), a wartością druga litera pary (klucz[i + 1]). Np. dla i=0, szyfr['G'] = 'A'.
• szyfr[klucz[i + 1]] = klucz[i]: Dodaje do słownika odwrotny wpis, aby szyfrowanie działało w obie strony. Np. dla i=0, szyfr['A'] = 'G'.

Inicjalizacja zmiennej wynikowej:

• wynik = "": Tworzy pusty ciąg znaków, do którego będą dodawane przetworzone litery.

Przetwarzanie tekstu wejściowego:

• for litera in tekst:: Rozpoczyna pętlę, która przechodzi przez każdy znak (litera) w tekście wejściowym (tekst).

Konwersja bieżącej litery na wielką:

• litera_upper = litera.upper(): Zamienia bieżącą literę na wielką, aby sprawdzić, czy znajduje się ona w słowniku szyfr (który zawiera tylko wielkie litery jako klucze).

Sprawdzenie, czy litera jest w kluczu:

• if litera_upper in szyfr:: Sprawdza, czy wielka wersja bieżącej litery jest kluczem w słowniku szyfr. Jeśli tak, oznacza to, że ta litera podlega zamianie.

Wykonanie zamiany (jeśli litera jest w kluczu):

• if litera.islower():: Sprawdza, czy oryginalna litera była mała.
• wynik += szyfr[litera_upper].lower(): Jeśli tak, pobiera ze słownika literę do zamiany (szyfr[litera_upper]), zamienia ją na małą (.lower()) i dodaje do wynik.
• else:: W przeciwnym razie (jeśli oryginalna litera była wielka).
• wynik += szyfr[litera_upper]: Pobiera ze słownika literę do zamiany (która już jest wielka) i dodaje ją do wynik.

Obsługa liter spoza klucza:

• else:: Jeśli wielka wersja bieżącej litery nie jest kluczem w słowniku szyfr.
• wynik += litera: Dodaje oryginalną literę do wynik bez żadnej zmiany. Dotyczy to liter niebędących w kluczu oraz znaków niebędących literami (np. spacji, znaków interpunkcyjnych).

Zwrócenie wyniku:

• return wynik: Po przetworzeniu wszystkich liter z tekstu wejściowego, funkcja zwraca gotowy zaszyfrowany (lub odszyfrowany) ciąg znaków wynik.