Nonce va IV - bir marta ishlatiladigan qiymatlar

function korsat(string $nom, string $qiymat): void
{
    printf("%-14s %s%s", $nom . ':', $qiymat, PHP_EOL);
}

function gcm(string $matn, string $kalit, string $nonce): string
{
    $teg = '';
    return openssl_encrypt($matn, 'aes-256-gcm', $kalit,
        OPENSSL_RAW_DATA, $nonce, $teg);
}

$kalit = hex2bin(str_repeat('5e', 32));
$matn = 'Hisob raqami: 20208000';

// Har xil nonce - har xil shifrmatn
foreach (['01', '02', '03'] as $b) {
    $nonce = hex2bin(str_repeat($b, 12));
    printf('nonce %s...: %s%s', $b . $b,
        bin2hex(gcm($matn, $kalit, $nonce)), PHP_EOL);
}

$kalit = hex2bin(str_repeat('5e', 32));
$nonce = hex2bin(str_repeat('99', 12));   // BIR XIL nonce

$xabar1 = 'Toladi: 1000000 som';
$xabar2 = 'Toladi: 2500000 som';

$c1 = gcm($xabar1, $kalit, $nonce);
$c2 = gcm($xabar2, $kalit, $nonce);

korsat('shifr 1', bin2hex($c1));
korsat('shifr 2', bin2hex($c2));

// Ikki shifrmatnni XOR qilamiz
$xorShifr = $c1 ^ $c2;
$xorMatn = $xabar1 ^ $xabar2;

korsat('c1 XOR c2', bin2hex($xorShifr));
korsat('p1 XOR p2', bin2hex($xorMatn));
var_dump(hash_equals($xorShifr, $xorMatn));

$kalit = hex2bin(str_repeat('5e', 32));
$nonce = hex2bin(str_repeat('99', 12));

// Hujumchi 1-xabarni biladi (masalan, o'zi yuborgan)
$malum = 'Toladi: 1000000 som';
$sir = 'Toladi: 2500000 som';

$c1 = gcm($malum, $kalit, $nonce);
$c2 = gcm($sir, $kalit, $nonce);

// Hujumchida faqat c1, c2 va $malum bor - KALIT YO'Q
$tiklangan = ($c1 ^ $c2) ^ $malum;

korsat('malum matn', $malum);
korsat('tiklangan', $tiklangan);
korsat('haqiqiy sir', $sir);
var_dump($tiklangan === $sir);

// 12 baytlik (96 bit) nonce - GCM standarti
$bitlar = 96;

echo 'nonce uzunligi: ', $bitlar, ' bit', PHP_EOL;
echo 'variantlar:     2^', $bitlar, PHP_EOL;

// Tug'ilgan kun paradoksi: ~2^(n/2) dan keyin to'qnashuv ehtimoli sezilarli
$xavfsiz = 2 ** ($bitlar / 2);
printf('xavfsiz chegara: 2^%d = %s xabar%s',
    $bitlar / 2, number_format($xavfsiz, 0, '.', ' '), PHP_EOL);

// Amaliy tavsiya - undan ancha past
$tavsiya = 2 ** 32;
printf('amaliy tavsiya:  2^32 = %s xabar (bitta kalit uchun)%s',
    number_format($tavsiya, 0, '.', ' '), PHP_EOL);

// Soniyasiga 1000 xabar bo'lsa
$kunlar = $tavsiya / 1000 / 86400;
printf('1000 xabar/sek tezlikda: %.0f kun%s', $kunlar, PHP_EOL);

// XATO: har jarayon o'z hisoblagichini nolga qo'yadi
final class XatoHisoblagich
{
    private int $son = 0;

    public function keyingi(): string
    {
        return str_pad(pack('J', $this->son++), 12, "\x00", STR_PAD_LEFT);
    }
}

$server1 = new XatoHisoblagich();
$server2 = new XatoHisoblagich();   // ikkinchi server / qayta ishga tushirish

echo 'server 1: ', bin2hex($server1->keyingi()), PHP_EOL;
echo 'server 1: ', bin2hex($server1->keyingi()), PHP_EOL;
echo 'server 2: ', bin2hex($server2->keyingi()), PHP_EOL;

