/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <string.h>
#include <stdint.h>
#include <nanohub/aes.h>


#define AES_NUM_ROUNDS    14



static const uint8_t FwdSbox[] = {
    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 const uint8_t RevSbox[] = {
    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
    0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
    0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
    0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
    0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
    0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
    0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
    0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
    0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
    0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
    0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D,
};

static const uint32_t FwdTab0[] = { //other 3 tables are this same table, RORed 8, 16, and 24 bits respectively.
    0xC66363A5, 0xF87C7C84, 0xEE777799, 0xF67B7B8D, 0xFFF2F20D, 0xD66B6BBD, 0xDE6F6FB1, 0x91C5C554,
    0x60303050, 0x02010103, 0xCE6767A9, 0x562B2B7D, 0xE7FEFE19, 0xB5D7D762, 0x4DABABE6, 0xEC76769A,
    0x8FCACA45, 0x1F82829D, 0x89C9C940, 0xFA7D7D87, 0xEFFAFA15, 0xB25959EB, 0x8E4747C9, 0xFBF0F00B,
    0x41ADADEC, 0xB3D4D467, 0x5FA2A2FD, 0x45AFAFEA, 0x239C9CBF, 0x53A4A4F7, 0xE4727296, 0x9BC0C05B,
    0x75B7B7C2, 0xE1FDFD1C, 0x3D9393AE, 0x4C26266A, 0x6C36365A, 0x7E3F3F41, 0xF5F7F702, 0x83CCCC4F,
    0x6834345C, 0x51A5A5F4, 0xD1E5E534, 0xF9F1F108, 0xE2717193, 0xABD8D873, 0x62313153, 0x2A15153F,
    0x0804040C, 0x95C7C752, 0x46232365, 0x9DC3C35E, 0x30181828, 0x379696A1, 0x0A05050F, 0x2F9A9AB5,
    0x0E070709, 0x24121236, 0x1B80809B, 0xDFE2E23D, 0xCDEBEB26, 0x4E272769, 0x7FB2B2CD, 0xEA75759F,
    0x1209091B, 0x1D83839E, 0x582C2C74, 0x341A1A2E, 0x361B1B2D, 0xDC6E6EB2, 0xB45A5AEE, 0x5BA0A0FB,
    0xA45252F6, 0x763B3B4D, 0xB7D6D661, 0x7DB3B3CE, 0x5229297B, 0xDDE3E33E, 0x5E2F2F71, 0x13848497,
    0xA65353F5, 0xB9D1D168, 0x00000000, 0xC1EDED2C, 0x40202060, 0xE3FCFC1F, 0x79B1B1C8, 0xB65B5BED,
    0xD46A6ABE, 0x8DCBCB46, 0x67BEBED9, 0x7239394B, 0x944A4ADE, 0x984C4CD4, 0xB05858E8, 0x85CFCF4A,
    0xBBD0D06B, 0xC5EFEF2A, 0x4FAAAAE5, 0xEDFBFB16, 0x864343C5, 0x9A4D4DD7, 0x66333355, 0x11858594,
    0x8A4545CF, 0xE9F9F910, 0x04020206, 0xFE7F7F81, 0xA05050F0, 0x783C3C44, 0x259F9FBA, 0x4BA8A8E3,
    0xA25151F3, 0x5DA3A3FE, 0x804040C0, 0x058F8F8A, 0x3F9292AD, 0x219D9DBC, 0x70383848, 0xF1F5F504,
    0x63BCBCDF, 0x77B6B6C1, 0xAFDADA75, 0x42212163, 0x20101030, 0xE5FFFF1A, 0xFDF3F30E, 0xBFD2D26D,
    0x81CDCD4C, 0x180C0C14, 0x26131335, 0xC3ECEC2F, 0xBE5F5FE1, 0x359797A2, 0x884444CC, 0x2E171739,
    0x93C4C457, 0x55A7A7F2, 0xFC7E7E82, 0x7A3D3D47, 0xC86464AC, 0xBA5D5DE7, 0x3219192B, 0xE6737395,
    0xC06060A0, 0x19818198, 0x9E4F4FD1, 0xA3DCDC7F, 0x44222266, 0x542A2A7E, 0x3B9090AB, 0x0B888883,
    0x8C4646CA, 0xC7EEEE29, 0x6BB8B8D3, 0x2814143C, 0xA7DEDE79, 0xBC5E5EE2, 0x160B0B1D, 0xADDBDB76,
    0xDBE0E03B, 0x64323256, 0x743A3A4E, 0x140A0A1E, 0x924949DB, 0x0C06060A, 0x4824246C, 0xB85C5CE4,
    0x9FC2C25D, 0xBDD3D36E, 0x43ACACEF, 0xC46262A6, 0x399191A8, 0x319595A4, 0xD3E4E437, 0xF279798B,
    0xD5E7E732, 0x8BC8C843, 0x6E373759, 0xDA6D6DB7, 0x018D8D8C, 0xB1D5D564, 0x9C4E4ED2, 0x49A9A9E0,
    0xD86C6CB4, 0xAC5656FA, 0xF3F4F407, 0xCFEAEA25, 0xCA6565AF, 0xF47A7A8E, 0x47AEAEE9, 0x10080818,
    0x6FBABAD5, 0xF0787888, 0x4A25256F, 0x5C2E2E72, 0x381C1C24, 0x57A6A6F1, 0x73B4B4C7, 0x97C6C651,
    0xCBE8E823, 0xA1DDDD7C, 0xE874749C, 0x3E1F1F21, 0x964B4BDD, 0x61BDBDDC, 0x0D8B8B86, 0x0F8A8A85,
    0xE0707090, 0x7C3E3E42, 0x71B5B5C4, 0xCC6666AA, 0x904848D8, 0x06030305, 0xF7F6F601, 0x1C0E0E12,
    0xC26161A3, 0x6A35355F, 0xAE5757F9, 0x69B9B9D0, 0x17868691, 0x99C1C158, 0x3A1D1D27, 0x279E9EB9,
    0xD9E1E138, 0xEBF8F813, 0x2B9898B3, 0x22111133, 0xD26969BB, 0xA9D9D970, 0x078E8E89, 0x339494A7,
    0x2D9B9BB6, 0x3C1E1E22, 0x15878792, 0xC9E9E920, 0x87CECE49, 0xAA5555FF, 0x50282878, 0xA5DFDF7A,
    0x038C8C8F, 0x59A1A1F8, 0x09898980, 0x1A0D0D17, 0x65BFBFDA, 0xD7E6E631, 0x844242C6, 0xD06868B8,
    0x824141C3, 0x299999B0, 0x5A2D2D77, 0x1E0F0F11, 0x7BB0B0CB, 0xA85454FC, 0x6DBBBBD6, 0x2C16163A,
};

static const uint32_t RevTab0[] = { //other 3 tables are this same table, RORed 8, 16, and 24 bits respectively.
    0x51F4A750, 0x7E416553, 0x1A17A4C3, 0x3A275E96, 0x3BAB6BCB, 0x1F9D45F1, 0xACFA58AB, 0x4BE30393,
    0x2030FA55, 0xAD766DF6, 0x88CC7691, 0xF5024C25, 0x4FE5D7FC, 0xC52ACBD7, 0x26354480, 0xB562A38F,
    0xDEB15A49, 0x25BA1B67, 0x45EA0E98, 0x5DFEC0E1, 0xC32F7502, 0x814CF012, 0x8D4697A3, 0x6BD3F9C6,
    0x038F5FE7, 0x15929C95, 0xBF6D7AEB, 0x955259DA, 0xD4BE832D, 0x587421D3, 0x49E06929, 0x8EC9C844,
    0x75C2896A, 0xF48E7978, 0x99583E6B, 0x27B971DD, 0xBEE14FB6, 0xF088AD17, 0xC920AC66, 0x7DCE3AB4,
    0x63DF4A18, 0xE51A3182, 0x97513360, 0x62537F45, 0xB16477E0, 0xBB6BAE84, 0xFE81A01C, 0xF9082B94,
    0x70486858, 0x8F45FD19, 0x94DE6C87, 0x527BF8B7, 0xAB73D323, 0x724B02E2, 0xE31F8F57, 0x6655AB2A,
    0xB2EB2807, 0x2FB5C203, 0x86C57B9A, 0xD33708A5, 0x302887F2, 0x23BFA5B2, 0x02036ABA, 0xED16825C,
    0x8ACF1C2B, 0xA779B492, 0xF307F2F0, 0x4E69E2A1, 0x65DAF4CD, 0x0605BED5, 0xD134621F, 0xC4A6FE8A,
    0x342E539D, 0xA2F355A0, 0x058AE132, 0xA4F6EB75, 0x0B83EC39, 0x4060EFAA, 0x5E719F06, 0xBD6E1051,
    0x3E218AF9, 0x96DD063D, 0xDD3E05AE, 0x4DE6BD46, 0x91548DB5, 0x71C45D05, 0x0406D46F, 0x605015FF,
    0x1998FB24, 0xD6BDE997, 0x894043CC, 0x67D99E77, 0xB0E842BD, 0x07898B88, 0xE7195B38, 0x79C8EEDB,
    0xA17C0A47, 0x7C420FE9, 0xF8841EC9, 0x00000000, 0x09808683, 0x322BED48, 0x1E1170AC, 0x6C5A724E,
    0xFD0EFFFB, 0x0F853856, 0x3DAED51E, 0x362D3927, 0x0A0FD964, 0x685CA621, 0x9B5B54D1, 0x24362E3A,
    0x0C0A67B1, 0x9357E70F, 0xB4EE96D2, 0x1B9B919E, 0x80C0C54F, 0x61DC20A2, 0x5A774B69, 0x1C121A16,
    0xE293BA0A, 0xC0A02AE5, 0x3C22E043, 0x121B171D, 0x0E090D0B, 0xF28BC7AD, 0x2DB6A8B9, 0x141EA9C8,
    0x57F11985, 0xAF75074C, 0xEE99DDBB, 0xA37F60FD, 0xF701269F, 0x5C72F5BC, 0x44663BC5, 0x5BFB7E34,
    0x8B432976, 0xCB23C6DC, 0xB6EDFC68, 0xB8E4F163, 0xD731DCCA, 0x42638510, 0x13972240, 0x84C61120,
    0x854A247D, 0xD2BB3DF8, 0xAEF93211, 0xC729A16D, 0x1D9E2F4B, 0xDCB230F3, 0x0D8652EC, 0x77C1E3D0,
    0x2BB3166C, 0xA970B999, 0x119448FA, 0x47E96422, 0xA8FC8CC4, 0xA0F03F1A, 0x567D2CD8, 0x223390EF,
    0x87494EC7, 0xD938D1C1, 0x8CCAA2FE, 0x98D40B36, 0xA6F581CF, 0xA57ADE28, 0xDAB78E26, 0x3FADBFA4,
    0x2C3A9DE4, 0x5078920D, 0x6A5FCC9B, 0x547E4662, 0xF68D13C2, 0x90D8B8E8, 0x2E39F75E, 0x82C3AFF5,
    0x9F5D80BE, 0x69D0937C, 0x6FD52DA9, 0xCF2512B3, 0xC8AC993B, 0x10187DA7, 0xE89C636E, 0xDB3BBB7B,
    0xCD267809, 0x6E5918F4, 0xEC9AB701, 0x834F9AA8, 0xE6956E65, 0xAAFFE67E, 0x21BCCF08, 0xEF15E8E6,
    0xBAE79BD9, 0x4A6F36CE, 0xEA9F09D4, 0x29B07CD6, 0x31A4B2AF, 0x2A3F2331, 0xC6A59430, 0x35A266C0,
    0x744EBC37, 0xFC82CAA6, 0xE090D0B0, 0x33A7D815, 0xF104984A, 0x41ECDAF7, 0x7FCD500E, 0x1791F62F,
    0x764DD68D, 0x43EFB04D, 0xCCAA4D54, 0xE49604DF, 0x9ED1B5E3, 0x4C6A881B, 0xC12C1FB8, 0x4665517F,
    0x9D5EEA04, 0x018C355D, 0xFA877473, 0xFB0B412E, 0xB3671D5A, 0x92DBD252, 0xE9105633, 0x6DD64713,
    0x9AD7618C, 0x37A10C7A, 0x59F8148E, 0xEB133C89, 0xCEA927EE, 0xB761C935, 0xE11CE5ED, 0x7A47B13C,
    0x9CD2DF59, 0x55F2733F, 0x1814CE79, 0x73C737BF, 0x53F7CDEA, 0x5FFDAA5B, 0xDF3D6F14, 0x7844DB86,
    0xCAAFF381, 0xB968C43E, 0x3824342C, 0xC2A3405F, 0x161DC372, 0xBCE2250C, 0x283C498B, 0xFF0D9541,
    0x39A80171, 0x080CB3DE, 0xD8B4E49C, 0x6456C190, 0x7BCB8461, 0xD532B670, 0x486C5C74, 0xD0B85742,
};

#ifdef ARM

    #define STRINFIGY2(b) #b
    #define STRINGIFY(b) STRINFIGY2(b)
    #define ror(v, b) ({uint32_t ret; if (b) asm("ror %0, #" STRINGIFY(b) :"=r"(ret):"0"(v)); else ret = v; ret;})

#else

    inline static uint32_t ror(uint32_t val, uint32_t by)
    {
        if (!by)
            return val;

        val = (val >> by) | (val << (32 - by));

        return val;
    }

#endif


void aesInitForEncr(struct AesContext *ctx, const uint32_t *k)
{
    uint32_t i, *ks = ctx->K, roundConstant = 0x01000000;

    //first 8 words are just the key itself
    memcpy(ctx->K, k, sizeof(uint32_t[AES_KEY_WORDS]));

    //create round keys for encryption
    for (i = 0; i < 7; i++, ks += 8, roundConstant <<= 1) {
        ks[8] = ks[0] ^ roundConstant
             ^ (((uint32_t)FwdSbox[(ks[ 7] >> 16) & 0xff]) << 24)
             ^ (((uint32_t)FwdSbox[(ks[ 7] >>  8) & 0xff]) << 16)
             ^ (((uint32_t)FwdSbox[(ks[ 7] >>  0) & 0xff]) <<  8)
             ^ (((uint32_t)FwdSbox[(ks[ 7] >> 24) & 0xff]) <<  0);
        ks[9] = ks[1] ^ ks[8];
        ks[10] = ks[2] ^ ks[9];
        ks[11] = ks[3] ^ ks[10];
        ks[12] = ks[4]
             ^ (((uint32_t)FwdSbox[(ks[11] >> 24) & 0xff]) << 24)
             ^ (((uint32_t)FwdSbox[(ks[11] >> 16) & 0xff]) << 16)
             ^ (((uint32_t)FwdSbox[(ks[11] >>  8) & 0xff]) <<  8)
             ^ (((uint32_t)FwdSbox[(ks[11] >>  0) & 0xff]) <<  0);
        ks[13] = ks[5] ^ ks[12];
        ks[14] = ks[6] ^ ks[13];
        ks[15] = ks[7] ^ ks[14];
    }
}

void aesInitForDecr(struct AesContext *ctx, struct AesSetupTempWorksSpace *tmpSpace, const uint32_t *k)
{
    uint32_t i, j, *ks = ctx->K + 4, *encrK = tmpSpace->tmpCtx.K + 52;

    //we need encryption keys to calculate decryption keys
    aesInitForEncr(&tmpSpace->tmpCtx, k);

    //now we can calculate round keys for decryption
    memcpy(ctx->K, tmpSpace->tmpCtx.K + 56, sizeof(uint32_t[4]));
    for (i = 0; i < AES_NUM_ROUNDS - 1; i++, encrK -= 4, ks += 4) { //num_rounds-1 seems to be concensus, but num_rounds make more sense...
        for (j = 0; j < 4; j++) {
            ks[j] =
                ror(RevTab0[FwdSbox[(encrK[j] >> 24) & 0xff]],  0) ^
                ror(RevTab0[FwdSbox[(encrK[j] >> 16) & 0xff]],  8) ^
                ror(RevTab0[FwdSbox[(encrK[j] >>  8) & 0xff]], 16) ^
                ror(RevTab0[FwdSbox[(encrK[j] >>  0) & 0xff]], 24);
        }
    }
    memcpy(ks, encrK, sizeof(uint32_t[4]));
}

void aesEncr(struct AesContext *ctx, const uint32_t *src, uint32_t *dst)
{
    uint32_t x0, x1, x2, x3; //we CAN use an array, but then GCC will not use registers. so we use separate vars. sigh...
    uint32_t *k = ctx->K, i;

    //setup
    x0 = *src++ ^ *k++;
    x1 = *src++ ^ *k++;
    x2 = *src++ ^ *k++;
    x3 = *src++ ^ *k++;

    //all-but-last round
    for (i = 0; i < AES_NUM_ROUNDS - 1; i++) {
        uint32_t t0, t1, t2;

        t0 = *k++ ^
            ror(FwdTab0[(x0 >> 24) & 0xff],  0) ^
            ror(FwdTab0[(x1 >> 16) & 0xff],  8) ^
            ror(FwdTab0[(x2 >>  8) & 0xff], 16) ^
            ror(FwdTab0[(x3 >>  0) & 0xff], 24);

        t1 = *k++ ^
            ror(FwdTab0[(x1 >> 24) & 0xff],  0) ^
            ror(FwdTab0[(x2 >> 16) & 0xff],  8) ^
            ror(FwdTab0[(x3 >>  8) & 0xff], 16) ^
            ror(FwdTab0[(x0 >>  0) & 0xff], 24);

        t2 = *k++ ^
            ror(FwdTab0[(x2 >> 24) & 0xff],  0) ^
            ror(FwdTab0[(x3 >> 16) & 0xff],  8) ^
            ror(FwdTab0[(x0 >>  8) & 0xff], 16) ^
            ror(FwdTab0[(x1 >>  0) & 0xff], 24);

        x3 = *k++ ^
            ror(FwdTab0[(x3 >> 24) & 0xff],  0) ^
            ror(FwdTab0[(x0 >> 16) & 0xff],  8) ^
            ror(FwdTab0[(x1 >>  8) & 0xff], 16) ^
            ror(FwdTab0[(x2 >>  0) & 0xff], 24);

       x0 = t0;
       x1 = t1;
       x2 = t2;
    }

    //last round
    *dst++ = *k++ ^
            (((uint32_t)(FwdSbox[(x0 >> 24) & 0xff])) << 24) ^
            (((uint32_t)(FwdSbox[(x1 >> 16) & 0xff])) << 16) ^
            (((uint32_t)(FwdSbox[(x2 >>  8) & 0xff])) <<  8) ^
            (((uint32_t)(FwdSbox[(x3 >>  0) & 0xff])) <<  0);

    *dst++ = *k++ ^
            (((uint32_t)(FwdSbox[(x1 >> 24) & 0xff])) << 24) ^
            (((uint32_t)(FwdSbox[(x2 >> 16) & 0xff])) << 16) ^
            (((uint32_t)(FwdSbox[(x3 >>  8) & 0xff])) <<  8) ^
            (((uint32_t)(FwdSbox[(x0 >>  0) & 0xff])) <<  0);

    *dst++ = *k++ ^
            (((uint32_t)(FwdSbox[(x2 >> 24) & 0xff])) << 24) ^
            (((uint32_t)(FwdSbox[(x3 >> 16) & 0xff])) << 16) ^
            (((uint32_t)(FwdSbox[(x0 >>  8) & 0xff])) <<  8) ^
            (((uint32_t)(FwdSbox[(x1 >>  0) & 0xff])) <<  0);

    *dst++ = *k++ ^
            (((uint32_t)(FwdSbox[(x3 >> 24) & 0xff])) << 24) ^
            (((uint32_t)(FwdSbox[(x0 >> 16) & 0xff])) << 16) ^
            (((uint32_t)(FwdSbox[(x1 >>  8) & 0xff])) <<  8) ^
            (((uint32_t)(FwdSbox[(x2 >>  0) & 0xff])) <<  0);
}

void aesDecr(struct AesContext *ctx, const uint32_t *src, uint32_t *dst)
{
    uint32_t x0, x1, x2, x3;
    uint32_t *k = ctx->K, i;

    //setup
    x0 = *src++ ^ *k++;
    x1 = *src++ ^ *k++;
    x2 = *src++ ^ *k++;
    x3 = *src++ ^ *k++;

    //all-but-last round
    for (i = 0; i < AES_NUM_ROUNDS - 1; i++) {
        uint32_t t0, t1, t2;

        t0 = *k++ ^
            ror(RevTab0[(x0 >> 24) & 0xff],  0) ^
            ror(RevTab0[(x3 >> 16) & 0xff],  8) ^
            ror(RevTab0[(x2 >>  8) & 0xff], 16) ^
            ror(RevTab0[(x1 >>  0) & 0xff], 24);

        t1 = *k++ ^
            ror(RevTab0[(x1 >> 24) & 0xff],  0) ^
            ror(RevTab0[(x0 >> 16) & 0xff],  8) ^
            ror(RevTab0[(x3 >>  8) & 0xff], 16) ^
            ror(RevTab0[(x2 >>  0) & 0xff], 24);

        t2 = *k++ ^
            ror(RevTab0[(x2 >> 24) & 0xff],  0) ^
            ror(RevTab0[(x1 >> 16) & 0xff],  8) ^
            ror(RevTab0[(x0 >>  8) & 0xff], 16) ^
            ror(RevTab0[(x3 >>  0) & 0xff], 24);

        x3 = *k++ ^
            ror(RevTab0[(x3 >> 24) & 0xff],  0) ^
            ror(RevTab0[(x2 >> 16) & 0xff],  8) ^
            ror(RevTab0[(x1 >>  8) & 0xff], 16) ^
            ror(RevTab0[(x0 >>  0) & 0xff], 24);

       x0 = t0;
       x1 = t1;
       x2 = t2;
    }

    //last round
    *dst++ = *k++ ^
            (((uint32_t)(RevSbox[(x0 >> 24) & 0xff])) << 24) ^
            (((uint32_t)(RevSbox[(x3 >> 16) & 0xff])) << 16) ^
            (((uint32_t)(RevSbox[(x2 >>  8) & 0xff])) <<  8) ^
            (((uint32_t)(RevSbox[(x1 >>  0) & 0xff])) <<  0);

    *dst++ = *k++ ^
            (((uint32_t)(RevSbox[(x1 >> 24) & 0xff])) << 24) ^
            (((uint32_t)(RevSbox[(x0 >> 16) & 0xff])) << 16) ^
            (((uint32_t)(RevSbox[(x3 >>  8) & 0xff])) <<  8) ^
            (((uint32_t)(RevSbox[(x2 >>  0) & 0xff])) <<  0);

    *dst++ = *k++ ^
            (((uint32_t)(RevSbox[(x2 >> 24) & 0xff])) << 24) ^
            (((uint32_t)(RevSbox[(x1 >> 16) & 0xff])) << 16) ^
            (((uint32_t)(RevSbox[(x0 >>  8) & 0xff])) <<  8) ^
            (((uint32_t)(RevSbox[(x3 >>  0) & 0xff])) <<  0);

    *dst++ = *k++ ^
            (((uint32_t)(RevSbox[(x3 >> 24) & 0xff])) << 24) ^
            (((uint32_t)(RevSbox[(x2 >> 16) & 0xff])) << 16) ^
            (((uint32_t)(RevSbox[(x1 >>  8) & 0xff])) <<  8) ^
            (((uint32_t)(RevSbox[(x0 >>  0) & 0xff])) <<  0);
}

void aesCbcInitForEncr(struct AesCbcContext *ctx, const uint32_t *k, const uint32_t *iv)
{
    aesInitForEncr(&ctx->aes, k);
    memcpy(ctx->iv, iv, sizeof(uint32_t[AES_BLOCK_WORDS]));
}

void aesCbcInitForDecr(struct AesCbcContext *ctx, const uint32_t *k, const uint32_t *iv)
{
    struct AesSetupTempWorksSpace tmp;

    aesInitForDecr(&ctx->aes, &tmp, k);
    memcpy(ctx->iv, iv, sizeof(uint32_t[AES_BLOCK_WORDS]));
}

void aesCbcEncr(struct AesCbcContext *ctx, const uint32_t *src, uint32_t *dst)
{
    uint32_t i;

    for (i = 0; i < AES_BLOCK_WORDS; i++)
        ctx->iv[i] ^= *src++;

    aesEncr(&ctx->aes, ctx->iv, dst);
    memcpy(ctx->iv, dst, sizeof(uint32_t[AES_BLOCK_WORDS]));
}

void aesCbcDecr(struct AesCbcContext *ctx, const uint32_t *src, uint32_t *dst)
{
    uint32_t i, tmp[AES_BLOCK_WORDS];

    aesDecr(&ctx->aes, src, tmp);
    for (i = 0; i < AES_BLOCK_WORDS; i++)
        tmp[i] ^= ctx->iv[i];

    memcpy(ctx->iv, src, sizeof(uint32_t[AES_BLOCK_WORDS]));
    memcpy(dst, tmp, sizeof(uint32_t[AES_BLOCK_WORDS]));
}