C# / .NET Kompendium PLEN
.NET / C# / Bezpieczeństwo

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ć:

  1. Poufność: szyfrujesz kluczem publicznym odbiorcy, a odszyfrować może tylko właściciel klucza prywatnego.
  2. 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.

  3. Zalety: nie ma problemu dystrybucji klucza (publiczny można udostępniać), umożliwia podpisy i certyfikaty.

  4. 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

  1. ClientHello - klient wysyła obsługiwane szyfry, losową wartość i od razu swoją wartość publiczną ECDHE (key_share).
  2. 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.
  3. Z sekretu i skrótu dotychczasowej rozmowy funkcja HKDF wyprowadza klucze symetryczne. Od tej chwili reszta handshake'u jest już zaszyfrowana.
  4. Certificate - serwer wysyła certyfikat (łańcuch do zaufanego CA).
  5. CertificateVerify - serwer podpisuje skrót całej rozmowy swoim kluczem prywatnym, a klient weryfikuje podpis kluczem publicznym z certyfikatu.
  6. Finished - obie strony wysyłają kod uwierzytelniający (HMAC) całego handshake'u, co potwierdza, że nikt go nie zmienił.
  7. 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.Cryptography i 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ą.
Postaw mi kawę