Kryptografia: szyfrowanie symetryczne i asymetryczne, hashowanie, TLS
Cztery podstawowe narzędzia
| Narzędzie | Do czego służy | Klucz | Przykłady |
|---|---|---|---|
| Szyfrowanie symetryczne | poufność dużych danych | jeden wspólny, tajny | AES-GCM, ChaCha20-Poly1305 |
| Szyfrowanie asymetryczne | wymiana kluczy, poufność krótkich danych | para: publiczny i prywatny | RSA, ECDH |
| Podpis cyfrowy | autentyczność i integralność, niezaprzeczalność | prywatny podpisuje, publiczny weryfikuje | RSA-PSS, ECDSA, Ed25519 |
| Hash / HMAC | skrót danych, kontrola integralności, hasła | brak (hash) lub tajny (HMAC) | SHA-256, HMAC-SHA256, PBKDF2, Argon2 |
Szyfrowanie symetryczne
Ten sam klucz szyfruje i deszyfruje:
tekst jawny --[ klucz K ]--> szyfrogram --[ ten sam klucz K ]--> tekst jawny
- Algorytmy: AES (klucze 128/192/256 bitów), ChaCha20. DES i 3DES są przestarzałe.
- Zalety: bardzo szybkie (sprzętowe AES-NI), nadaje się do dużych danych: plików, dysków, ruchu sieciowego.
- Wada: problem dystrybucji klucza - obie strony muszą znać ten sam sekret i trzeba go jakoś bezpiecznie przekazać.
- Tryby pracy: AES szyfruje jeden blok 16 B, a tryb decyduje, jak połączyć bloki. ECB jest niebezpieczny (takie same bloki dają takie same szyfrogramy i widać wzorce). Używaj AES-GCM (szyfruje i jednocześnie wykrywa modyfikację, tzw. AEAD) albo CBC z osobnym HMAC.
- Zasada krytyczna: nigdy nie używaj tego samego nonce z tym samym kluczem dwa razy w GCM - to łamie bezpieczeństwo.
Szyfrowanie asymetryczne
Klucze działają w parze: co zaszyfrujesz jednym, odszyfrujesz tylko drugim. Klucza prywatnego nie da się praktycznie wyliczyć z publicznego (RSA opiera się na trudności faktoryzacji dużych liczb, ECC na problemie logarytmu dyskretnego na krzywych eliptycznych).
Dwa zastosowania, które łatwo pomylić:
- Poufność: szyfrujesz kluczem publicznym odbiorcy, a odszyfrować może tylko właściciel klucza prywatnego.
-
Podpis cyfrowy: podpisujesz własnym kluczem prywatnym, a każdy sprawdza podpis Twoim kluczem publicznym. Dowodzi to, że dokument pochodzi od Ciebie i nie został zmieniony.
-
Zalety: nie ma problemu dystrybucji klucza (publiczny można udostępniać), umożliwia podpisy i certyfikaty.
- Wady: wolne (setki razy wolniejsze od AES), RSA szyfruje tylko krótkie dane, klucze są długie. Podobną siłę dają AES-128, RSA-3072 i ECC P-256, więc ECC jest znacznie krótsze i szybsze od RSA.
Porównanie
| Symetryczne | Asymetryczne | |
|---|---|---|
| Klucze | jeden wspólny, tajny | para: publiczny i prywatny |
| Szybkość | bardzo szybkie | wolne |
| Wielkość danych | dowolna | małe (praktycznie klucze, skróty) |
| Dystrybucja klucza | problem | rozwiązana (publiczny jest jawny) |
| Podpis cyfrowy | nie | tak |
| Typowe użycie | dane, dyski, ruch | wymiana kluczy, podpisy, certyfikaty |
Szyfrowanie hybrydowe - tak robi się to w praktyce
Asymetryczne rozwiązuje wymianę klucza, symetryczne szyfruje dane. Tak działa HTTPS (TLS) oraz szyfrowana poczta (PGP, S/MIME): treść idzie AES-em, a klucz AES jest uzgodniony lub zaszyfrowany kluczem publicznym odbiorcy.
Uzgadnianie klucza w TLS
Cel: klient i serwer mają dojść do wspólnego, tajnego klucza symetrycznego, mimo że rozmawiają przez sieć, którą ktoś może podsłuchiwać. Klucz nie jest nigdzie wysyłany - każda strona wylicza go sama.
Idea: Diffie-Hellman (DH / ECDHE)
Każda strona losuje tymczasowy sekret i wysyła tylko jego „obraz” (wartość publiczną). Ze swojego sekretu i cudzej wartości publicznej obie dochodzą do tej samej liczby. Przykład na małych liczbach (publiczne: p = 23, g = 5):
| Klient | Serwer | |
|---|---|---|
| losuje sekret | a = 6 | b = 15 |
| wysyła wartość publiczną | A = 5^6 mod 23 = 8 | B = 5^15 mod 23 = 19 |
| wylicza wspólny sekret | B^a mod 23 = 19^6 mod 23 = 2 | A^b mod 23 = 8^15 mod 23 = 2 |
Podsłuchujący widzi 23, 5, 8 i 19, ale bez a lub b nie obliczy 2. Przy prawdziwych, ogromnych liczbach (albo punktach na krzywej eliptycznej, stąd ECDHE, np. krzywe X25519 i P-256) wyliczenie sekretu z samych wartości publicznych jest praktycznie niewykonalne.
Przebieg handshake'u w TLS 1.3
- ClientHello - klient wysyła obsługiwane szyfry, losową wartość i od razu swoją wartość publiczną ECDHE (
key_share). - ServerHello - serwer wybiera szyfr (np.
TLS_AES_256_GCM_SHA384) i odsyła swoją wartość publiczną ECDHE. Obie strony potrafią już wyliczyć wspólny sekret. - Z sekretu i skrótu dotychczasowej rozmowy funkcja HKDF wyprowadza klucze symetryczne. Od tej chwili reszta handshake'u jest już zaszyfrowana.
- Certificate - serwer wysyła certyfikat (łańcuch do zaufanego CA).
- CertificateVerify - serwer podpisuje skrót całej rozmowy swoim kluczem prywatnym, a klient weryfikuje podpis kluczem publicznym z certyfikatu.
- Finished - obie strony wysyłają kod uwierzytelniający (HMAC) całego handshake'u, co potwierdza, że nikt go nie zmienił.
- Dalej idą dane aplikacji, szyfrowane symetrycznie (AES-GCM lub ChaCha20-Poly1305).
Handshake w TLS 1.3 trwa jedną podróż w obie strony (1-RTT). Istnieje też tryb 0-RTT przy wznawianiu sesji (szybszy, ale z ryzykiem powtórzenia żądania).
Dlaczego certyfikat jest niezbędny
Sam DH nie uwierzytelnia nikogo. Atakujący w środku (MITM) mógłby uzgodnić jeden klucz z klientem, a drugi z serwerem i podsłuchiwać obie strony. Dlatego serwer podpisuje handshake kluczem prywatnym, a klient weryfikuje podpis certyfikatem zaufanego CA. Asymetryczna kryptografia pełni tu dwie role: ECDHE tworzy klucz, a podpis (RSA/ECDSA) dowodzi tożsamości serwera. Więcej o certyfikatach: Zabezpieczanie WebAPI.
Forward secrecy (poufność wsteczna)
Klucze ECDHE są tymczasowe (ephemeral) - losowane na jedną sesję i po niej wyrzucane. Nawet jeśli za rok wycieknie klucz prywatny serwera, nie da się odszyfrować wcześniej zarejestrowanego ruchu, bo klucz sesji nie wynikał z długoterminowego klucza.
Stary sposób: TLS 1.2 z wymianą kluczy przez RSA
Klient generował losowy pre-master secret i szyfrował go kluczem publicznym RSA serwera. Działało, ale bez forward secrecy: kto zapisał ruch, a później zdobył klucz prywatny, odszyfrowałby wszystko. TLS 1.3 usunął wymianę kluczy przez RSA i zostawił tylko (EC)DHE.
Uzgadnianie klucza w TLS w skrócie (odpowiedź na rozmowie)
W TLS 1.3 klient i serwer wymieniają tymczasowe klucze publiczne ECDHE i każda strona wylicza z nich ten sam wspólny sekret, którego nikt nie przesyłał. Z sekretu HKDF wyprowadza klucze symetryczne do AES-GCM. Serwer dowodzi tożsamości, podpisując handshake kluczem prywatnym z certyfikatu, a ponieważ klucze DH są tymczasowe, ruch zachowuje forward secrecy.
Hashowanie, HMAC i hasła
- Hash (SHA-256) to funkcja jednokierunkowa: z danych powstaje skrót stałej długości, a z skrótu nie da się odzyskać danych. Mała zmiana danych daje zupełnie inny skrót. Służy do kontroli integralności i jako element podpisu.
- HMAC to hash z tajnym kluczem: dowodzi, że wiadomość nie została zmieniona i że ktoś znający klucz ją wysłał (np. podpis JWT w algorytmie HS256).
- Hasła: nie używaj samego SHA - jest zbyt szybki, więc atakujący sprawdza miliardy zgadnięć na sekundę. Użyj wolnej funkcji z solą: PBKDF2, bcrypt, scrypt lub Argon2 (ASP.NET Identity domyślnie używa PBKDF2). Sól (losowa, unikalna dla hasła) uniemożliwia atak tablicami tęczowymi, a porównanie wykonuj w stałym czasie (
CryptographicOperations.FixedTimeEquals).
Działający przykład - CryptoDemo
Aplikacja konsolowa .NET 8, bez dodatkowych pakietów (dotnet new console -n CryptoDemo, wklej Program.cs, dotnet run). Pokazuje kolejno: AES-GCM z wykryciem modyfikacji, RSA (szyfrowanie i podpis), Diffie-Hellmana na małych liczbach (A=8, B=19, wspólny sekret 2), ECDH z AES-GCM (szyfrowanie hybrydowe), ECDSA oraz hash, PBKDF2 i HMAC.
using System.Numerics;
using System.Security.Cryptography;
using System.Text;
static string Hex(byte[] data) => Convert.ToHexString(data)[..Math.Min(32, data.Length * 2)] + "...";
// ---------------------------------------------------------------
// 1. Symmetric encryption: AES-GCM (confidentiality + integrity)
// ---------------------------------------------------------------
Console.WriteLine("=== 1. AES-GCM (symmetric) ===");
byte[] key = RandomNumberGenerator.GetBytes(32); // 256-bit secret key
byte[] nonce = RandomNumberGenerator.GetBytes(AesGcm.NonceByteSizes.MaxSize); // 12 bytes, unique per message
byte[] plain = Encoding.UTF8.GetBytes("Top secret message");
byte[] cipher = new byte[plain.Length];
byte[] tag = new byte[AesGcm.TagByteSizes.MaxSize]; // 16 bytes
using (var aes = new AesGcm(key, tag.Length))
{
aes.Encrypt(nonce, plain, cipher, tag);
Console.WriteLine($"cipher: {Hex(cipher)}");
var decrypted = new byte[cipher.Length];
aes.Decrypt(nonce, cipher, tag, decrypted);
Console.WriteLine($"decrypted: {Encoding.UTF8.GetString(decrypted)}");
cipher[0] ^= 1; // an attacker flips one bit
try { aes.Decrypt(nonce, cipher, tag, new byte[cipher.Length]); }
catch (CryptographicException) { Console.WriteLine("tampered data detected (authentication tag mismatch)"); }
}
// ---------------------------------------------------------------
// 2. Asymmetric encryption and signature: RSA
// ---------------------------------------------------------------
Console.WriteLine("\n=== 2. RSA (asymmetric) ===");
using (var rsa = RSA.Create(2048))
{
byte[] data = Encoding.UTF8.GetBytes("short message");
// confidentiality: encrypt with the PUBLIC key, decrypt with the PRIVATE key
byte[] encrypted = rsa.Encrypt(data, RSAEncryptionPadding.OaepSHA256);
byte[] decrypted = rsa.Decrypt(encrypted, RSAEncryptionPadding.OaepSHA256);
Console.WriteLine($"RSA decrypted: {Encoding.UTF8.GetString(decrypted)}");
// signature: sign with the PRIVATE key, verify with the PUBLIC key
byte[] signature = rsa.SignData(data, HashAlgorithmName.SHA256, RSASignaturePadding.Pss);
bool valid = rsa.VerifyData(data, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pss);
bool validAfterChange = rsa.VerifyData(Encoding.UTF8.GetBytes("other message"), signature,
HashAlgorithmName.SHA256, RSASignaturePadding.Pss);
Console.WriteLine($"signature valid: {valid}, after changing the message: {validAfterChange}");
}
// ---------------------------------------------------------------
// 3. Key agreement (what happens in the TLS handshake)
// ---------------------------------------------------------------
Console.WriteLine("\n=== 3a. Diffie-Hellman on small numbers ===");
BigInteger p = 23, g = 5;
BigInteger a = 6, b = 15; // private values (never sent)
BigInteger A = BigInteger.ModPow(g, a, p); // public value of the client = 8
BigInteger B = BigInteger.ModPow(g, b, p); // public value of the server = 19
Console.WriteLine($"A={A}, B={B}");
Console.WriteLine($"client secret = {BigInteger.ModPow(B, a, p)}, server secret = {BigInteger.ModPow(A, b, p)}");
Console.WriteLine("\n=== 3b. ECDH (P-256) + AES-GCM: hybrid encryption ===");
using var client = ECDiffieHellman.Create(ECCurve.NamedCurves.nistP256);
using var server = ECDiffieHellman.Create(ECCurve.NamedCurves.nistP256);
// each side combines ITS private key with the OTHER side's public key
byte[] clientKey = client.DeriveKeyFromHash(server.PublicKey, HashAlgorithmName.SHA256);
byte[] serverKey = server.DeriveKeyFromHash(client.PublicKey, HashAlgorithmName.SHA256);
Console.WriteLine($"both sides derived the same 256-bit key: {clientKey.SequenceEqual(serverKey)}");
byte[] n2 = RandomNumberGenerator.GetBytes(12);
byte[] msg = Encoding.UTF8.GetBytes("hello over the 'TLS' channel");
byte[] ct = new byte[msg.Length];
byte[] t2 = new byte[16];
using (var sender = new AesGcm(clientKey, 16)) sender.Encrypt(n2, msg, ct, t2);
var pt = new byte[ct.Length];
using (var receiver = new AesGcm(serverKey, 16)) receiver.Decrypt(n2, ct, t2, pt);
Console.WriteLine($"server read: {Encoding.UTF8.GetString(pt)}");
// ---------------------------------------------------------------
// 4. Digital signature with elliptic curves: ECDSA
// ---------------------------------------------------------------
Console.WriteLine("\n=== 4. ECDSA (signature) ===");
using (var ecdsa = ECDsa.Create(ECCurve.NamedCurves.nistP256))
{
byte[] document = Encoding.UTF8.GetBytes("Invoice #123, total 100 PLN");
byte[] sig = ecdsa.SignData(document, HashAlgorithmName.SHA256);
Console.WriteLine($"valid: {ecdsa.VerifyData(document, sig, HashAlgorithmName.SHA256)}");
}
// ---------------------------------------------------------------
// 5. Hashing and password storage
// ---------------------------------------------------------------
Console.WriteLine("\n=== 5. Hash and password hashing ===");
byte[] sha = SHA256.HashData(Encoding.UTF8.GetBytes("abc")); // one-way, fast: NOT for passwords
Console.WriteLine($"SHA-256(abc) = {Convert.ToHexString(sha)[..16]}...");
byte[] salt = RandomNumberGenerator.GetBytes(16); // unique per password
byte[] hash = Rfc2898DeriveBytes.Pbkdf2("MyPassword!", salt, 600_000, HashAlgorithmName.SHA256, 32); // slow on purpose
byte[] attempt = Rfc2898DeriveBytes.Pbkdf2("MyPassword!", salt, 600_000, HashAlgorithmName.SHA256, 32);
Console.WriteLine($"password matches: {CryptographicOperations.FixedTimeEquals(hash, attempt)}"); // constant-time compare
// HMAC: a hash with a secret key (integrity + authenticity of a message)
byte[] mac = HMACSHA256.HashData(key, Encoding.UTF8.GetBytes("message"));
Console.WriteLine($"HMAC = {Hex(mac)}");
Jeśli wolisz mieć to w jednym fragmencie, najważniejsze są trzy linie ilustrujące hybrydę: każda strona łączy swój klucz prywatny z cudzym publicznym, a z wyniku powstaje klucz AES:
byte[] clientKey = client.DeriveKeyFromHash(server.PublicKey, HashAlgorithmName.SHA256);
byte[] serverKey = server.DeriveKeyFromHash(client.PublicKey, HashAlgorithmName.SHA256);
// clientKey == serverKey, and the key itself never travelled over the network
Najczęstsze pomyłki
- Hashowanie to nie szyfrowanie - skrótu nie da się odszyfrować.
- Base64 to kodowanie, a nie szyfrowanie.
- Klucz publiczny można ujawniać, prywatny nigdy - trzymaj go w Key Vault, HSM lub magazynie certyfikatów, nie w repozytorium.
- Własna kryptografia to zły pomysł - używaj
System.Security.Cryptographyi trybów AEAD. - Ten sam nonce dwa razy w AES-GCM niszczy bezpieczeństwo.
- ECB ujawnia wzorce w danych.
- Podpis to nie „szyfrowanie kluczem prywatnym” - w nowoczesnych schematach (PSS, ECDSA) to osobna operacja.
Pytania rekrutacyjne
- Czym różni się szyfrowanie symetryczne od asymetrycznego? Symetryczne używa jednego wspólnego klucza i jest szybkie, ale wymaga bezpiecznego przekazania klucza. Asymetryczne używa pary kluczy, rozwiązuje wymianę kluczy i umożliwia podpisy, ale jest wolne.
- Jak działa HTTPS? Klient i serwer uzgadniają klucz sesji przez ECDHE, serwer dowodzi tożsamości podpisem i certyfikatem, a dane szyfrowane są symetrycznie (AES-GCM).
- Co to forward secrecy? Klucze sesji są tymczasowe, więc wyciek klucza prywatnego serwera nie pozwala odszyfrować starego ruchu.
- Dlaczego sam Diffie-Hellman nie wystarcza? Nie uwierzytelnia stron, więc jest podatny na MITM. Potrzebny jest podpis i certyfikat.
- Hash, szyfrowanie i kodowanie? Hash jest jednokierunkowy, szyfrowanie odwracalne kluczem, kodowanie (Base64) odwracalne bez klucza.
- Jak przechowywać hasła? Wolna funkcja z solą (PBKDF2, bcrypt, Argon2), nigdy samo SHA ani szyfrowanie.
- Dlaczego tryb ECB jest zły? Takie same bloki jawne dają takie same szyfrogramy, więc wzorce przeciekają.