Към съдържанието
wannacode

Криптографията, която не пишеш сам

Накратко: Криптографията се взима от стандартната библиотека, не се пише сама: криптографски случайни числа, сравнение за постоянно време и шифроване с проверка като AES-GCM.

Проблем

Кодът, който някой вече знае

Магазинът праща код от 6 цифри при „забравена парола“. Същият генератор прави и кодовете за отстъпка в бюлетина. Кодът изглежда случаен: 807592, 213904, 566120.

Една нощ някой сменя паролата на купувач и пазарува с картата му. Не е отгатвал милион кодове: пробвал е един. Знаел е кода, преди купувачът да отвори имейла си.

Генераторът е new Random((int)started), а started е секундата, в която магазинът е тръгнал.

Идеята

Random е формула, не случайност

Random е генератор на псевдослучайни числа: формула, която от едно число (семе) смята редица, която изглежда случайна. Едно и също семе дава една и съща редица. За игри, симулации и тестове това е полезно. За тайни е катастрофа: който знае семето или може да го отгатне, знае всяко следващо число.

Семето на магазина е секундата на старта. Атакуващият знае, че магазинът е рестартиран през нощта: 3600 възможности. Той има свой код за отстъпка от бюлетина. Пробва всяко семе, докато първият код съвпадне с неговия. Тогава следващият код на неговото копие е кодът на купувача.

За всичко, което трябва да е тайно и непредсказуемо (токени, кодове, ключове, salt, nonce), се ползва криптографски генератор. Той взима случайност от операционната система (събития от хардуера, шум) и е направен така, че от изхода му да не може да се изчисли следващият.

Виж го

Атакуващият пробва всяка секунда

static string ResetToken()
{
    var bytes = RandomNumberGenerator.GetBytes(32);
    return Base64Url.EncodeToString(bytes);
}


static string Code() =>
    RandomNumberGenerator.GetInt32(1_000_000)
        .ToString("D6");
Стъпка по стъпка, с думи
  1. Магазинът прави кодовете с Random, а семето е секундата на старта: 03:40:17. Първият код отива в бюлетина, и при атакуващия.
  2. Следващото число от същия генератор е кодът за смяна на паролата на купувач. Отива по имейл.
  3. Атакуващият знае, че магазинът е рестартиран през нощта. Пробва всяка секунда от 03:00: по един генератор за секунда.
  4. На опит 2418 първият код е същият като неговия код за отстъпка. Това е семето: 03:40:17.
  5. Следващото число на неговото копие е кодът на купувача. Сменя паролата и взима акаунта.
  6. Поправката: байтовете идват от криптографския генератор на операционната система. Семе за отгатване няма.
  7. 3600 опита или 3 милиона: нищо. Токенът е 32 случайни байта, а и кодът от 6 цифри вече не се предсказва.
static string Code(Random random) =>
    random.Next(1_000_000).ToString("D6");


static string? PredictNext(
    string seen, long from, int window)
{
    for (int i = 0; i < window; i++)
    {
        var guess = new Random((int)(from + i));
        if (Code(guess) == seen)
        {
            Console.WriteLine($"Семе: опит {i + 1}");
            return Code(guess);
        }
    }
    return null;
}
long night = 1_793_070_000; // 27.10.2026, 03:00 UTC
long started = night + 2_417; // магазинът е рестартиран в 03:40:17
var random = new Random((int)started);
var discount = Code(random);
var reset = Code(random);
Console.WriteLine($"Код за отстъпка от бюлетина (у атакуващия): {discount}");
var predicted = PredictNext(discount, night, 3_600);
Console.WriteLine($"Предсказан код за смяна на паролата: {predicted}");
Console.WriteLine($"Истинският код, пратен на купувача: {reset}");
Изход
Код за отстъпка от бюлетина (у атакуващия): 541336
Семе: опит 2418
Предсказан код за смяна на паролата: 652332
Истинският код, пратен на купувача: 652332

