Wikiszótár

Advanced Encryption Standard

Angol

Főnév

Advanced Encryption Standard (tsz. Advanced Encryption Standards)

  1. (informatika, algoritmusok) A AES (Advanced Encryption Standard) egy szimmetrikus kulcsú titkosítási algoritmus, amelyet széles körben használnak adatvédelemre. Az AES-t az amerikai NIST (National Institute of Standards and Technology) fejlesztette ki a DES (Data Encryption Standard) utódjaként.


Fő jellemzők

  1. Blokk titkosítás:
    • Az AES rögzített méretű 128 bites (16 bájtos) blokkokkal dolgozik.
    • A bemeneti adatot blokkokra osztja, és minden blokkot külön-külön titkosít.
  2. Kulcsméretek:
    • Támogatott kulcsméretek: 128-bit, 192-bit, és 256-bit.
    • A kulcsméret meghatározza a titkosítási körök számát:
      • 10 kör: 128 bites kulcs esetén.
      • 12 kör: 192 bites kulcs esetén.
      • 14 kör: 256 bites kulcs esetén.
  3. Biztonság:
    • Az AES biztonsága a matematikai nehézségen (pl. S-box, keverési lépések) alapul.
    • Jelenleg nincs ismert hatékony támadás, amely feltörné a teljes 256 bites AES-t.
  4. Alkalmazási területek:
    • HTTPS/TLS kapcsolat titkosítása.
    • VPN-ek, fájl titkosítás, adattárolás.


AES struktúra

Az AES algoritmus egy iteratív blokktitkosító algoritmus, amely négy alapvető lépésből áll minden körben:

1. SubBytes (Csere):

  • Egy nemlineáris S-box segítségével minden bájt átalakítása.

2. ShiftRows (Sor eltolás):

  • A mátrix második, harmadik és negyedik sorát eltoljuk különböző mértékben.

3. MixColumns (Oszlopkeverés):

  • Lineáris transzformáció az oszlopokon.

4. AddRoundKey (Körkulcs hozzáadása):

  • A jelenlegi blokk XOR művelettel történő kombinálása a körhöz tartozó kulccsal.

Kezdeti kulcshozzáadás:

  • Az első kör előtt egy XOR művelet történik a bemeneti blokkal és a kezdő kulccsal.

Utolsó kör:

  • A végső körben a MixColumns lépés kimarad.


Pszeudokód

AES(plain_text, key):
    key_schedule = KeyExpansion(key)
    state = plain_text XOR key_schedule[0]

    for round = 1 to N-1:
        SubBytes(state)
        ShiftRows(state)
        MixColumns(state)
        AddRoundKey(state, key_schedule[round])

    SubBytes(state)
    ShiftRows(state)
    AddRoundKey(state, key_schedule[N])

    return state

Python implementáció

Az alábbi implementáció bemutatja az AES algoritmus alapvető működését: 

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes

# Titkosítás
def aes_encrypt(plain_text, key):
    cipher = AES.new(key, AES.MODE_CBC)  # CBC mód
    ct_bytes = cipher.encrypt(pad(plain_text.encode(), AES.block_size))
    return cipher.iv, ct_bytes

# Visszafejtés
def aes_decrypt(iv, cipher_text, key):
    cipher = AES.new(key, AES.MODE_CBC, iv)
    pt = unpad(cipher.decrypt(cipher_text), AES.block_size)
    return pt.decode()

# Példa használat
key = get_random_bytes(16)  # 128 bites kulcs
plain_text = "Hello, AES titkosítás!"
iv, cipher_text = aes_encrypt(plain_text, key)
print("Titkosított szöveg:", cipher_text)

decrypted_text = aes_decrypt(iv, cipher_text, key)
print("Visszafejtett szöveg:", decrypted_text)

Kimenet: 

Titkosított szöveg: b'...'
Visszafejtett szöveg: Hello, AES titkosítás!

C++ implementáció

A következő implementáció a Crypto++ könyvtárat használja: 

#include <iostream>
#include <string>
#include <cryptopp/aes.h>
#include <cryptopp/modes.h>
#include <cryptopp/filters.h>
#include <cryptopp/osrng.h>

using namespace std;
using namespace CryptoPP;

string aes_encrypt(const string& plain_text, SecByteBlock& key, SecByteBlock& iv) {
    string cipher_text;

    // Titkosítás
    CBC_Mode<AES>::Encryption encryptor;
    encryptor.SetKeyWithIV(key, key.size(), iv);

    StringSource(plain_text, true,
                 new StreamTransformationFilter(encryptor,
                                                new StringSink(cipher_text)));

    return cipher_text;
}

string aes_decrypt(const string& cipher_text, SecByteBlock& key, SecByteBlock& iv) {
    string plain_text;

    // Visszafejtés
    CBC_Mode<AES>::Decryption decryptor;
    decryptor.SetKeyWithIV(key, key.size(), iv);

    StringSource(cipher_text, true,
                 new StreamTransformationFilter(decryptor,
                                                new StringSink(plain_text)));

    return plain_text;
}

int main() {
    AutoSeededRandomPool prng;

    // Kulcs és IV létrehozása
    SecByteBlock key(AES::DEFAULT_KEYLENGTH);
    SecByteBlock iv(AES::BLOCKSIZE);
    prng.GenerateBlock(key, key.size());
    prng.GenerateBlock(iv, iv.size());

    string plain_text = "Hello, AES titkosítás!";
    cout << "Eredeti szöveg: " << plain_text << endl;

    // Titkosítás
    string cipher_text = aes_encrypt(plain_text, key, iv);
    cout << "Titkosított szöveg: " << cipher_text << endl;

    // Visszafejtés
    string decrypted_text = aes_decrypt(cipher_text, key, iv);
    cout << "Visszafejtett szöveg: " << decrypted_text << endl;

    return 0;
}

Kimenet: 

Eredeti szöveg: Hello, AES titkosítás!
Titkosított szöveg: ...
Visszafejtett szöveg: Hello, AES titkosítás!

Összegzés

Előnyök:

  1. Biztonságos: AES a modern szabvány, amely ellenáll a legtöbb támadásnak.
  2. Gyors: Hatékony hardveres és szoftveres implementációk.
  3. Rugalmasság: Támogatja a 128, 192 és 256 bites kulcsokat.

Hátrányok:

  1. Statikus blokk hossz: Minden adatot 16 bájtos blokkokban kell kezelni.
  2. Kulcs menedzsment: A szimmetrikus kulcsok biztonságos tárolása és megosztása problémás lehet.

Az AES-t széles körben használják biztonságos kommunikációhoz, adattitkosításhoz és adatvédelemhez. Számos könyvtár és eszköz biztosít gyors és könnyen használható implementációkat Pythonban és C++-ban is.

További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=Advanced_Encryption_Standard&oldid=3479508”