Cryptology Academy · Lektion

RSA- og ECDSA-nøglepar i Python

Generér, serialisér og anvend RSA- og EC-nøgler til signering og kryptering.

Lektion 3 af 413 trin

RSA- og ECDSA-nøglepar i Python er en gratis Cryptology Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Cryptology Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Cryptology Academy-kurset indeholder 4 lektioner i alt.

Oversigt over nøgleparoperationer

Pythons cryptography-bibliotek understøtter RSA og ECDSA til generering, signering, verifikation, serialisering og indlæsning af nøgler. Det er byggestenene til TLS-certifikater, kodesignering og JWT'er.

Generering af et RSA-nøglepar

Minimumsanbefaling: 2048 bit for kompatibilitet, 4096 bit til nøgler med lang levetid:

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")

RSA-signering med PSS

Brug altid PSS-padding til signaturer (ikke 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], "...")

Verifikation af RSA-signaturer

Verifikation udløser InvalidSignature ved fejl:

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")

Generering af et ECDSA-nøglepar

ECDSA med NIST P-256 (secp256r1) giver 128-bit sikkerhed med meget mindre nøgler end 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)

ECDSA-signering og -verifikation

ECDSA bruger som standard DER-kodede signaturer:

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")

Serialisering af nøgler til PEM

Gem nøgler i PEM-filer til opbevaring eller distribution:

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])

Indlæsning af nøgler fra PEM

Indlæs gemte nøgler i objekter igen:

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)

ECDH-nøgleaftale

Brug ECDH til at aflede en delt hemmelighed til symmetrisk kryptering:

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())

RSA-kryptering med OAEP

Ved kryptering af små datamængder (f.eks. en DEK) med RSA skal du altid bruge 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)

Valg mellem RSA og ECDSA

ECDSA: mindre signaturer (~71 byte for P-256 mod ~256 byte for RSA-2048), hurtigere signering og samme sikkerhedsniveau. RSA: bredere understøttelse af ældre systemer og en enklere mental model. Brug ECDSA P-256 eller Ed25519 til nye systemer.

Videnscheck

Hvorfor bør RSA-PSS foretrækkes frem for PKCS#1 v1.5 til digitale signaturer?

Besvar den i den interaktive lektion

Opsummering af lektionen

Brug rsa.generate_private_key til RSA og ec.generate_private_key til ECDSA. Signer med PSS (RSA) eller ECDSA + SHA-256. Serialiser til PEM med PKCS8-format og kryptering med adgangskode. Brug ECDH til nøgleaftale. Foretræk ECDSA P-256 eller Ed25519 til nye systemer.

Gratis at komme i gang

Lær Cryptology Academy med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 67
Lektioner: 261

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “RSA- og ECDSA-nøglepar i Python” gratis?

Ja — hele teksten til “RSA- og ECDSA-nøglepar i Python” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Cryptology Academy-kurset, skal du opgradere til CoddyKit PRO. Cryptology Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “RSA- og ECDSA-nøglepar i Python”?

Generér, serialisér og anvend RSA- og EC-nøgler til signering og kryptering. Du øver dig i Cryptology Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Cryptology Academy?

Der kræves ingen tidligere erfaring. Cryptology Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “RSA- og ECDSA-nøglepar i Python”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Cryptology Academy-lektion?

Ja. Alle Cryptology Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Oversigt over Python cryptography-biblioteket
AES-GCM: Kryptering og dekryptering i Python
RSA- og ECDSA-nøglepar i Python
Almindelige Python-kryptografifejl og sikre mønstre

← Tilbage til Cryptology Academy