Кодовете на четирите езика са различни, защото генераторите са различни. Опитът е един и същ: 2418, защото семето е 03:40:17.

Идеята

Криптографският генератор на всеки език

static string ResetToken()
{
    var bytes = RandomNumberGenerator.GetBytes(32);
    return Base64Url.EncodeToString(bytes);
}


static string Code() =>
    RandomNumberGenerator.GetInt32(1_000_000)
        .ToString("D6");
var first = ResetToken();
var second = ResetToken();
Console.WriteLine($"Дължина на токена: {first.Length}");
Console.WriteLine($"Само A–Z, a–z, 0–9, - и _: {Regex.IsMatch(first, "^[A-Za-z0-9_-]+$")}");
Console.WriteLine($"Два токена подред са различни: {first != second}");
Console.WriteLine($"Кодът е 6 цифри: {Regex.IsMatch(Code(), "^[0-9]{6}$")}");
Изход
Дължина на токена: 43
Само A–Z, a–z, 0–9, - и _: True
Два токена подред са различни: True
Кодът е 6 цифри: True

Токенът е 32 байта (256 бита), записани с Base64 за адреси: 43 знака, които могат да стоят в линк. Да се отгатне е колкото да се отгатне ключ на AES-256.

RandomNumberGenerator има статични методи: GetBytes, GetInt32, GetString. Base64Url (от .NET 9, System.Buffers.Text) пише без +, / и =. Random.Shared е бърз, но не е криптографски.

Пробвай

Предвиди изхода

Два генератора с едно и също семе. Какво ще отпечата?

var a = new Random(42);
var b = new Random(42);
Console.WriteLine(a.Next(100) == b.Next(100));
Console.WriteLine(a.Next(100) == b.Next(100));
Отговор

Пробвай

Попълни

Токен за смяна на паролата, от криптографския генератор:

var bytes = RandomNumberGenerator.(32);

Пробвай

Намери грешката

Токенът е дълъг и изглежда сигурен. Кой ред го прави предсказуем?

Избери реда с грешката.

Идеята

Сравнението, което не издава нищо

Когато магазинът проверява кода от имейла, той го сравнява с пазения. Обикновеното сравнение на низове спира при първата разлика. Колкото повече знаци от началото са верни, толкова по-дълго трае. По мрежата разликата е наносекунди, но с много опити и статистика се мери. Така атакуващият познава знак по знак: 10 опита за първия, 10 за втория…

Програмата долу не мери време: тя брои колко знака гледа сравнението, а то е същото, което прави времето различно.

// Какво прави == отвътре: спира при първата разлика
static int ComparedChars(string secret, string guess)
{
    int i = 0;
    while (i < secret.Length && secret[i] == guess[i])
    {
        i++;
    }
    return Math.Min(i + 1, secret.Length);
}
var secret = "481937";
foreach (var guess in new[] { "000000", "400000", "480000", "481000" })
{
    Console.WriteLine($"{guess}: сравнени знаци {ComparedChars(secret, guess)}");
}
var expected = Encoding.UTF8.GetBytes(secret);
foreach (var guess in new[] { "481000", "481937" })
{
    var given = Encoding.UTF8.GetBytes(guess);
    Console.WriteLine($"{guess}: FixedTimeEquals = {CryptographicOperations.FixedTimeEquals(expected, given)}");
}
Изход
000000: сравнени знаци 1
400000: сравнени знаци 2
480000: сравнени знаци 3
481000: сравнени знаци 4
481000: FixedTimeEquals = False
481937: FixedTimeEquals = True

Сравнението за постоянно време гледа всички байтове, каквото и да намери, и времето не зависи от това колко е познато. Всеки език го има готово: CryptographicOperations.FixedTimeEquals. Ползва се за всичко тайно, което идва отвън: кодове, токени, подписи на JWT, HMAC.

Идеята