echo PHP_EOL, 'server 2 ning birinchi nonce i server 1 nikini TAKRORLADI',
    PHP_EOL;

final class XavfsizShifr
{
    private const NONCE = 12;

    public function __construct(private readonly string $kalit) {}

    public function shifrla(string $matn): string
    {
        // Nonce har chaqiruvda YANGI va TASODIFIY
        $nonce = random_bytes(self::NONCE);
        $teg = '';

        $shifr = openssl_encrypt($matn, 'aes-256-gcm', $this->kalit,
            OPENSSL_RAW_DATA, $nonce, $teg);

        // Nonce shifrmatn bilan birga saqlanadi - u maxfiy emas
        return $nonce . $teg . $shifr;
    }

    public function och(string $paket): string
    {
        if (strlen($paket) < self::NONCE + 16) {
            throw new RuntimeException('paket juda qisqa');
        }

        $nonce = substr($paket, 0, self::NONCE);
        $teg = substr($paket, self::NONCE, 16);
        $shifr = substr($paket, self::NONCE + 16);

        $matn = openssl_decrypt($shifr, 'aes-256-gcm', $this->kalit,
            OPENSSL_RAW_DATA, $nonce, $teg);

        if ($matn === false) {
            throw new RuntimeException('butunlik tekshiruvi otmadi');
        }

        return $matn;
    }
}

$shifr = new XavfsizShifr(hex2bin(str_repeat('5e', 32)));

$matn = 'Toladi: 1000000 som';

// Bir xil matnni 5 marta shifrlaymiz
$paketlar = [];
for ($i = 0; $i < 5; $i++) {
    $paketlar[] = $shifr->shifrla($matn);
}

// Hammasi har xilmi?
echo 'noyob paketlar: ', count(array_unique($paketlar)), ' / 5', PHP_EOL;

// Nonce lar ham har xilmi?
$noncelar = array_map(static fn(string $p): string => substr($p, 0, 12),
    $paketlar);
echo 'noyob noncelar: ', count(array_unique($noncelar)), ' / 5', PHP_EOL;

// Hammasi to'g'ri ochiladimi?
$ochildi = array_map(static fn(string $p): string => $shifr->och($p),
    $paketlar);
echo 'hammasi ochildi: ',
    count(array_unique($ochildi)) === 1 && $ochildi[0] === $matn
        ? 'ha' : 'yoq', PHP_EOL;

$kalit = hex2bin(str_repeat('11', 32));

// CBC da IV faqat noyob emas, TAXMIN QILIB BO'LMAYDIGAN bo'lishi kerak
$matn = 'Hisob: 20208000';

// Ketma-ket IV - noyob, lekin taxmin qilinadi
foreach ([1, 2, 3] as $n) {
    $iv = str_pad(pack('J', $n), 16, "\x00", STR_PAD_LEFT);
    $s = openssl_encrypt($matn, 'aes-256-cbc', $kalit, OPENSSL_RAW_DATA, $iv);
    printf('IV=%d -> %s%s', $n, substr(bin2hex($s), 0, 32), PHP_EOL);
}

echo PHP_EOL, 'Bu IV lar NOYOB, lekin keyingisini taxmin qilish oson', PHP_EOL;

$jadval = [
    ['Uzunlik', '12 bayt', '16 bayt'],
    ['Noyob bolishi', 'MAJBURIY', 'MAJBURIY'],
    ['Taxminlanmasligi', 'shart emas', 'MAJBURIY'],
    ['Maxfiymi', 'yoq', 'yoq'],
    ['Qayerda saqlanadi', 'shifrmatn bilan', 'shifrmatn bilan'],
    ['Takrorlansa', 'HALOKAT', 'jiddiy zaiflik'],
];

printf("%-20s %-16s %s%s", '', 'GCM nonce', 'CBC IV', PHP_EOL);
echo str_repeat('-', 56), PHP_EOL;
foreach ($jadval as $q) {
    printf("%-20s %-16s %s%s", ...[...$q, PHP_EOL]);
}