Miscellany

/* encrypt a block of text (woot, I found the crypto part!) */

#define f_nround(bo, bi, k) \
    f_rn(bo, bi, 0, k);     \
    f_rn(bo, bi, 1, k);     \
    f_rn(bo, bi, 2, k);     \
    f_rn(bo, bi, 3, k);     \
    k += 4

#define f_lround(bo, bi, k) \
    f_rl(bo, bi, 0, k);     \
    f_rl(bo, bi, 1, k);     \
    f_rl(bo, bi, 2, k);     \
    f_rl(bo, bi, 3, k)

static void aes_encrypt(void *ctx_arg, u8 *out, const u8 *in)
{
        const struct aes_ctx *ctx = ctx_arg;
        u32 b0[4], b1[4];
        const u32 *kp = E_KEY + 4;

        b0[0] = u32_in (in) ^ E_KEY[0];
        b0[1] = u32_in (in + 4) ^ E_KEY[1];
        b0[2] = u32_in (in + 8) ^ E_KEY[2];
        b0[3] = u32_in (in + 12) ^ E_KEY[3];

        if (ctx->key_length > 24) {
                f_nround (b1, b0, kp);
                f_nround (b0, b1, kp);
        }

        if (ctx->key_length > 16) {
                f_nround (b1, b0, kp);
                f_nround (b0, b1, kp);
        }

        f_nround (b1, b0, kp);
        f_nround (b0, b1, kp);
        f_nround (b1, b0, kp);
        f_nround (b0, b1, kp);
        f_nround (b1, b0, kp);
        f_nround (b0, b1, kp);
        f_nround (b1, b0, kp);
        f_nround (b0, b1, kp);
        f_nround (b1, b0, kp);
        f_lround (b0, b1, kp);

        u32_out (out, b0[0]);
        u32_out (out + 4, b0[1]);
        u32_out (out + 8, b0[2]);
        u32_out (out + 12, b0[3]);
}

/* decrypt a block of text */

#define i_nround(bo, bi, k) \
    i_rn(bo, bi, 0, k);     \
    i_rn(bo, bi, 1, k);     \
    i_rn(bo, bi, 2, k);     \
    i_rn(bo, bi, 3, k);     \
    k -= 4

#define i_lround(bo, bi, k) \
    i_rl(bo, bi, 0, k);     \
    i_rl(bo, bi, 1, k);     \
    i_rl(bo, bi, 2, k);     \
    i_rl(bo, bi, 3, k)

static void aes_decrypt(void *ctx_arg, u8 *out, const u8 *in)
{
        const struct aes_ctx *ctx = ctx_arg;
        u32 b0[4], b1[4];
        const int key_len = ctx->key_length;
        const u32 *kp = D_KEY + key_len + 20;

        b0[0] = u32_in (in) ^ E_KEY[key_len + 24];
        b0[1] = u32_in (in + 4) ^ E_KEY[key_len + 25];
        b0[2] = u32_in (in + 8) ^ E_KEY[key_len + 26];
        b0[3] = u32_in (in + 12) ^ E_KEY[key_len + 27];

        if (key_len > 24) {
                i_nround (b1, b0, kp);
                i_nround (b0, b1, kp);
        }

        if (key_len > 16) {
                i_nround (b1, b0, kp);
                i_nround (b0, b1, kp);
        }

        i_nround (b1, b0, kp);
        i_nround (b0, b1, kp);
        i_nround (b1, b0, kp);
        i_nround (b0, b1, kp);
        i_nround (b1, b0, kp);
        i_nround (b0, b1, kp);
        i_nround (b1, b0, kp);
        i_nround (b0, b1, kp);
        i_nround (b1, b0, kp);
        i_lround (b0, b1, kp);

        u32_out (out, b0[0]);
        u32_out (out + 4, b0[1]);
        u32_out (out + 8, b0[2]);
        u32_out (out + 12, b0[3]);
}