0Pricing
Cryptology Academy · Lekcja

Pary kluczy RSA i ECDSA w Pythonie

Generować, serializować i używać kluczy RSA oraz EC do podpisywania i szyfrowania

Pary kluczy RSA i ECDSA w Pythonie to bezpłatna lekcja Cryptology Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Cryptology Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Cryptology Academy zawiera 4 lekcji w sumie.

Omówienie operacji na parach kluczy

Biblioteka cryptography dla Pythona obsługuje RSA i ECDSA do generowania kluczy, podpisywania, weryfikowania, serializowania i wczytywania. Są to podstawowe elementy certyfikatów TLS, podpisywania kodu i JWT.

Generowanie pary kluczy RSA

Minimalne zalecenie: 2048 bitów dla zgodności, 4096 bitów dla kluczy używanych przez długi czas:

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.backends import default_backend

private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
    backend=default_backend()
)
public_key = private_key.public_key()
print("RSA key generated, size:", private_key.key_size, "bits")

Podpisywanie RSA za pomocą PSS

Do podpisów zawsze używaj dopełnienia PSS (nie PKCS#1 v1.5):

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding

message = b"document to sign"
signature = private_key.sign(
    message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)
print("RSA-PSS signature:", signature.hex()[:32], "...")

Weryfikowanie podpisu RSA

Weryfikacja w przypadku niepowodzenia zgłasza InvalidSignature:

from cryptography.exceptions import InvalidSignature

try:
    public_key.verify(
        signature,
        message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("Signature valid!")
except InvalidSignature:
    print("Signature INVALID")

Generowanie pary kluczy ECDSA

ECDSA z NIST P-256 (secp256r1) zapewnia 128-bitowy poziom bezpieczeństwa przy znacznie mniejszych kluczach niż RSA-3072:

from cryptography.hazmat.primitives.asymmetric import ec

private_key = ec.generate_private_key(ec.SECP256R1())
public_key = private_key.public_key()
print("EC private key generated on curve:", private_key.curve.name)

Podpisywanie i weryfikowanie ECDSA

ECDSA domyślnie używa podpisów zakodowanych w formacie DER:

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes
from cryptography.exceptions import InvalidSignature

# Sign
sig = private_key.sign(b"my data", ec.ECDSA(hashes.SHA256()))
print("ECDSA signature bytes:", len(sig))

# Verify
try:
    public_key.verify(sig, b"my data", ec.ECDSA(hashes.SHA256()))
    print("ECDSA signature valid")
except InvalidSignature:
    print("Invalid")

Serializacja kluczy do PEM

Zapisuj klucze w plikach PEM na potrzeby przechowywania lub dystrybucji:

from cryptography.hazmat.primitives import serialization

# Private key — encrypted with passphrase
private_pem = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.BestAvailableEncryption(b"strong-passphrase")
)

# Public key — no encryption
public_pem = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)
print(public_pem.decode()[:64])

Wczytywanie kluczy z PEM

Wczytaj zapisane klucze z powrotem do obiektów:

from cryptography.hazmat.primitives.serialization import (
    load_pem_private_key, load_pem_public_key
)

with open("ec_private.pem", "rb") as f:
    priv = load_pem_private_key(f.read(), password=b"strong-passphrase")

with open("ec_public.pem", "rb") as f:
    pub = load_pem_public_key(f.read())

print("Loaded EC key curve:", priv.curve.name)

Uzgadnianie klucza ECDH

Używaj ECDH do wyprowadzania wspólnego sekretu na potrzeby szyfrowania symetrycznego:

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.hkdf import HKDF

alice_priv = ec.generate_private_key(ec.SECP256R1())
bob_priv = ec.generate_private_key(ec.SECP256R1())

# Alice computes shared secret
shared = alice_priv.exchange(ec.ECDH(), bob_priv.public_key())
aes_key = HKDF(hashes.SHA256(), 32, None, b"app-context").derive(shared)
print("Derived AES key:", aes_key.hex())

Szyfrowanie RSA za pomocą OAEP

Do szyfrowania małych danych (np. DEK) za pomocą RSA zawsze używaj OAEP:

from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes

# Encrypt with public key
ciphertext = public_key.encrypt(
    b"small secret",
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# Decrypt with private key
plaintext = private_key.decrypt(ciphertext, padding.OAEP(
    mgf=padding.MGF1(algorithm=hashes.SHA256()),
    algorithm=hashes.SHA256(), label=None
))
print("Decrypted:", plaintext)

Wybór między RSA a ECDSA

ECDSA: mniejsze podpisy (około 71 bajtów dla P-256 w porównaniu z około 256 bajtami dla RSA-2048), szybsze podpisywanie i ten sam poziom bezpieczeństwa. RSA: szersza obsługa starszych systemów i prostszy model mentalny. W nowych systemach używaj ECDSA P-256 lub Ed25519.

Sprawdzenie wiedzy

Dlaczego w przypadku podpisów cyfrowych należy preferować RSA-PSS zamiast PKCS#1 v1.5?

Podsumowanie lekcji

Używaj rsa.generate_private_key dla RSA oraz ec.generate_private_key dla ECDSA. Podpisuj za pomocą PSS (RSA) lub ECDSA + SHA-256. Serializuj do PEM w formacie PKCS8 i stosuj szyfrowanie za pomocą hasła. Używaj ECDH do uzgadniania klucza. W nowych systemach preferuj ECDSA P-256 lub Ed25519.

Często zadawane pytania

Czy lekcja „Pary kluczy RSA i ECDSA w Pythonie” jest bezpłatna?

Tak — pełny tekst „Pary kluczy RSA i ECDSA w Pythonie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Cryptology Academy, przejdź na CoddyKit PRO. Kurs Cryptology Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Pary kluczy RSA i ECDSA w Pythonie”?

Generować, serializować i używać kluczy RSA oraz EC do podpisywania i szyfrowania Ćwiczysz Cryptology Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Cryptology Academy?

Nie wymagamy żadnego doświadczenia. Cryptology Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Pary kluczy RSA i ECDSA w Pythonie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Cryptology Academy?

Tak. Każda lekcja Cryptology Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Przegląd biblioteki cryptography dla języka Python
  2. Szyfrowanie i odszyfrowywanie AES-GCM w Pythonie
  3. Pary kluczy RSA i ECDSA w Pythonie
  4. Typowe pułapki kryptograficzne w Pythonie i bezpieczne wzorce
← Powrót do Cryptology Academy