Home /Modules/crypto/aes.c

aes.c

crypto/src/aes.c · 271 line(s) · c

/*
 * crypto/src/aes.c
 * AES-128/192/256 — FIPS 197 reference implementation (table-free S-box).
 *
 * SECURITY NOTE: this is a correct REFERENCE implementation. It is NOT
 * constant-time (S-box/field ops leak via caches/timing) and must not be used
 * to protect real data. See crypto/include/slcrypto.h.
 */
#include "slcrypto.h"
#include <string.h>

static const uint8_t SBOX[256] = {
0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16
};

static uint8_t INV_SBOX[256];
static int inv_ready = 0;
static void build_inv(void) {
    if (inv_ready) return;
    for (int i = 0; i < 256; i++) INV_SBOX[SBOX[i]] = (uint8_t)i;
    inv_ready = 1;
}

static uint8_t xtime(uint8_t x) { return (uint8_t)((x << 1) ^ ((x >> 7) * 0x1b)); }
static uint8_t gmul(uint8_t a, uint8_t b) {
    uint8_t p = 0;
    for (int i = 0; i < 8; i++) {
        if (b & 1) p ^= a;
        uint8_t hi = a & 0x80;
        a <<= 1;
        if (hi) a ^= 0x1b;
        b >>= 1;
    }
    return p;
}

static const uint8_t RCON[11] = {0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36};

slcrypto_status slc_aes_set_encrypt_key(slc_aes_key *k, const uint8_t *key, int key_bits) {
    int nk;
    if (key_bits == 128) { nk = 4; k->rounds = 10; }
    else if (key_bits == 192) { nk = 6; k->rounds = 12; }
    else if (key_bits == 256) { nk = 8; k->rounds = 14; }
    else return SLCRYPTO_ERR_PARAM;
    int total = 4 * (k->rounds + 1);
    uint32_t *rk = k->rk;
    for (int i = 0; i < nk; i++)
        rk[i] = ((uint32_t)key[4*i]<<24)|((uint32_t)key[4*i+1]<<16)|((uint32_t)key[4*i+2]<<8)|key[4*i+3];
    for (int i = nk; i < total; i++) {
        uint32_t t = rk[i-1];
        if (i % nk == 0) {
            t = (t << 8) | (t >> 24); /* RotWord */
            t = ((uint32_t)SBOX[(t>>24)&0xff]<<24)|((uint32_t)SBOX[(t>>16)&0xff]<<16)|
                ((uint32_t)SBOX[(t>>8)&0xff]<<8)|SBOX[t&0xff];
            t ^= (uint32_t)RCON[i/nk] << 24;
        } else if (nk > 6 && i % nk == 4) {
            t = ((uint32_t)SBOX[(t>>24)&0xff]<<24)|((uint32_t)SBOX[(t>>16)&0xff]<<16)|
                ((uint32_t)SBOX[(t>>8)&0xff]<<8)|SBOX[t&0xff];
        }
        rk[i] = rk[i-nk] ^ t;
    }
    return SLCRYPTO_OK;
}

slcrypto_status slc_aes_set_decrypt_key(slc_aes_key *k, const uint8_t *key, int key_bits) {
    build_inv();
    return slc_aes_set_encrypt_key(k, key, key_bits); /* same schedule; inverse applied in decrypt */
}

static void add_round_key(uint8_t s[16], const uint32_t *rk) {
    for (int c = 0; c < 4; c++) {
        s[4*c+0] ^= (uint8_t)(rk[c] >> 24);
        s[4*c+1] ^= (uint8_t)(rk[c] >> 16);
        s[4*c+2] ^= (uint8_t)(rk[c] >> 8);
        s[4*c+3] ^= (uint8_t)(rk[c]);
    }
}