Шифроване: готов алгоритъм от готова библиотека

Магазинът пази IBAN-а на купувачите, които връщат стока. В базата той трябва да е шифрован, а при четене трябва да е сигурно, че никой не го е подменил. Двете ги прави шифроване с проверка (authenticated encryption). Стандартът е AES-GCM: шифрова и добавя таг от 16 байта. Ако се смени и един бит, тагът не съвпада и разшифроването спира с грешка.

AES-GCM е в стандартната библиотека:
static (byte[] Box, byte[] Tag) Encrypt(byte[] key, byte[] nonce, string text)
{
    using var aes = new AesGcm(key, AesGcm.TagByteSizes.MaxSize);
    var plain = Encoding.UTF8.GetBytes(text);
    var box = new byte[plain.Length];
    var tag = new byte[AesGcm.TagByteSizes.MaxSize];
    aes.Encrypt(nonce, plain, box, tag);
    return (box, tag);
}


static string Decrypt(byte[] key, byte[] nonce, byte[] box, byte[] tag)
{
    using var aes = new AesGcm(key, tag.Length);
    var plain = new byte[box.Length];
    aes.Decrypt(nonce, box, tag, plain);
    return Encoding.UTF8.GetString(plain);
}
var key = RandomNumberGenerator.GetBytes(32); // в истинския магазин: от хранилището за тайни
var nonce = RandomNumberGenerator.GetBytes(12); // нов за всяко съобщение
var (box, tag) = Encrypt(key, nonce, "BG80 BNBG 9661 1020 3456 78");
Console.WriteLine($"Шифрован: {box.Length + tag.Length} байта");
Console.WriteLine($"Разшифрован: {Decrypt(key, nonce, box, tag)}");
box[5] ^= 1;
try
{
    Decrypt(key, nonce, box, tag);
}
catch (AuthenticationTagMismatchException)
{
    Console.WriteLine("Подменен един байт: проверката на тага не мина, отказвам");
}
Изход
Шифрован: 43 байта
Разшифрован: BG80 BNBG 9661 1020 3456 78
Подменен един байт: проверката на тага не мина, отказвам
Шифрованият IBAN е 27 байта текст и 16 байта таг. Ключът е 32 случайни байта, а в истинския магазин идва от хранилището за тайни, както в урока за тайните. Nonce-ът е 12 случайни байта, нови за всяко съобщение: два текста с един ключ и един nonce издават връзката между тях. Nonce-ът не е тайна и се пази до шифрования текст.

Виж го

Своята схема, разбита в няколко реда

Колега решава, че AES е „прекалено сложно“, и пише свое шифроване: всеки байт XOR с байт от тайна дума. Изглежда като шум. Но XOR се обръща сам, а всяка фактура започва с едни и същи думи:

static byte[] Xor(byte[] data, byte[] key)
{
    var result = new byte[data.Length];
    for (int i = 0; i < data.Length; i++)
    {
        result[i] = (byte)(data[i] ^ key[i % key.Length]);
    }
    return result;
}
var key = Encoding.UTF8.GetBytes("SHOP2026"); // „тайният“ ключ на магазина
var invoice = Xor(Encoding.UTF8.GetBytes("ФАКТУРА 2026-0142, общо 249,90 €"), key);
var iban = Xor(Encoding.UTF8.GetBytes("BG80 BNBG 9661 1020 3456 78"), key);
// атакуващият: всяка фактура започва така
var known = Encoding.UTF8.GetBytes("ФАКТУРА ");
var found = Xor(invoice[..8], known[..8]);
Console.WriteLine($"Ключът е: {Encoding.UTF8.GetString(found)}");
Console.WriteLine($"Друго съобщение: {Encoding.UTF8.GetString(Xor(iban, found))}");
Изход
Ключът е: SHOP2026
Друго съобщение: BG80 BNBG 9661 1020 3456 78

