AES

Advanced Encryption Standard (AES, česky standard pokročilého šifrování) je standardizovaný algoritmus používaný k šifrování dat v informatice. Jedná se o symetrickou blokovou šifru šifrující i dešifrující stejným klíčem data rozdělená do bloků pevně dané délky. Norma nahradila dříve užívanou šifru DES.


:.:

WiKi popis: cs.wikipedia.org/wiki/Advanced_Encryption_Standard


Další techničtější detaily:

AES S-box (Substitution box) je pole konstant, které se používá při šifrování a dešifrování dat. Toto pole je generováno pomocí následujících kroků:

  1. Multiplikativní inverze v Galoisově poli (2^8):
    • Každý bajt (8 bitů) je považován za prvek Galoisova pole GF(28)GF(2^8)GF(28).
    • Multiplikativní inverze každého bajtu se vypočítá pomocí algebraických operací v tomto poli. Inverse of zero is zero.
  2. Affine transformace:
    • Výsledky multiplikativní inverze jsou dále transformovány pomocí bitové affine transformace. Tento krok zvyšuje nelinearitu S-boxu a zajišťuje jeho kryptografickou bezpečnost.
def galois_multiplicative_inverse(byte):
    # Multiplikativní inverze v GF(2^8)
    if byte == 0:
        return 0
    for inverse in range(256):
        if galois_mult(byte, inverse) == 1:
            return inverse
    return 0

def galois_mult(a, b):
    p = 0
    while b:
        if b & 1:
            p ^= a
        a <<= 1
        if a & 0x100:
            a ^= 0x11B  # Primitive polynomial for GF(2^8)
        b >>= 1
    return p & 0xFF

def affine_transform(byte):
    # Affine transformace na byte
    matrix = [
        [1, 1, 1, 1, 1, 0, 0, 0],
        [0, 1, 1, 1, 1, 1, 0, 0],
        [0, 0, 1, 1, 1, 1, 1, 0],
        [0, 0, 0, 1, 1, 1, 1, 1],
        [1, 0, 0, 0, 1, 1, 1, 1],
        [1, 1, 0, 0, 0, 1, 1, 1],
        [1, 1, 1, 0, 0, 0, 1, 1],
        [1, 1, 1, 1, 0, 0, 0, 1]
    ]
    vector = [1, 1, 0, 0, 0, 1, 1, 0]

    result = 0
    for i in range(8):
        bit = 0
        for j in range(8):
            bit ^= ((byte >> j) & 1) * matrix[i][j]
        bit ^= vector[i]
        result |= bit << i

    return result & 0xFF

def generate_sbox():
    sbox = []
    for byte in range(256):
        inverse = galois_multiplicative_inverse(byte)
        transformed = affine_transform(inverse)
        sbox.append(transformed)
    return sbox

sbox = generate_sbox()

# Convert to 16x16 matrix for readability
sbox_matrix = [sbox[i:i+16] for i in range(0, 256, 16)]
for row in sbox_matrix:
    print([hex(x) for x in row])

Galoisova multiplikativní inverze:

Affine transformace:

Generování S-boxu:


Důvody a účely využití S-boxu:

  1. Nelinearita:
    • S-box je nelineární substituční operace, což znamená, že vstupní data jsou transformována způsobem, který není lineární. To je důležité pro ochranu proti lineárním kryptoanalytickým útokům. Nelineární transformace zajišťují, že malé změny ve vstupu způsobují složité a nepředvídatelné změny ve výstupu.
  2. Difúze:
    • S-box přispívá k difúzi, což znamená, že každý bit výstupu závisí na všech bitech vstupu. To pomáhá zajistit, že výstupní data jsou důkladně „promíchána“, což komplikuje pokusy o zpětné získání původního textu bez znalosti klíče.
  3. Odolnost proti algebraickým útokům:
    • Použití Galoisových polí a affine transformací v konstrukci S-boxu poskytuje odolnost proti algebraickým útokům. Algebraické vlastnosti S-boxu zajišťují, že útoky využívající algebraické rovnice jsou velmi obtížné.
  4. Kompaktnost a rychlost:
    • S-box může být efektivně implementován jako tabulka look-up, což znamená, že operace SubBytes může být velmi rychlá. Místo složitých výpočtů se jednoduše provede vyhledání hodnoty v předdefinované tabulce.

Jak S-box funguje v AES:

V AES se S-box používá v každém kole šifrování a dešifrování:

  1. SubBytes:
    • V každém kole šifrování (kromě posledního) je každý byte bloku nahrazen odpovídajícím byte z S-boxu.
    • Například, pokud je byte hodnota 0x53, je nahrazen hodnotou, která se nachází na pozici (5,3) v S-boxu.
  2. Inverse SubBytes:
    • V každém kole dešifrování (kromě posledního) je použit Inverse S-box, který je inverzní tabulkou k původnímu S-boxu. To umožňuje zpětnou substituci a obnovu původního plaintextu.


PKCS7 padding je metoda, která se používá k tomu, aby se zajistilo, že délka plaintextu je násobkem velikosti bloku před šifrováním. To je důležité, protože mnoho šifrovacích algoritmů, včetně těch v režimu CBC (Cipher Block Chaining), vyžaduje, aby data měla přesnou délku bloku.

Jak PKCS7 Padding funguje

  1. Padding Délka:
    • Pokud délka plaintextu není násobkem velikosti bloku (například 16 bajtů), PKCS7 padding přidá k plaintextu určitou délku paddingu, která je rovna počtu přidaných bajtů.
    • Paddingová délka je určena jako rozdíl mezi velikostí bloku a délkou plaintextu.
  2. Padding Bajte:
    • Všechny paddingové bajty mají hodnotu, která odpovídá počtu přidaných bajtů.
    • Například, pokud je velikost bloku 16 bajtů a délka plaintextu je 13 bajtů, přidají se 3 bajty paddingu. Tyto bajty budou mít hodnotu 03.


Python testy, vysvětlení a variace:
github.com/…agama_point_crypto/…/simple_aes_1gen.py – generování substituční tabulky
github.com/…agama_point_crypto/…/simple_dh_keys.py DH
github.com/…agama_point_crypto/…/simple_aes_3lib_dh.py DH keys + AES
github.com/…agama_point_crypto/…/simple_cbc_xor_test.py CBC_XOR
github.com/…agama_point_crypto/…/simple_sign_verify.py simple final DH/CBC/S_V