摘自网上一种AES加密，用C语言实现通过32字节密钥对16字节长度数据进行加密。
1 #include <string.h> 2 #include <stdio.h> 3 #ifndef uint8 4 #define uint8 unsigned char 5 #endif 6 #ifndef uint32 7 #define uint32 unsigned long int 8 #endif 9 typedef struct 10 { 11 uint32 erk[64]; /* encryption round keys */ 12 uint32 drk[64]; /* decryption round keys */ 13 int nr; /* number of rounds */ 14 } 15 aes_context; 16 //#define TEST 17 18 /* uncomment the following line to use pre-computed tables */ 19 /* otherwise the tables will be generated at the first run */ 20 21 /* #define FIXED_TABLES */ 22 23 #ifndef FIXED_TABLES 24 25 /* forward S-box & tables */ 26 27 uint32 FSb[256]; 28 uint32 FT0[256]; 29 uint32 FT1[256]; 30 uint32 FT2[256]; 31 uint32 FT3[256]; 32 33 /* reverse S-box & tables */ 34 35 uint32 RSb[256]; 36 uint32 RT0[256]; 37 uint32 RT1[256]; 38 uint32 RT2[256]; 39 uint32 RT3[256]; 40 41 /* round constants */ 42 43 uint32 RCON[10]; 44 45 /* tables generation flag */ 46 47 int do_init = 1; 48 49 /* tables generation routine */ 50 51 #define ROTR8(x) ( ( ( x << 24 ) & 0xFFFFFFFF ) | 52 ((x & 0xFFFFFFFF) >> 8)) 53 54 #define XTIME(x) ( ( x << 1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) ) 55 #define MUL(x,y) ( ( x && y ) ? pow[(log[x] + log[y]) % 255] : 0 ) 56 57 void aes_gen_tables(void) 58 { 59 int i; 60 uint8 x, y; 61 uint8 pow[256]; 62 uint8 log[256]; 63 64 /* compute pow and log tables over GF(2^8) */ 65 66 for (i = 0, x = 1; i < 256; i++, x ^= XTIME(x)) 67 { 68 pow[i] = x; 69 log[x] = i; 70 } 71 72 /* calculate the round constants */ 73 74 for (i = 0, x = 1; i < 10; i++, x = XTIME(x)) 75 { 76 RCON[i] = (uint32)x << 24; 77 } 78 79 /* generate the forward and reverse S-boxes */ 80 81 FSb[0x00] = 0x63; 82 RSb[0x63] = 0x00; 83 84 for (i = 1; i < 256; i++) 85 { 86 x = pow[255 - log[i]]; 87 88 y = x; y = (y << 1) | (y >> 7); 89 x ^= y; y = (y << 1) | (y >> 7); 90 x ^= y; y = (y << 1) | (y >> 7); 91 x ^= y; y = (y << 1) | (y >> 7); 92 x ^= y ^ 0x63; 93 94 FSb[i] = x; 95 RSb[x] = i; 96 } 97 98 /* generate the forward and reverse tables */ 99 100 for (i = 0; i < 256; i++) 101 { 102 x = (unsigned char)FSb[i]; y = XTIME(x); 103 104 FT0[i] = (uint32)(x ^ y) ^ 105 ((uint32)x << 8) ^ 106 ((uint32)x << 16) ^ 107 ((uint32)y << 24); 108 109 FT0[i] &= 0xFFFFFFFF; 110 111 FT1[i] = ROTR8(FT0[i]); 112 FT2[i] = ROTR8(FT1[i]); 113 FT3[i] = ROTR8(FT2[i]); 114 115 y = (unsigned char)RSb[i]; 116 117 RT0[i] = ((uint32)MUL(0x0B, y)) ^ 118 ((uint32)MUL(0x0D, y) << 8) ^ 119 ((uint32)MUL(0x09, y) << 16) ^ 120 ((uint32)MUL(0x0E, y) << 24); 121 122 RT0[i] &= 0xFFFFFFFF; 123 124 RT1[i] = ROTR8(RT0[i]); 125 RT2[i] = ROTR8(RT1[i]); 126 RT3[i] = ROTR8(RT2[i]); 127 } 128 } 129 130 #else 131 132 /* forward S-box */ 133 134 static const uint32 FSb[256] = 135 { 136 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 137 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76, 138 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 139 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, 140 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 141 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15, 142 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 143 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75, 144 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 145 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, 146 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 147 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, 148 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 149 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8, 150 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 151 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 152 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 153 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73, 154 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 155 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB, 156 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 157 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, 158 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 159 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08, 160 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 161 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, 162 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 163 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 164 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 165 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF, 166 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 167 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16 168 }; 169 170 /* forward tables */ 171 172 #define FT 173 174 V(C6, 63, 63, A5), V(F8, 7C, 7C, 84), V(EE, 77, 77, 99), V(F6, 7B, 7B, 8D), 175 V(FF, F2, F2, 0D), V(D6, 6B, 6B, BD), V(DE, 6F, 6F, B1), V(91, C5, C5, 54), 176 V(60, 30, 30, 50), V(02, 01, 01, 03), V(CE, 67, 67, A9), V(56, 2B, 2B, 7D), 177 V(E7, FE, FE, 19), V(B5, D7, D7, 62), V(4D, AB, AB, E6), V(EC, 76, 76, 9A), 178 V(8F, CA, CA, 45), V(1F, 82, 82, 9D), V(89, C9, C9, 40), V(FA, 7D, 7D, 87), 179 V(EF, FA, FA, 15), V(B2, 59, 59, EB), V(8E, 47, 47, C9), V(FB, F0, F0, 0B), 180 V(41, AD, AD, EC), V(B3, D4, D4, 67), V(5F, A2, A2, FD), V(45, AF, AF, EA), 181 V(23, 9C, 9C, BF), V(53, A4, A4, F7), V(E4, 72, 72, 96), V(9B, C0, C0, 5B), 182 V(75, B7, B7, C2), V(E1, FD, FD, 1C), V(3D, 93, 93, AE), V(4C, 26, 26, 6A), 183 V(6C, 36, 36, 5A), V(7E, 3F, 3F, 41), V(F5, F7, F7, 02), V(83, CC, CC, 4F), 184 V(68, 34, 34, 5C), V(51, A5, A5, F4), V(D1, E5, E5, 34), V(F9, F1, F1, 08), 185 V(E2, 71, 71, 93), V(AB, D8, D8, 73), V(62, 31, 31, 53), V(2A, 15, 15, 3F), 186 V(08, 04, 04, 0C), V(95, C7, C7, 52), V(46, 23, 23, 65), V(9D, C3, C3, 5E), 187 V(30, 18, 18, 28), V(37, 96, 96, A1), V(0A, 05, 05, 0F), V(2F, 9A, 9A, B5), 188 V(0E, 07, 07, 09), V(24, 12, 12, 36), V(1B, 80, 80, 9B), V(DF, E2, E2, 3D), 189 V(CD, EB, EB, 26), V(4E, 27, 27, 69), V(7F, B2, B2, CD), V(EA, 75, 75, 9F), 190 V(12, 09, 09, 1B), V(1D, 83, 83, 9E), V(58, 2C, 2C, 74), V(34, 1A, 1A, 2E), 191 V(36, 1B, 1B, 2D), V(DC, 6E, 6E, B2), V(B4, 5A, 5A, EE), V(5B, A0, A0, FB), 192 V(A4, 52, 52, F6), V(76, 3B, 3B, 4D), V(B7, D6, D6, 61), V(7D, B3, B3, CE), 193 V(52, 29, 29, 7B), V(DD, E3, E3, 3E), V(5E, 2F, 2F, 71), V(13, 84, 84, 97), 194 V(A6, 53, 53, F5), V(B9, D1, D1, 68), V(00, 00, 00, 00), V(C1, ED, ED, 2C), 195 V(40, 20, 20, 60), V(E3, FC, FC, 1F), V(79, B1, B1, C8), V(B6, 5B, 5B, ED), 196 V(D4, 6A, 6A, BE), V(8D, CB, CB, 46), V(67, BE, BE, D9), V(72, 39, 39, 4B), 197 V(94, 4A, 4A, DE), V(98, 4C, 4C, D4), V(B0, 58, 58, E8), V(85, CF, CF, 4A), 198 V(BB, D0, D0, 6B), V(C5, EF, EF, 2A), V(4F, AA, AA, E5), V(ED, FB, FB, 16), 199 V(86, 43, 43, C5), V(9A, 4D, 4D, D7), V(66, 33, 33, 55), V(11, 85, 85, 94), 200 V(8A, 45, 45, CF), V(E9, F9, F9, 10), V(04, 02, 02, 06), V(FE, 7F, 7F, 81), 201 V(A0, 50, 50, F0), V(78, 3C, 3C, 44), V(25, 9F, 9F, BA), V(4B, A8, A8, E3), 202 V(A2, 51, 51, F3), V(5D, A3, A3, FE), V(80, 40, 40, C0), V(05, 8F, 8F, 8A), 203 V(3F, 92, 92, AD), V(21, 9D, 9D, BC), V(70, 38, 38, 48), V(F1, F5, F5, 04), 204 V(63, BC, BC, DF), V(77, B6, B6, C1), V(AF, DA, DA, 75), V(42, 21, 21, 63), 205 V(20, 10, 10, 30), V(E5, FF, FF, 1A), V(FD, F3, F3, 0E), V(BF, D2, D2, 6D), 206 V(81, CD, CD, 4C), V(18, 0C, 0C, 14), V(26, 13, 13, 35), V(C3, EC, EC, 2F), 207 V(BE, 5F, 5F, E1), V(35, 97, 97, A2), V(88, 44, 44, CC), V(2E, 17, 17, 39), 208 V(93, C4, C4, 57), V(55, A7, A7, F2), V(FC, 7E, 7E, 82), V(7A, 3D, 3D, 47), 209 V(C8, 64, 64, AC), V(BA, 5D, 5D, E7), V(32, 19, 19, 2B), V(E6, 73, 73, 95), 210 V(C0, 60, 60, A0), V(19, 81, 81, 98), V(9E, 4F, 4F, D1), V(A3, DC, DC, 7F), 211 V(44, 22, 22, 66), V(54, 2A, 2A, 7E), V(3B, 90, 90, AB), V(0B, 88, 88, 83), 212 V(8C, 46, 46, CA), V(C7, EE, EE, 29), V(6B, B8, B8, D3), V(28, 14, 14, 3C), 213 V(A7, DE, DE, 79), V(BC, 5E, 5E, E2), V(16, 0B, 0B, 1D), V(AD, DB, DB, 76), 214 V(DB, E0, E0, 3B), V(64, 32, 32, 56), V(74, 3A, 3A, 4E), V(14, 0A, 0A, 1E), 215 V(92, 49, 49, DB), V(0C, 06, 06, 0A), V(48, 24, 24, 6C), V(B8, 5C, 5C, E4), 216 V(9F, C2, C2, 5D), V(BD, D3, D3, 6E), V(43, AC, AC, EF), V(C4, 62, 62, A6), 217 V(39, 91, 91, A8), V(31, 95, 95, A4), V(D3, E4, E4, 37), V(F2, 79, 79, 8B), 218 V(D5, E7, E7, 32), V(8B, C8, C8, 43), V(6E, 37, 37, 59), V(DA, 6D, 6D, B7), 219 V(01, 8D, 8D, 8C), V(B1, D5, D5, 64), V(9C, 4E, 4E, D2), V(49, A9, A9, E0), 220 V(D8, 6C, 6C, B4), V(AC, 56, 56, FA), V(F3, F4, F4, 07), V(CF, EA, EA, 25), 221 V(CA, 65, 65, AF), V(F4, 7A, 7A, 8E), V(47, AE, AE, E9), V(10, 08, 08, 18), 222 V(6F, BA, BA, D5), V(F0, 78, 78, 88), V(4A, 25, 25, 6F), V(5C, 2E, 2E, 72), 223 V(38, 1C, 1C, 24), V(57, A6, A6, F1), V(73, B4, B4, C7), V(97, C6, C6, 51), 224 V(CB, E8, E8, 23), V(A1, DD, DD, 7C), V(E8, 74, 74, 9C), V(3E, 1F, 1F, 21), 225 V(96, 4B, 4B, DD), V(61, BD, BD, DC), V(0D, 8B, 8B, 86), V(0F, 8A, 8A, 85), 226 V(E0, 70, 70, 90), V(7C, 3E, 3E, 42), V(71, B5, B5, C4), V(CC, 66, 66, AA), 227 V(90, 48, 48, D8), V(06, 03, 03, 05), V(F7, F6, F6, 01), V(1C, 0E, 0E, 12), 228 V(C2, 61, 61, A3), V(6A, 35, 35, 5F), V(AE, 57, 57, F9), V(69, B9, B9, D0), 229 V(17, 86, 86, 91), V(99, C1, C1, 58), V(3A, 1D, 1D, 27), V(27, 9E, 9E, B9), 230 V(D9, E1, E1, 38), V(EB, F8, F8, 13), V(2B, 98, 98, B3), V(22, 11, 11, 33), 231 V(D2, 69, 69, BB), V(A9, D9, D9, 70), V(07, 8E, 8E, 89), V(33, 94, 94, A7), 232 V(2D, 9B, 9B, B6), V(3C, 1E, 1E, 22), V(15, 87, 87, 92), V(C9, E9, E9, 20), 233 V(87, CE, CE, 49), V(AA, 55, 55, FF), V(50, 28, 28, 78), V(A5, DF, DF, 7A), 234 V(03, 8C, 8C, 8F), V(59, A1, A1, F8), V(09, 89, 89, 80), V(1A, 0D, 0D, 17), 235 V(65, BF, BF, DA), V(D7, E6, E6, 31), V(84, 42, 42, C6), V(D0, 68, 68, B8), 236 V(82, 41, 41, C3), V(29, 99, 99, B0), V(5A, 2D, 2D, 77), V(1E, 0F, 0F, 11), 237 V(7B, B0, B0, CB), V(A8, 54, 54, FC), V(6D, BB, BB, D6), V(2C, 16, 16, 3A) 238 239 #define V(a,b,c,d) 0x##a##b##c##d 240 static const uint32 FT0[256] = { FT }; 241 #undef V 242 243 #define V(a,b,c,d) 0x##d##a##b##c 244 static const uint32 FT1[256] = { FT }; 245 #undef V 246 247 #define V(a,b,c,d) 0x##c##d##a##b 248 static const uint32 FT2[256] = { FT }; 249 #undef V 250 251 #define V(a,b,c,d) 0x##b##c##d##a 252 static const uint32 FT3[256] = { FT }; 253 #undef V 254 255 #undef FT 256 257 /* reverse S-box */ 258 259 static const uint32 RSb[256] = 260 { 261 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 262 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB, 263 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 264 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB, 265 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 266 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E, 267 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 268 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25, 269 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 270 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92, 271 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 272 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84, 273 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 274 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06, 275 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 276 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B, 277 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 278 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73, 279 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 280 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E, 281 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 282 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B, 283 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 284 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4, 285 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 286 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F, 287 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 288 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF, 289 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 290 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61, 291 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 292 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D 293 }; 294 295 /* reverse tables */ 296 297 #define RT 298 299 V(51, F4, A7, 50), V(7E, 41, 65, 53), V(1A, 17, A4, C3), V(3A, 27, 5E, 96), 300 V(3B, AB, 6B, CB), V(1F, 9D, 45, F1), V(AC, FA, 58, AB), V(4B, E3, 03, 93), 301 V(20, 30, FA, 55), V(AD, 76, 6D, F6), V(88, CC, 76, 91), V(F5, 02, 4C, 25), 302 V(4F, E5, D7, FC), V(C5, 2A, CB, D7), V(26, 35, 44, 80), V(B5, 62, A3, 8F), 303 V(DE, B1, 5A, 49), V(25, BA, 1B, 67), V(45, EA, 0E, 98), V(5D, FE, C0, E1), 304 V(C3, 2F, 75, 02), V(81, 4C, F0, 12), V(8D, 46, 97, A3), V(6B, D3, F9, C6), 305 V(03, 8F, 5F, E7), V(15, 92, 9C, 95), V(BF, 6D, 7A, EB), V(95, 52, 59, DA), 306 V(D4, BE, 83, 2D), V(58, 74, 21, D3), V(49, E0, 69, 29), V(8E, C9, C8, 44), 307 V(75, C2, 89, 6A), V(F4, 8E, 79, 78), V(99, 58, 3E, 6B), V(27, B9, 71, DD), 308 V(BE, E1, 4F, B6), V(F0, 88, AD, 17), V(C9, 20, AC, 66), V(7D, CE, 3A, B4), 309 V(63, DF, 4A, 18), V(E5, 1A, 31, 82), V(97, 51, 33, 60), V(62, 53, 7F, 45), 310 V(B1, 64, 77, E0), V(BB, 6B, AE, 84), V(FE, 81, A0, 1C), V(F9, 08, 2B, 94), 311 V(70, 48, 68, 58), V(8F, 45, FD, 19), V(94, DE, 6C, 87), V(52, 7B, F8, B7), 312 V(AB, 73, D3, 23), V(72, 4B, 02, E2), V(E3, 1F, 8F, 57), V(66, 55, AB, 2A), 313 V(B2, EB, 28, 07), V(2F, B5, C2, 03), V(86, C5, 7B, 9A), V(D3, 37, 08, A5), 314 V(30, 28, 87, F2), V(23, BF, A5, B2), V(02, 03, 6A, BA), V(ED, 16, 82, 5C), 315 V(8A, CF, 1C, 2B), V(A7, 79, B4, 92), V(F3, 07, F2, F0), V(4E, 69, E2, A1), 316 V(65, DA, F4, CD), V(06, 05, BE, D5), V(D1, 34, 62, 1F), V(C4, A6, FE, 8A), 317 V(34, 2E, 53, 9D), V(A2, F3, 55, A0), V(05, 8A, E1, 32), V(A4, F6, EB, 75), 318 V(0B, 83, EC, 39), V(40, 60, EF, AA), V(5E, 71, 9F, 06), V(BD, 6E, 10, 51), 319 V(3E, 21, 8A, F9), V(96, DD, 06, 3D), V(DD, 3E, 05, AE), V(4D, E6, BD, 46), 320 V(91, 54, 8D, B5), V(71, C4, 5D, 05), V(04, 06, D4, 6F), V(60, 50, 15, FF), 321 V(19, 98, FB, 24), V(D6, BD, E9, 97), V(89, 40, 43, CC), V(67, D9, 9E, 77), 322 V(B0, E8, 42, BD), V(07, 89, 8B, 88), V(E7, 19, 5B, 38), V(79, C8, EE, DB), 323 V(A1, 7C, 0A, 47), V(7C, 42, 0F, E9), V(F8, 84, 1E, C9), V(00, 00, 00, 00), 324 V(09, 80, 86, 83), V(32, 2B, ED, 48), V(1E, 11, 70, AC), V(6C, 5A, 72, 4E), 325 V(FD, 0E, FF, FB), V(0F, 85, 38, 56), V(3D, AE, D5, 1E), V(36, 2D, 39, 27), 326 V(0A, 0F, D9, 64), V(68, 5C, A6, 21), V(9B, 5B, 54, D1), V(24, 36, 2E, 3A), 327 V(0C, 0A, 67, B1), V(93, 57, E7, 0F), V(B4, EE, 96, D2), V(1B, 9B, 91, 9E), 328 V(80, C0, C5, 4F), V(61, DC, 20, A2), V(5A, 77, 4B, 69), V(1C, 12, 1A, 16), 329 V(E2, 93, BA, 0A), V(C0, A0, 2A, E5), V(3C, 22, E0, 43), V(12, 1B, 17, 1D), 330 V(0E, 09, 0D, 0B), V(F2, 8B, C7, AD), V(2D, B6, A8, B9), V(14, 1E, A9, C8), 331 V(57, F1, 19, 85), V(AF, 75, 07, 4C), V(EE, 99, DD, BB), V(A3, 7F, 60, FD), 332 V(F7, 01, 26, 9F), V(5C, 72, F5, BC), V(44, 66, 3B, C5), V(5B, FB, 7E, 34), 333 V(8B, 43, 29, 76), V(CB, 23, C6, DC), V(B6, ED, FC, 68), V(B8, E4, F1, 63), 334 V(D7, 31, DC, CA), V(42, 63, 85, 10), V(13, 97, 22, 40), V(84, C6, 11, 20), 335 V(85, 4A, 24, 7D), V(D2, BB, 3D, F8), V(AE, F9, 32, 11), V(C7, 29, A1, 6D), 336 V(1D, 9E, 2F, 4B), V(DC, B2, 30, F3), V(0D, 86, 52, EC), V(77, C1, E3, D0), 337 V(2B, B3, 16, 6C), V(A9, 70, B9, 99), V(11, 94, 48, FA), V(47, E9, 64, 22), 338 V(A8, FC, 8C, C4), V(A0, F0, 3F, 1A), V(56, 7D, 2C, D8), V(22, 33, 90, EF), 339 V(87, 49, 4E, C7), V(D9, 38, D1, C1), V(8C, CA, A2, FE), V(98, D4, 0B, 36), 340 V(A6, F5, 81, CF), V(A5, 7A, DE, 28), V(DA, B7, 8E, 26), V(3F, AD, BF, A4), 341 V(2C, 3A, 9D, E4), V(50, 78, 92, 0D), V(6A, 5F, CC, 9B), V(54, 7E, 46, 62), 342 V(F6, 8D, 13, C2), V(90, D8, B8, E8), V(2E, 39, F7, 5E), V(82, C3, AF, F5), 343 V(9F, 5D, 80, BE), V(69, D0, 93, 7C), V(6F, D5, 2D, A9), V(CF, 25, 12, B3), 344 V(C8, AC, 99, 3B), V(10, 18, 7D, A7), V(E8, 9C, 63, 6E), V(DB, 3B, BB, 7B), 345 V(CD, 26, 78, 09), V(6E, 59, 18, F4), V(EC, 9A, B7, 01), V(83, 4F, 9A, A8), 346 V(E6, 95, 6E, 65), V(AA, FF, E6, 7E), V(21, BC, CF, 08), V(EF, 15, E8, E6), 347 V(BA, E7, 9B, D9), V(4A, 6F, 36, CE), V(EA, 9F, 09, D4), V(29, B0, 7C, D6), 348 V(31, A4, B2, AF), V(2A, 3F, 23, 31), V(C6, A5, 94, 30), V(35, A2, 66, C0), 349 V(74, 4E, BC, 37), V(FC, 82, CA, A6), V(E0, 90, D0, B0), V(33, A7, D8, 15), 350 V(F1, 04, 98, 4A), V(41, EC, DA, F7), V(7F, CD, 50, 0E), V(17, 91, F6, 2F), 351 V(76, 4D, D6, 8D), V(43, EF, B0, 4D), V(CC, AA, 4D, 54), V(E4, 96, 04, DF), 352 V(9E, D1, B5, E3), V(4C, 6A, 88, 1B), V(C1, 2C, 1F, B8), V(46, 65, 51, 7F), 353 V(9D, 5E, EA, 04), V(01, 8C, 35, 5D), V(FA, 87, 74, 73), V(FB, 0B, 41, 2E), 354 V(B3, 67, 1D, 5A), V(92, DB, D2, 52), V(E9, 10, 56, 33), V(6D, D6, 47, 13), 355 V(9A, D7, 61, 8C), V(37, A1, 0C, 7A), V(59, F8, 14, 8E), V(EB, 13, 3C, 89), 356 V(CE, A9, 27, EE), V(B7, 61, C9, 35), V(E1, 1C, E5, ED), V(7A, 47, B1, 3C), 357 V(9C, D2, DF, 59), V(55, F2, 73, 3F), V(18, 14, CE, 79), V(73, C7, 37, BF), 358 V(53, F7, CD, EA), V(5F, FD, AA, 5B), V(DF, 3D, 6F, 14), V(78, 44, DB, 86), 359 V(CA, AF, F3, 81), V(B9, 68, C4, 3E), V(38, 24, 34, 2C), V(C2, A3, 40, 5F), 360 V(16, 1D, C3, 72), V(BC, E2, 25, 0C), V(28, 3C, 49, 8B), V(FF, 0D, 95, 41), 361 V(39, A8, 01, 71), V(08, 0C, B3, DE), V(D8, B4, E4, 9C), V(64, 56, C1, 90), 362 V(7B, CB, 84, 61), V(D5, 32, B6, 70), V(48, 6C, 5C, 74), V(D0, B8, 57, 42) 363 364 #define V(a,b,c,d) 0x##a##b##c##d 365 static const uint32 RT0[256] = { RT }; 366 #undef V 367 368 #define V(a,b,c,d) 0x##d##a##b##c 369 static const uint32 RT1[256] = { RT }; 370 #undef V 371 372 #define V(a,b,c,d) 0x##c##d##a##b 373 static const uint32 RT2[256] = { RT }; 374 #undef V 375 376 #define V(a,b,c,d) 0x##b##c##d##a 377 static const uint32 RT3[256] = { RT }; 378 #undef V 379 380 #undef RT 381 382 /* round constants */ 383 384 static const uint32 RCON[10] = 385 { 386 0x01000000, 0x02000000, 0x04000000, 0x08000000, 387 0x10000000, 0x20000000, 0x40000000, 0x80000000, 388 0x1B000000, 0x36000000 389 }; 390 391 int do_init = 0; 392 393 void aes_gen_tables(void) 394 { 395 } 396 397 #endif 398 399 /* platform-independant 32-bit integer manipulation macros */ 400 401 #define GET_UINT32(n,b,i) 402 { 403 (n) = ((uint32)(b)[(i)] << 24) 404 | ((uint32)(b)[(i)+1] << 16) 405 | ((uint32)(b)[(i)+2] << 8) 406 | ((uint32)(b)[(i)+3]); 407 } 408 409 #define PUT_UINT32(n,b,i) 410 { 411 (b)[(i)] = (uint8)((n) >> 24); 412 (b)[(i)+1] = (uint8)((n) >> 16); 413 (b)[(i)+2] = (uint8)((n) >> 8); 414 (b)[(i)+3] = (uint8)((n)); 415 } 416 417 /* decryption key schedule tables */ 418 419 int KT_init = 1; 420 421 uint32 KT0[256]; 422 uint32 KT1[256]; 423 uint32 KT2[256]; 424 uint32 KT3[256]; 425 426 /* AES key scheduling routine */ 427 428 int aes_set_key(aes_context *ctx, uint8 *key) 429 { 430 int i; 431 uint32 *RK, *SK; 432 433 if (do_init) 434 { 435 aes_gen_tables(); 436 437 do_init = 0; 438 } 439 ctx->nr = 14; 440 /*switch( nbits ) 441 { 442 case 128: ctx->nr = 10; break; 443 case 192: ctx->nr = 12; break; 444 case 256: ctx->nr = 14; break; 445 default : return( 1 ); 446 }*/ 447 448 RK = ctx->erk; 449 450 for (i = 0; i < 8; i++) 451 { 452 GET_UINT32(RK[i], key, i * 4); 453 } 454 for (i = 0; i < 7; i++, RK += 8) 455 { 456 RK[8] = RK[0] ^ RCON[i] ^ 457 (FSb[(uint8)(RK[7] >> 16)] << 24) ^ 458 (FSb[(uint8)(RK[7] >> 8)] << 16) ^ 459 (FSb[(uint8)(RK[7])] << 8) ^ 460 (FSb[(uint8)(RK[7] >> 24)]); 461 462 RK[9] = RK[1] ^ RK[8]; 463 RK[10] = RK[2] ^ RK[9]; 464 RK[11] = RK[3] ^ RK[10]; 465 466 RK[12] = RK[4] ^ 467 (FSb[(uint8)(RK[11] >> 24)] << 24) ^ 468 (FSb[(uint8)(RK[11] >> 16)] << 16) ^ 469 (FSb[(uint8)(RK[11] >> 8)] << 8) ^ 470 (FSb[(uint8)(RK[11])]); 471 472 RK[13] = RK[5] ^ RK[12]; 473 RK[14] = RK[6] ^ RK[13]; 474 RK[15] = RK[7] ^ RK[14]; 475 } 476 477 /* setup decryption round keys */ 478 479 if (KT_init) 480 { 481 for (i = 0; i < 256; i++) 482 { 483 KT0[i] = RT0[FSb[i]]; 484 KT1[i] = RT1[FSb[i]]; 485 KT2[i] = RT2[FSb[i]]; 486 KT3[i] = RT3[FSb[i]]; 487 } 488 489 KT_init = 0; 490 } 491 492 SK = ctx->drk; 493 494 *SK++ = *RK++; 495 *SK++ = *RK++; 496 *SK++ = *RK++; 497 *SK++ = *RK++; 498 499 for (i = 1; i < 14; i++) 500 { 501 RK -= 8; 502 503 *SK++ = KT0[(uint8)(*RK >> 24)] ^ 504 KT1[(uint8)(*RK >> 16)] ^ 505 KT2[(uint8)(*RK >> 8)] ^ 506 KT3[(uint8)(*RK)]; RK++; 507 508 *SK++ = KT0[(uint8)(*RK >> 24)] ^ 509 KT1[(uint8)(*RK >> 16)] ^ 510 KT2[(uint8)(*RK >> 8)] ^ 511 KT3[(uint8)(*RK)]; RK++; 512 513 *SK++ = KT0[(uint8)(*RK >> 24)] ^ 514 KT1[(uint8)(*RK >> 16)] ^ 515 KT2[(uint8)(*RK >> 8)] ^ 516 KT3[(uint8)(*RK)]; RK++; 517 518 *SK++ = KT0[(uint8)(*RK >> 24)] ^ 519 KT1[(uint8)(*RK >> 16)] ^ 520 KT2[(uint8)(*RK >> 8)] ^ 521 KT3[(uint8)(*RK)]; RK++; 522 } 523 524 RK -= 8; 525 526 *SK++ = *RK++; 527 *SK++ = *RK++; 528 *SK++ = *RK++; 529 *SK++ = *RK++; 530 531 return(0); 532 } 533 534 /* AES 256-bit block encryption routine */ 535 536 void aes_encrypt(aes_context *ctx, uint8 input[16], uint8 output[16]) 537 { 538 uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3; 539 540 RK = ctx->erk; 541 542 GET_UINT32(X0, input, 0); X0 ^= RK[0]; 543 GET_UINT32(X1, input, 4); X1 ^= RK[1]; 544 GET_UINT32(X2, input, 8); X2 ^= RK[2]; 545 GET_UINT32(X3, input, 12); X3 ^= RK[3]; 546 547 #define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3) 548 { 549 RK += 4; 550 551 X0 = RK[0] ^ FT0[(uint8)(Y0 >> 24)] ^ 552 FT1[(uint8)(Y1 >> 16)] ^ 553 FT2[(uint8)(Y2 >> 8)] ^ 554 FT3[(uint8)(Y3)]; 555 556 X1 = RK[1] ^ FT0[(uint8)(Y1 >> 24)] ^ 557 FT1[(uint8)(Y2 >> 16)] ^ 558 FT2[(uint8)(Y3 >> 8)] ^ 559 FT3[(uint8)(Y0)]; 560 561 X2 = RK[2] ^ FT0[(uint8)(Y2 >> 24)] ^ 562 FT1[(uint8)(Y3 >> 16)] ^ 563 FT2[(uint8)(Y0 >> 8)] ^ 564 FT3[(uint8)(Y1)]; 565 566 X3 = RK[3] ^ FT0[(uint8)(Y3 >> 24)] ^ 567 FT1[(uint8)(Y0 >> 16)] ^ 568 FT2[(uint8)(Y1 >> 8)] ^ 569 FT3[(uint8)(Y2)]; 570 } 571 572 AES_FROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 1 */ 573 AES_FROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); /* round 2 */ 574 AES_FROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 3 */ 575 AES_FROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); /* round 4 */ 576 AES_FROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 5 */ 577 AES_FROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); /* round 6 */ 578 AES_FROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 7 */ 579 AES_FROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); /* round 8 */ 580 AES_FROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 9 */ 581 582 // if( ctx->nr > 10 ) 583 //{ 584 AES_FROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); /* round 10 */ 585 AES_FROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 11 */ 586 //} 587 AES_FROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); /* round 12 */ 588 AES_FROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 13 */ 589 590 591 /* last round */ 592 593 RK += 4; 594 595 X0 = RK[0] ^ (FSb[(uint8)(Y0 >> 24)] << 24) ^ 596 (FSb[(uint8)(Y1 >> 16)] << 16) ^ 597 (FSb[(uint8)(Y2 >> 8)] << 8) ^ 598 (FSb[(uint8)(Y3)]); 599 600 X1 = RK[1] ^ (FSb[(uint8)(Y1 >> 24)] << 24) ^ 601 (FSb[(uint8)(Y2 >> 16)] << 16) ^ 602 (FSb[(uint8)(Y3 >> 8)] << 8) ^ 603 (FSb[(uint8)(Y0)]); 604 605 X2 = RK[2] ^ (FSb[(uint8)(Y2 >> 24)] << 24) ^ 606 (FSb[(uint8)(Y3 >> 16)] << 16) ^ 607 (FSb[(uint8)(Y0 >> 8)] << 8) ^ 608 (FSb[(uint8)(Y1)]); 609 610 X3 = RK[3] ^ (FSb[(uint8)(Y3 >> 24)] << 24) ^ 611 (FSb[(uint8)(Y0 >> 16)] << 16) ^ 612 (FSb[(uint8)(Y1 >> 8)] << 8) ^ 613 (FSb[(uint8)(Y2)]); 614 615 PUT_UINT32(X0, output, 0); 616 PUT_UINT32(X1, output, 4); 617 PUT_UINT32(X2, output, 8); 618 PUT_UINT32(X3, output, 12); 619 } 620 621 /* AES 256-bit block decryption routine */ 622 623 void aes_decrypt(aes_context *ctx, uint8 input[16], uint8 output[16]) 624 { 625 uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3; 626 627 RK = ctx->drk; 628 629 GET_UINT32(X0, input, 0); X0 ^= RK[0]; 630 GET_UINT32(X1, input, 4); X1 ^= RK[1]; 631 GET_UINT32(X2, input, 8); X2 ^= RK[2]; 632 GET_UINT32(X3, input, 12); X3 ^= RK[3]; 633 634 #define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3) 635 { 636 RK += 4; 637 638 X0 = RK[0] ^ RT0[(uint8)(Y0 >> 24)] ^ 639 RT1[(uint8)(Y3 >> 16)] ^ 640 RT2[(uint8)(Y2 >> 8)] ^ 641 RT3[(uint8)(Y1)]; 642 643 X1 = RK[1] ^ RT0[(uint8)(Y1 >> 24)] ^ 644 RT1[(uint8)(Y0 >> 16)] ^ 645 RT2[(uint8)(Y3 >> 8)] ^ 646 RT3[(uint8)(Y2)]; 647 648 X2 = RK[2] ^ RT0[(uint8)(Y2 >> 24)] ^ 649 RT1[(uint8)(Y1 >> 16)] ^ 650 RT2[(uint8)(Y0 >> 8)] ^ 651 RT3[(uint8)(Y3)]; 652 653 X3 = RK[3] ^ RT0[(uint8)(Y3 >> 24)] ^ 654 RT1[(uint8)(Y2 >> 16)] ^ 655 RT2[(uint8)(Y1 >> 8)] ^ 656 RT3[(uint8)(Y0)]; 657 } 658 659 AES_RROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 1 */ 660 AES_RROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); /* round 2 */ 661 AES_RROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 3 */ 662 AES_RROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); /* round 4 */ 663 AES_RROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 5 */ 664 AES_RROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); /* round 6 */ 665 AES_RROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 7 */ 666 AES_RROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); /* round 8 */ 667 AES_RROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 9 */ 668 669 // if( ctx->nr > 10 ) 670 //{ 671 AES_RROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); /* round 10 */ 672 AES_RROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 11 */ 673 //} 674 AES_RROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); /* round 12 */ 675 AES_RROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); /* round 13 */ 676 677 678 /* last round */ 679 680 RK += 4; 681 682 X0 = RK[0] ^ (RSb[(uint8)(Y0 >> 24)] << 24) ^ 683 (RSb[(uint8)(Y3 >> 16)] << 16) ^ 684 (RSb[(uint8)(Y2 >> 8)] << 8) ^ 685 (RSb[(uint8)(Y1)]); 686 687 X1 = RK[1] ^ (RSb[(uint8)(Y1 >> 24)] << 24) ^ 688 (RSb[(uint8)(Y0 >> 16)] << 16) ^ 689 (RSb[(uint8)(Y3 >> 8)] << 8) ^ 690 (RSb[(uint8)(Y2)]); 691 692 X2 = RK[2] ^ (RSb[(uint8)(Y2 >> 24)] << 24) ^ 693 (RSb[(uint8)(Y1 >> 16)] << 16) ^ 694 (RSb[(uint8)(Y0 >> 8)] << 8) ^ 695 (RSb[(uint8)(Y3)]); 696 697 X3 = RK[3] ^ (RSb[(uint8)(Y3 >> 24)] << 24) ^ 698 (RSb[(uint8)(Y2 >> 16)] << 16) ^ 699 (RSb[(uint8)(Y1 >> 8)] << 8) ^ 700 (RSb[(uint8)(Y0)]); 701 702 PUT_UINT32(X0, output, 0); 703 PUT_UINT32(X1, output, 4); 704 PUT_UINT32(X2, output, 8); 705 PUT_UINT32(X3, output, 12); 706 } 707 /* 708 传进参数：密钥；加密字符串；密文存储文件 709 密钥会被自动填充或者截取为32字节 710 */ 711 void AES(unsigned char *key, unsigned char *buf, FILE *fp) 712 { 713 aes_context ctx; 714 char *keytemp; 715 //密钥拓展成32字节 716 for (int i=0,j=0; i<32; i++) 717 { 718 if (key[i] != 0) 719 { 720 keytemp[i] = key[i]; 721 j++; 722 } 723 else{ 724 keytemp[i] = key[i%j]; 725 } 726 } 727 printf("拓展后的密钥：", keytemp); 728 aes_set_key(&ctx, keytemp); 729 for (int k = 1; buf != ‘\0‘; k++) 730 { 731 if (k%8==0) 732 aes_encrypt(&ctx, buf, buf); 733 } 734 } 735 int main(void) 736 { 737 //int m, n, i, j; 738 int i; 739 //char c; 740 aes_context ctx; 741 unsigned char buf[16]; 742 unsigned char key[32] = { ‘f‘, ‘e‘, ‘f‘, ‘2‘, ‘f‘, ‘e‘, ‘g‘, ‘h‘, ‘b‘, ‘v‘, ‘c‘, ‘x‘, ‘z‘, ‘q‘, ‘e‘, ‘w‘, ‘f‘, ‘e‘, ‘f‘, ‘2‘, ‘f‘, ‘e‘, ‘g‘, ‘h‘, ‘f‘, ‘e‘, ‘f‘, ‘2‘, ‘f‘, ‘e‘, ‘g‘, ‘h‘ }; 743 printf("输入32个字符作为秘钥\n"); 744 scanf("%s",key); 745 printf(key); 746 printf("输入加密数据\n"); 747 scanf("%s", buf); 748 aes_set_key(&ctx, key); 749 /* for (i = 0; i<16; i++) 750 { 751 buf[i] = ‘d‘; 752 }*/ 753 printf("the data to encrypt:\n"); 754 for (i = 0; i<16; i++) 755 { 756 printf("%02x ", buf[i]); 757 } 758 printf("\n"); 759 760 getchar(); 761 aes_encrypt(&ctx, buf, buf); 762 printf("The encrypted data is:\n"); 763 for (i = 0; i<16; i++) 764 { 765 printf("%02x ", buf[i]); 766 } 767 printf("\n"); 768 printf("\n"); 769 770 771 // aes_set_key( &ctx, key, 128 + n * 64 ); 772 aes_decrypt(&ctx, buf, buf); 773 printf("The decrypted data is:\n"); 774 for (i = 0; i<16; i++) 775 { 776 printf("%02x ", buf[i]); 777 } 778 printf("\n"); 779 getchar(); 780 return 0; 781 782 } 783 784 //#endif