Тайната дума излиза от първите 8 байта на една фактура, а с нея се чете всичко, шифровано някога. Не са нужни математика и милиарди опити, само известно начало на текста.

Това е правилото на урока: не измисляй своя криптография. Не своя алгоритъм, не своя схема около готов алгоритъм, не свой генератор. Хората, които правят криптография, публикуват схемите си и чакат години други да ги чупят. Ползваш тяхната работа през библиотека.

По-точно, за любопитните

Кое за какво.

  • Пароли: бавен hash със salt (bcrypt, argon2id), урокът за паролите. Никога шифроване: паролата не трябва да може да се разчете обратно.
  • Подпис на съобщение с общ ключ: HMAC-SHA256, както в JWT.
  • Шифроване на данни: AES-GCM (или ChaCha20-Poly1305) с ключ от хранилище за тайни.
  • Токени и кодове: криптографският генератор.
  • Hash за цялост на файл: SHA-256 или SHA-512, както в урока за зависимостите. MD5 и SHA-1 са счупени за това.

Библиотеки на по-високо ниво. AES-GCM пак иска да не повториш nonce и да пазиш ключа. Библиотеките като libsodium (NaCl), Google Tink и Fernet в cryptography на Python скриват и тези решения: имаш encrypt(key, text) и decrypt(key, box), без режими и nonce.

Сравнение за постоянно време отвътре. Сравнява всички байтове и събира разликите с XOR и OR: diff |= a[i] ^ b[i], а накрая проверява diff == 0. Няма ранно излизане. Не го пишеш сам: компилаторът може да го „оптимизира“; готовите функции са направени така, че да не стане.

Кодът от 6 цифри. Дори от криптографски генератор, 6 цифри са милион възможности. Затова кодът изтича след минути и се заключва след няколко грешни опита. Токенът в линк е 32 байта и тези ограничения не са нужни за отгатването, а за изтичане (например в лог).

UUID. UUID.randomUUID() в Java, uuid.uuid4() в Python и crypto.randomUUID() в Node са от криптографски генератор. Guid.NewGuid() в .NET на практика също, но документацията не го обещава, затова за тайни ползвай RandomNumberGenerator. Самият UUID е 122 случайни бита: става за id, но токенът от 32 байта е по-ясен.

Упражнение

Кодове за отстъпка

Реши задачата в редактора си.

Магазинът иска кодове за отстъпка от 10 знака, които се четат лесно: само главни латински букви и цифри, без 0, O, 1 и I, които се бъркат. Азбуката е ABCDEFGHJKLMNPQRSTUVWXYZ23456789 (32 знака, 50 бита на код). Напиши DiscountCode с криптографския генератор, направи 1000 кода и провери, че всички са от азбуката и са различни:

Изход
Кодове: 1000
Всеки е 10 знака от азбуката: True
Различни: 1000
Подсказка: RandomNumberGenerator.GetString(азбука, дължина) (от .NET 8) прави точно това.

Още задачи

  • Изтичане. Пази до всеки код кога е направен и отказвай кодове, по-стари от 15 минути.
  • Опити. Заключвай кода след 5 грешни опита и брой опитите.
  • Без модул. Защо ALPHABET[randomByte % 32] е наред, а ALPHABET[randomByte % 30] не е? (Подсказка: 256 се дели на 32, но не и на 30.)

Тест

Провери се

1. Защо код от Random със семе е опасен за смяна на паролата, дори да е дълъг 32 знака?
2. Кое е криптографски генератор?
3. Защо токенът се сравнява с MessageDigest.isEqual / FixedTimeEquals / compare_digest / timingSafeEqual, а не с ==?
4. Магазинът „шифрова“ фактурите с XOR и тайна дума от 8 букви. Всяка фактура започва с „ФАКТУРА “. Колко трудно е да се намери думата?

Създаден от Иво Гергов като част от кампанията на Evo Tech за достъпно обучение по програмиране ·