void slc_aes_encrypt_block(const slc_aes_key *k, const uint8_t in[16], uint8_t out[16]) {
    uint8_t s[16]; memcpy(s, in, 16);
    add_round_key(s, k->rk);
    for (int r = 1; r < k->rounds; r++) {
        for (int i = 0; i < 16; i++) s[i] = SBOX[s[i]];                 /* SubBytes */
        uint8_t t[16];                                                  /* ShiftRows */
        for (int c = 0; c < 4; c++) for (int row = 0; row < 4; row++)
            t[4*c+row] = s[4*((c+row)%4)+row];
        for (int c = 0; c < 4; c++) {                                   /* MixColumns */
            uint8_t a0=t[4*c],a1=t[4*c+1],a2=t[4*c+2],a3=t[4*c+3];
            s[4*c+0]=(uint8_t)(xtime(a0)^(xtime(a1)^a1)^a2^a3);
            s[4*c+1]=(uint8_t)(a0^xtime(a1)^(xtime(a2)^a2)^a3);
            s[4*c+2]=(uint8_t)(a0^a1^xtime(a2)^(xtime(a3)^a3));
            s[4*c+3]=(uint8_t)((xtime(a0)^a0)^a1^a2^xtime(a3));
        }
        add_round_key(s, k->rk + 4*r);
    }
    for (int i = 0; i < 16; i++) s[i] = SBOX[s[i]];
    uint8_t t[16];
    for (int c = 0; c < 4; c++) for (int row = 0; row < 4; row++)
        t[4*c+row] = s[4*((c+row)%4)+row];
    memcpy(s, t, 16);
    add_round_key(s, k->rk + 4*k->rounds);
    memcpy(out, s, 16);
}

void slc_aes_decrypt_block(const slc_aes_key *k, const uint8_t in[16], uint8_t out[16]) {
    build_inv();
    uint8_t s[16]; memcpy(s, in, 16);
    add_round_key(s, k->rk + 4*k->rounds);
    for (int r = k->rounds - 1; r >= 1; r--) {
        uint8_t t[16];                                                  /* InvShiftRows */
        for (int c = 0; c < 4; c++) for (int row = 0; row < 4; row++)
            t[4*c+row] = s[4*((c-row+4)%4)+row];
        for (int i = 0; i < 16; i++) s[i] = INV_SBOX[t[i]];             /* InvSubBytes */
        add_round_key(s, k->rk + 4*r);
        for (int c = 0; c < 4; c++) {                                   /* InvMixColumns */
            uint8_t a0=s[4*c],a1=s[4*c+1],a2=s[4*c+2],a3=s[4*c+3];
            s[4*c+0]=(uint8_t)(gmul(a0,14)^gmul(a1,11)^gmul(a2,13)^gmul(a3,9));
            s[4*c+1]=(uint8_t)(gmul(a0,9)^gmul(a1,14)^gmul(a2,11)^gmul(a3,13));
            s[4*c+2]=(uint8_t)(gmul(a0,13)^gmul(a1,9)^gmul(a2,14)^gmul(a3,11));
            s[4*c+3]=(uint8_t)(gmul(a0,11)^gmul(a1,13)^gmul(a2,9)^gmul(a3,14));
        }
    }
    uint8_t t[16];
    for (int c = 0; c < 4; c++) for (int row = 0; row < 4; row++)
        t[4*c+row] = s[4*((c-row+4)%4)+row];
    for (int i = 0; i < 16; i++) s[i] = INV_SBOX[t[i]];
    add_round_key(s, k->rk);
    memcpy(out, s, 16);
}

/* ============================ GCM (SP 800-38D) =========================== */

static void ghash_mul(uint8_t x[16], const uint8_t h[16]) {
    uint8_t z[16] = {0}, v[16];
    memcpy(v, h, 16);
    for (int i = 0; i < 128; i++) {
        if ((x[i/8] >> (7 - (i%8))) & 1)
            for (int j = 0; j < 16; j++) z[j] ^= v[j];
        int lsb = v[15] & 1;
        for (int j = 15; j > 0; j--) v[j] = (uint8_t)((v[j] >> 1) | (v[j-1] << 7));
        v[0] >>= 1;
        if (lsb) v[0] ^= 0xe1;
    }
    memcpy(x, z, 16);
}

static void gcm_inc32(uint8_t ctr[16]) {
    for (int i = 15; i >= 12; i--) { if (++ctr[i]) break; }
}

