Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro· GoogleHugging Face LMArena Human Preference 140K

from cryptography.fernet import Fernet Generowanie klucza key = Fernet.generatekey()…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Amazon Novaamazon.nova-pro-v1:0’s answer.
  1. User

    from cryptography.fernet import Fernet

    Generowanie klucza

    key = Fernet.generate_key()

    Inicjalizacja obiektu do szyfrowania

    cipher = Fernet(key)

    Funkcja do szyfrowania wiadomości

    def encrypt_message(message): encrypted_message = cipher.encrypt(message.encode()) return encrypted_message

    Funkcja do deszyfrowania wiadomości

    def decrypt_message(encrypted_message): decrypted_message = cipher.decrypt(encrypted_message).decode() return decrypted_message

    Przykładowa wiadomość do zaszyfrowania

    message = "test"

    Szyfrowanie wiadomości

    encrypted_message = encrypt_message(message) print("Zaszyfrowana wiadomość:", encrypted_message)

    Deszyfrowanie wiadomości

    decrypted_message = decrypt_message(encrypted_message) print("Odszyfrowana wiadomość:", decrypted_message) print("\nKey: " + str(key))

  2. Gemini Assistant

    To bardzo dobry i zwięzły przykład użycia biblioteki cryptography do szyfrowania symetrycznego. Skrypt jest poprawny i robi dokładnie to, co powinien w ramach prostego demo.

    Oto moja szczegółowa analiza:

    Co jest zrobione dobrze?

    1. Właściwy wybór narzędzia: Użycie cryptography.fernet to świetna decyzja. Fernet to wysokopoziomowy standard, który jest "gotowy do użycia" i zaprojektowany tak, by był bezpieczny i prosty. Automatycznie zarządza takimi rzeczami jak szyfrowanie (AES-128-CBC), integralność danych (HMAC z SHA256) i wersjonowanie klucza, co chroni przed wieloma typowymi błędami implementacyjnymi.
    2. Poprawna obsługa typów danych: Prawidłowo konwertujesz wiadomość (string) na bajty (.encode()) przed szyfrowaniem i z powrotem na string (.decode()) po deszyfrowaniu. Fernet operuje wyłącznie na bajtach, więc jest to kluczowy krok.
    3. Czytelność i prostota: Kod jest bardzo łatwy do zrozumienia. Funkcje encrypt_message i decrypt_message jasno określają swoje zadanie.

    Co można by ulepszyć? (Kwestie praktyczne i bezpieczeństwa)

    Twój skrypt jest idealny jako demonstracja, ale w prawdziwej aplikacji napotkałby na kilka fundamentalnych problemów.

    1. Zarządzanie kluczem (NAJWAŻNIEJSZE):

      • Problem: Klucz jest generowany na nowo za każdym razem, gdy uruchamiasz skrypt. To oznacza, że wiadomość zaszyfrowana podczas jednego uruchomienia nie może być odszyfrowana podczas kolejnego, ponieważ nowy skrypt będzie miał już nowy, inny klucz.
      • Rozwiązanie: Klucz musisz wygenerować tylko raz, a następnie go bezpiecznie przechować i wczytywać, gdy będzie potrzebny do szyfrowania lub deszyfrowania. Nigdy nie przechowuj klucza w tym samym miejscu co zaszyfrowane dane.
    2. Zakres zmiennych (Scope):

      • Problem: Zmienna cipher jest zdefiniowana w globalnym zakresie. W małym skrypcie to działa, ale w większych aplikacjach jest to zła praktyka. Funkcje powinny być bardziej niezależne.
      • Rozwiązanie: Lepiej jest przekazywać klucz lub obiekt cipher jako argument do funkcji.
    3. Obsługa błędów:

      • Problem: Jeśli spróbujesz odszyfrować dane przy użyciu niewłaściwego klucza (co w Twoim skrypcie stanie się przy drugim uruchomieniu) lub jeśli zaszyfrowane dane zostaną uszkodzone, metoda cipher.decrypt() rzuci wyjątek InvalidToken. Twój skrypt w takiej sytuacji po prostu by się "wysypał".
      • Rozwiązanie: Wywołanie deszyfrowania powinno być umieszczone w bloku try...except.
    4. Bezpieczeństwo:

      • Problem: Na końcu skryptu drukujesz klucz na ekranie (print("\nKey: " + str(key))). W prawdziwym zastosowaniu jest to ogromne zagrożenie bezpieczeństwa. Klucz jest sekretem, który należy chronić za wszelką cenę.
      • Rozwiązanie: Nigdy nie loguj, nie drukuj ani nie ujawniaj klucza w niezabezpieczony sposób.

    Poprawiona wersja skryptu (bardziej praktyczna)

    Oto jak mógłby wyglądać ten skrypt, gdyby był przygotowany do bardziej realnego użycia. Pokazuje on, jak zapisać i wczytać klucz z pliku.

    from cryptography.fernet import Fernet
    from cryptography.fernet import InvalidToken
    import os
    
    KEY_FILE = "secret.key"
    
    # --- Funkcje do zarządzania kluczem ---
    def generate_and_save_key():
        """Generuje nowy klucz i zapisuje go do pliku."""
        key = Fernet.generate_key()
        with open(KEY_FILE, "wb") as key_file: # 'wb' - zapis binarny
            key_file.write(key)
        print(f"Nowy klucz został wygenerowany i zapisany w pliku: {KEY_FILE}")
        return key
    
    def load_key():
        """Wczytuje klucz z pliku."""
        if not os.path.exists(KEY_FILE):
            return generate_and_save_key()
            
        with open(KEY_FILE, "rb") as key_file: # 'rb' - odczyt binarny
            key = key_file.read()
        return key
    
    # --- Funkcje do szyfrowania/deszyfrowania ---
    def encrypt_message(message: str, key: bytes) -> bytes:
        """Szyfruje wiadomość (string) używając podanego klucza."""
        f = Fernet(key)
        encrypted_message = f.encrypt(message.encode())
        return encrypted_message
    
    def decrypt_message(encrypted_message: bytes, key: bytes) -> str | None:
        """Deszyfruje wiadomość używając podanego klucza. Zwraca None w przypadku błędu."""
        f = Fernet(key)
        try:
            decrypted_message = f.decrypt(encrypted_message).decode()
            return decrypted_message
        except InvalidToken:
            print("BŁĄD: Nieprawidłowy token lub klucz. Nie można odszyfrować wiadomości.")
            return None
    
    # --- Główna część skryptu ---
    if __name__ == "__main__":
        # Krok 1: Wczytaj klucz (lub wygeneruj, jeśli nie istnieje)
        encryption_key = load_key()
    
        # Krok 2: Przygotuj wiadomość
        original_message = "To jest moja super tajna wiadomość!"
        print(f"Oryginalna wiadomość: {original_message}")
    
        # Krok 3: Szyfrowanie
        encrypted = encrypt_message(original_message, encryption_key)
        print(f"Zaszyfrowana wiadomość: {encrypted}")
    
        # Krok 4: Deszyfrowanie
        decrypted = decrypt_message(encrypted, encryption_key)
        if decrypted:
            print(f"Odszyfrowana wiadomość: {decrypted}")
    
        # UWAGA: Nigdy nie drukuj klucza w prawdziwej aplikacji!
        # Robimy to tutaj tylko w celach demonstracyjnych.
        # print(f"\nUżyty klucz: {encryption_key}") 
    

    Podsumowanie

    Twój skrypt jest doskonałym punktem wyjścia i poprawnie pokazuje podstawową mechanikę szyfrowania. Moje uwagi dotyczą głównie przeniesienia tej koncepcji do świata rzeczywistego, gdzie zarządzanie kluczami i obsługa błędów stają się absolutnie krytyczne.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.