nel/3rdparty/seven_zip/Aes.c

   1 /* Aes.c -- AES encryption / decryption
   2 2017-01-24 : Igor Pavlov : Public domain */
   3
   4 #include "Precomp.h"
   5
   6 #include "Aes.h"
   7 #include "CpuArch.h"
   8
   9 static UInt32 T[256 * 4];
  10 static const Byte Sbox[256] = {
  11   0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
  12   0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
  13   0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
  14   0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
  15   0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
  16   0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
  17   0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
  18   0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
  19   0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
  20   0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
  21   0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
  22   0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
  23   0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
  24   0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
  25   0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
  26   0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16};
  27
  28 void MY_FAST_CALL AesCbc_Encode(UInt32 *ivAes, Byte *data, size_t numBlocks);
  29 void MY_FAST_CALL AesCbc_Decode(UInt32 *ivAes, Byte *data, size_t numBlocks);
  30 void MY_FAST_CALL AesCtr_Code(UInt32 *ivAes, Byte *data, size_t numBlocks);
  31
  32 void MY_FAST_CALL AesCbc_Encode_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
  33 void MY_FAST_CALL AesCbc_Decode_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
  34 void MY_FAST_CALL AesCtr_Code_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
  35
  36 AES_CODE_FUNC g_AesCbc_Encode;
  37 AES_CODE_FUNC g_AesCbc_Decode;
  38 AES_CODE_FUNC g_AesCtr_Code;
  39
  40 static UInt32 D[256 * 4];
  41 static Byte InvS[256];
  42
  43 static const Byte Rcon[11] = { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 };
  44
  45 #define xtime(x) ((((x) << 1) ^ (((x) & 0x80) != 0 ? 0x1B : 0)) & 0xFF)
  46
  47 #define Ui32(a0, a1, a2, a3) ((UInt32)(a0) | ((UInt32)(a1) << 8) | ((UInt32)(a2) << 16) | ((UInt32)(a3) << 24))
  48
  49 #define gb0(x) ( (x)          & 0xFF)
  50 #define gb1(x) (((x) >> ( 8)) & 0xFF)
  51 #define gb2(x) (((x) >> (16)) & 0xFF)
  52 #define gb3(x) (((x) >> (24)))
  53
  54 #define gb(n, x) gb ## n(x)
  55
  56 #define TT(x) (T + (x << 8))
  57 #define DD(x) (D + (x << 8))
  58
  59
  60 void AesGenTables(void)
  61 {
  62   unsigned i;
  63   for (i = 0; i < 256; i++)
  64     InvS[Sbox[i]] = (Byte)i;
  65
  66   for (i = 0; i < 256; i++)
  67   {
  68     {
  69       UInt32 a1 = Sbox[i];
  70       UInt32 a2 = xtime(a1);
  71       UInt32 a3 = a2 ^ a1;
  72       TT(0)[i] = Ui32(a2, a1, a1, a3);
  73       TT(1)[i] = Ui32(a3, a2, a1, a1);
  74       TT(2)[i] = Ui32(a1, a3, a2, a1);
  75       TT(3)[i] = Ui32(a1, a1, a3, a2);
  76     }
  77     {
  78       UInt32 a1 = InvS[i];
  79       UInt32 a2 = xtime(a1);
  80       UInt32 a4 = xtime(a2);
  81       UInt32 a8 = xtime(a4);
  82       UInt32 a9 = a8 ^ a1;
  83       UInt32 aB = a8 ^ a2 ^ a1;
  84       UInt32 aD = a8 ^ a4 ^ a1;
  85       UInt32 aE = a8 ^ a4 ^ a2;
  86       DD(0)[i] = Ui32(aE, a9, aD, aB);
  87       DD(1)[i] = Ui32(aB, aE, a9, aD);
  88       DD(2)[i] = Ui32(aD, aB, aE, a9);
  89       DD(3)[i] = Ui32(a9, aD, aB, aE);
  90     }
  91   }
  92
  93   g_AesCbc_Encode = AesCbc_Encode;
  94   g_AesCbc_Decode = AesCbc_Decode;
  95   g_AesCtr_Code = AesCtr_Code;
  96
  97   #ifdef MY_CPU_X86_OR_AMD64
  98   if (CPU_Is_Aes_Supported())
  99   {
 100     g_AesCbc_Encode = AesCbc_Encode_Intel;
 101     g_AesCbc_Decode = AesCbc_Decode_Intel;
 102     g_AesCtr_Code = AesCtr_Code_Intel;
 103   }
 104   #endif
 105 }
 106
 107
 108 #define HT(i, x, s) TT(x)[gb(x, s[(i + x) & 3])]
 109
 110 #define HT4(m, i, s, p) m[i] = \
 111     HT(i, 0, s) ^ \
 112     HT(i, 1, s) ^ \
 113     HT(i, 2, s) ^ \
 114     HT(i, 3, s) ^ w[p + i]
 115
 116 #define HT16(m, s, p) \
 117     HT4(m, 0, s, p); \
 118     HT4(m, 1, s, p); \
 119     HT4(m, 2, s, p); \
 120     HT4(m, 3, s, p); \
 121
 122 #define FT(i, x) Sbox[gb(x, m[(i + x) & 3])]
 123 #define FT4(i) dest[i] = Ui32(FT(i, 0), FT(i, 1), FT(i, 2), FT(i, 3)) ^ w[i];
 124
 125
 126 #define HD(i, x, s) DD(x)[gb(x, s[(i - x) & 3])]
 127
 128 #define HD4(m, i, s, p) m[i] = \
 129     HD(i, 0, s) ^ \
 130     HD(i, 1, s) ^ \
 131     HD(i, 2, s) ^ \
 132     HD(i, 3, s) ^ w[p + i];
 133
 134 #define HD16(m, s, p) \
 135     HD4(m, 0, s, p); \
 136     HD4(m, 1, s, p); \
 137     HD4(m, 2, s, p); \
 138     HD4(m, 3, s, p); \
 139
 140 #define FD(i, x) InvS[gb(x, m[(i - x) & 3])]
 141 #define FD4(i) dest[i] = Ui32(FD(i, 0), FD(i, 1), FD(i, 2), FD(i, 3)) ^ w[i];
 142
 143 void MY_FAST_CALL Aes_SetKey_Enc(UInt32 *w, const Byte *key, unsigned keySize)
 144 {
 145   unsigned i, wSize;
 146   wSize = keySize + 28;
 147   keySize /= 4;
 148   w[0] = ((UInt32)keySize / 2) + 3;
 149   w += 4;
 150
 151   for (i = 0; i < keySize; i++, key += 4)
 152     w[i] = GetUi32(key);
 153
 154   for (; i < wSize; i++)
 155   {
 156     UInt32 t = w[(size_t)i - 1];
 157     unsigned rem = i % keySize;
 158     if (rem == 0)
 159       t = Ui32(Sbox[gb1(t)] ^ Rcon[i / keySize], Sbox[gb2(t)], Sbox[gb3(t)], Sbox[gb0(t)]);
 160     else if (keySize > 6 && rem == 4)
 161       t = Ui32(Sbox[gb0(t)], Sbox[gb1(t)], Sbox[gb2(t)], Sbox[gb3(t)]);
 162     w[i] = w[i - keySize] ^ t;
 163   }
 164 }
 165
 166 void MY_FAST_CALL Aes_SetKey_Dec(UInt32 *w, const Byte *key, unsigned keySize)
 167 {
 168   unsigned i, num;
 169   Aes_SetKey_Enc(w, key, keySize);
 170   num = keySize + 20;
 171   w += 8;
 172   for (i = 0; i < num; i++)
 173   {
 174     UInt32 r = w[i];
 175     w[i] =
 176       DD(0)[Sbox[gb0(r)]] ^
 177       DD(1)[Sbox[gb1(r)]] ^
 178       DD(2)[Sbox[gb2(r)]] ^
 179       DD(3)[Sbox[gb3(r)]];
 180   }
 181 }
 182
 183 /* Aes_Encode and Aes_Decode functions work with little-endian words.
 184   src and dest are pointers to 4 UInt32 words.
 185   src and dest can point to same block */
 186
 187 static void Aes_Encode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
 188 {
 189   UInt32 s[4];
 190   UInt32 m[4];
 191   UInt32 numRounds2 = w[0];
 192   w += 4;
 193   s[0] = src[0] ^ w[0];
 194   s[1] = src[1] ^ w[1];
 195   s[2] = src[2] ^ w[2];
 196   s[3] = src[3] ^ w[3];
 197   w += 4;
 198   for (;;)
 199   {
 200     HT16(m, s, 0);
 201     if (--numRounds2 == 0)
 202       break;
 203     HT16(s, m, 4);
 204     w += 8;
 205   }
 206   w += 4;
 207   FT4(0); FT4(1); FT4(2); FT4(3);
 208 }
 209
 210 static void Aes_Decode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
 211 {
 212   UInt32 s[4];
 213   UInt32 m[4];
 214   UInt32 numRounds2 = w[0];
 215   w += 4 + numRounds2 * 8;
 216   s[0] = src[0] ^ w[0];
 217   s[1] = src[1] ^ w[1];
 218   s[2] = src[2] ^ w[2];
 219   s[3] = src[3] ^ w[3];
 220   for (;;)
 221   {
 222     w -= 8;
 223     HD16(m, s, 4);
 224     if (--numRounds2 == 0)
 225       break;
 226     HD16(s, m, 0);
 227   }
 228   FD4(0); FD4(1); FD4(2); FD4(3);
 229 }
 230
 231 void AesCbc_Init(UInt32 *p, const Byte *iv)
 232 {
 233   unsigned i;
 234   for (i = 0; i < 4; i++)
 235     p[i] = GetUi32(iv + i * 4);
 236 }
 237
 238 void MY_FAST_CALL AesCbc_Encode(UInt32 *p, Byte *data, size_t numBlocks)
 239 {
 240   for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)
 241   {
 242     p[0] ^= GetUi32(data);
 243     p[1] ^= GetUi32(data + 4);
 244     p[2] ^= GetUi32(data + 8);
 245     p[3] ^= GetUi32(data + 12);
 246
 247     Aes_Encode(p + 4, p, p);
 248
 249     SetUi32(data,      p[0]);
 250     SetUi32(data + 4,  p[1]);
 251     SetUi32(data + 8,  p[2]);
 252     SetUi32(data + 12, p[3]);
 253   }
 254 }
 255
 256 void MY_FAST_CALL AesCbc_Decode(UInt32 *p, Byte *data, size_t numBlocks)
 257 {
 258   UInt32 in[4], out[4];
 259   for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)
 260   {
 261     in[0] = GetUi32(data);
 262     in[1] = GetUi32(data + 4);
 263     in[2] = GetUi32(data + 8);
 264     in[3] = GetUi32(data + 12);
 265
 266     Aes_Decode(p + 4, out, in);
 267
 268     SetUi32(data,      p[0] ^ out[0]);
 269     SetUi32(data + 4,  p[1] ^ out[1]);
 270     SetUi32(data + 8,  p[2] ^ out[2]);
 271     SetUi32(data + 12, p[3] ^ out[3]);
 272
 273     p[0] = in[0];
 274     p[1] = in[1];
 275     p[2] = in[2];
 276     p[3] = in[3];
 277   }
 278 }
 279
 280 void MY_FAST_CALL AesCtr_Code(UInt32 *p, Byte *data, size_t numBlocks)
 281 {
 282   for (; numBlocks != 0; numBlocks--)
 283   {
 284     UInt32 temp[4];
 285     unsigned i;
 286
 287     if (++p[0] == 0)
 288       p[1]++;
 289
 290     Aes_Encode(p + 4, temp, p);
 291
 292     for (i = 0; i < 4; i++, data += 4)
 293     {
 294       UInt32 t = temp[i];
 295
 296       #ifdef MY_CPU_LE_UNALIGN
 297         *((UInt32 *)data) ^= t;
 298       #else
 299         data[0] ^= (t & 0xFF);
 300         data[1] ^= ((t >> 8) & 0xFF);
 301         data[2] ^= ((t >> 16) & 0xFF);
 302         data[3] ^= ((t >> 24));
 303       #endif
 304     }
 305   }
 306 }