static void gcm_core(const slc_aes_key *k, const uint8_t h[16],
                     const uint8_t *iv, size_t iv_len,
                     const uint8_t *aad, size_t aad_len,
                     const uint8_t *in, size_t in_len, uint8_t *out,
                     int encrypt, uint8_t j0[16], uint8_t s[16]) {
    /* Compute J0 */
    if (iv_len == 12) {
        memcpy(j0, iv, 12); j0[12]=0; j0[13]=0; j0[14]=0; j0[15]=1;
    } else {
        uint8_t y[16] = {0};
        size_t p = 0;
        while (p < iv_len) {
            size_t take = iv_len - p; if (take > 16) take = 16;
            for (size_t i = 0; i < take; i++) y[i] ^= iv[p+i];
            if (take == 16) { ghash_mul(y, h); }
            else { ghash_mul(y, h); }
            p += take;
        }
        uint8_t lenblk[16] = {0};
        uint64_t bits = (uint64_t)iv_len * 8;
        for (int i = 0; i < 8; i++) lenblk[15-i] = (uint8_t)(bits >> (8*i));
        for (int i = 0; i < 16; i++) y[i] ^= lenblk[i];
        ghash_mul(y, h);
        memcpy(j0, y, 16);
    }

    /* GHASH over AAD */
    memset(s, 0, 16);
    size_t p = 0;
    while (p < aad_len) {
        size_t take = aad_len - p; if (take > 16) take = 16;
        for (size_t i = 0; i < take; i++) s[i] ^= aad[p+i];
        ghash_mul(s, h);
        p += take;
    }

    /* CTR encrypt/decrypt starting at inc32(J0), GHASH over ciphertext */
    uint8_t ctr[16]; memcpy(ctr, j0, 16); gcm_inc32(ctr);
    p = 0;
    while (p < in_len) {
        uint8_t ks[16];
        slc_aes_encrypt_block(k, ctr, ks);
        gcm_inc32(ctr);
        size_t take = in_len - p; if (take > 16) take = 16;
        for (size_t i = 0; i < take; i++) out[p+i] = in[p+i] ^ ks[i];
        /* GHASH uses ciphertext in both directions */
        const uint8_t *ctblk = encrypt ? &out[p] : &in[p];
        for (size_t i = 0; i < take; i++) s[i] ^= ctblk[i];
        ghash_mul(s, h);
        p += take;
    }

    /* length block */
    uint8_t lenblk[16] = {0};
    uint64_t abits = (uint64_t)aad_len * 8, cbits = (uint64_t)in_len * 8;
    for (int i = 0; i < 8; i++) lenblk[7-i]  = (uint8_t)(abits >> (8*i));
    for (int i = 0; i < 8; i++) lenblk[15-i] = (uint8_t)(cbits >> (8*i));
    for (int i = 0; i < 16; i++) s[i] ^= lenblk[i];
    ghash_mul(s, h);
}

slcrypto_status slc_aes_gcm_encrypt(
    const uint8_t *key, int key_bits,
    const uint8_t *iv, size_t iv_len,
    const uint8_t *aad, size_t aad_len,
    const uint8_t *pt, size_t pt_len,
    uint8_t *ct_out, uint8_t *tag_out, size_t tag_len)
{
    if (!key || tag_len == 0 || tag_len > 16) return SLCRYPTO_ERR_PARAM;
    slc_aes_key k;
    if (slc_aes_set_encrypt_key(&k, key, key_bits) != SLCRYPTO_OK) return SLCRYPTO_ERR_PARAM;
    uint8_t h[16] = {0}, zero[16] = {0};
    slc_aes_encrypt_block(&k, zero, h);
    uint8_t j0[16], s[16];
    gcm_core(&k, h, iv, iv_len, aad, aad_len, pt, pt_len, ct_out, 1, j0, s);
    uint8_t ej0[16]; slc_aes_encrypt_block(&k, j0, ej0);
    for (size_t i = 0; i < tag_len; i++) tag_out[i] = s[i] ^ ej0[i];
    return SLCRYPTO_OK;
}

slcrypto_status slc_aes_gcm_decrypt(
    const uint8_t *key, int key_bits,
    const uint8_t *iv, size_t iv_len,
    const uint8_t *aad, size_t aad_len,
    const uint8_t *ct, size_t ct_len,
    const uint8_t *tag, size_t tag_len,
    uint8_t *pt_out)
{
    if (!key || tag_len == 0 || tag_len > 16) return SLCRYPTO_ERR_PARAM;
    slc_aes_key k;
    if (slc_aes_set_encrypt_key(&k, key, key_bits) != SLCRYPTO_OK) return SLCRYPTO_ERR_PARAM;
    uint8_t h[16] = {0}, zero[16] = {0};
    slc_aes_encrypt_block(&k, zero, h);
    uint8_t j0[16], s[16];
    gcm_core(&k, h, iv, iv_len, aad, aad_len, ct, ct_len, pt_out, 0, j0, s);
    uint8_t ej0[16]; slc_aes_encrypt_block(&k, j0, ej0);
    uint8_t expect[16];
    for (size_t i = 0; i < tag_len; i++) expect[i] = s[i] ^ ej0[i];
    if (!slc_ct_equal(expect, tag, tag_len)) {
        /* scrub released plaintext on auth failure */
        for (size_t i = 0; i < ct_len; i++) pt_out[i] = 0;
        return SLCRYPTO_ERR_AUTH;
    }
    return SLCRYPTO_OK;
}