UltraGrid
UltraGrid Low-Latency High-Resolution Transmission System
Loading...
Searching...
No Matches
Macros | Typedefs | Functions
crypt_aes_impl.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define MAXKB   (256/8)
 
#define MAXKC   (256/32)
 
#define MAXNR   14
 

Typedefs

typedef unsigned short u16
 
typedef unsigned char u8
 

Functions

void rijndaelDecrypt (const u32 rk[], int Nr, const u8 ct[16], u8 pt[16])
 
void rijndaelDecryptRound (const u32 rk[], int Nr, u8 block[16], int rounds)
 
void rijndaelEncrypt (const u32 rk[], int Nr, const u8 pt[16], u8 ct[16])
 
void rijndaelEncryptRound (const u32 rk[], int Nr, u8 block[16], int rounds)
 
int rijndaelKeySetupDec (u32 rk[], const u8 cipherKey[], int keyBits)
 
int rijndaelKeySetupEnc (u32 rk[], const u8 cipherKey[], int keyBits)
 

Macro Definition Documentation

◆ MAXKB

#define MAXKB   (256/8)

Definition at line 30 of file crypt_aes_impl.h.

Referenced by makeKey().

◆ MAXKC

#define MAXKC   (256/32)

rijndael-alg-fst.h

Version
3.0 (December 2000)

Optimised ANSI C code for the Rijndael cipher (now AES)

Author
Vincent Rijmen vince.nosp@m.nt.r.nosp@m.ijmen.nosp@m.@esa.nosp@m.t.kul.nosp@m.euve.nosp@m.n.ac..nosp@m.be
Antoon Bosselaers antoo.nosp@m.n.bo.nosp@m.ssela.nosp@m.ers@.nosp@m.esat..nosp@m.kule.nosp@m.uven..nosp@m.ac.b.nosp@m.e
Paulo Barreto paulo.nosp@m..bar.nosp@m.reto@.nosp@m.terr.nosp@m.a.com.nosp@m..br

This code is hereby placed in the public domain.

THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Definition at line 29 of file crypt_aes_impl.h.

Referenced by rijndaelECB_MCT().

◆ MAXNR

#define MAXNR   14

Definition at line 31 of file crypt_aes_impl.h.

Typedef Documentation

◆ u16

typedef unsigned short u16

Definition at line 34 of file crypt_aes_impl.h.

◆ u8

typedef unsigned char u8

Definition at line 33 of file crypt_aes_impl.h.

Function Documentation

◆ rijndaelDecrypt()

void rijndaelDecrypt ( const u32 rk[],
int Nr,
const u8 ct[16],
u8 pt[16] )

Definition at line 1103 of file crypt_aes_impl.c.

1105{
1106 u32 s0, s1, s2, s3, t0, t1, t2, t3;
1107#ifndef FULL_UNROLL
1108 int r;
1109#endif /* ?FULL_UNROLL */
1110
1111 /*
1112 * map byte array block to cipher state
1113 * and add initial round key:
1114 */
1115 s0 = GETU32(ct) ^ rk[0];
1116 s1 = GETU32(ct + 4) ^ rk[1];
1117 s2 = GETU32(ct + 8) ^ rk[2];
1118 s3 = GETU32(ct + 12) ^ rk[3];
1119#ifdef FULL_UNROLL
1120 /* round 1: */
1121 t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) & 0xff] ^
1122 Td3[s1 & 0xff] ^ rk[4];
1123 t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) & 0xff] ^
1124 Td3[s2 & 0xff] ^ rk[5];
1125 t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) & 0xff] ^
1126 Td3[s3 & 0xff] ^ rk[6];
1127 t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) & 0xff] ^
1128 Td3[s0 & 0xff] ^ rk[7];
1129 /* round 2: */
1130 s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >> 8) & 0xff] ^
1131 Td3[t1 & 0xff] ^ rk[8];
1132 s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >> 8) & 0xff] ^
1133 Td3[t2 & 0xff] ^ rk[9];
1134 s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >> 8) & 0xff] ^
1135 Td3[t3 & 0xff] ^ rk[10];
1136 s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >> 8) & 0xff] ^
1137 Td3[t0 & 0xff] ^ rk[11];
1138 /* round 3: */
1139 t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) & 0xff] ^
1140 Td3[s1 & 0xff] ^ rk[12];
1141 t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) & 0xff] ^
1142 Td3[s2 & 0xff] ^ rk[13];
1143 t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) & 0xff] ^
1144 Td3[s3 & 0xff] ^ rk[14];
1145 t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) & 0xff] ^
1146 Td3[s0 & 0xff] ^ rk[15];
1147 /* round 4: */
1148 s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >> 8) & 0xff] ^
1149 Td3[t1 & 0xff] ^ rk[16];
1150 s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >> 8) & 0xff] ^
1151 Td3[t2 & 0xff] ^ rk[17];
1152 s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >> 8) & 0xff] ^
1153 Td3[t3 & 0xff] ^ rk[18];
1154 s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >> 8) & 0xff] ^
1155 Td3[t0 & 0xff] ^ rk[19];
1156 /* round 5: */
1157 t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) & 0xff] ^
1158 Td3[s1 & 0xff] ^ rk[20];
1159 t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) & 0xff] ^
1160 Td3[s2 & 0xff] ^ rk[21];
1161 t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) & 0xff] ^
1162 Td3[s3 & 0xff] ^ rk[22];
1163 t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) & 0xff] ^
1164 Td3[s0 & 0xff] ^ rk[23];
1165 /* round 6: */
1166 s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >> 8) & 0xff] ^
1167 Td3[t1 & 0xff] ^ rk[24];
1168 s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >> 8) & 0xff] ^
1169 Td3[t2 & 0xff] ^ rk[25];
1170 s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >> 8) & 0xff] ^
1171 Td3[t3 & 0xff] ^ rk[26];
1172 s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >> 8) & 0xff] ^
1173 Td3[t0 & 0xff] ^ rk[27];
1174 /* round 7: */
1175 t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) & 0xff] ^
1176 Td3[s1 & 0xff] ^ rk[28];
1177 t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) & 0xff] ^
1178 Td3[s2 & 0xff] ^ rk[29];
1179 t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) & 0xff] ^
1180 Td3[s3 & 0xff] ^ rk[30];
1181 t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) & 0xff] ^
1182 Td3[s0 & 0xff] ^ rk[31];
1183 /* round 8: */
1184 s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >> 8) & 0xff] ^
1185 Td3[t1 & 0xff] ^ rk[32];
1186 s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >> 8) & 0xff] ^
1187 Td3[t2 & 0xff] ^ rk[33];
1188 s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >> 8) & 0xff] ^
1189 Td3[t3 & 0xff] ^ rk[34];
1190 s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >> 8) & 0xff] ^
1191 Td3[t0 & 0xff] ^ rk[35];
1192 /* round 9: */
1193 t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) & 0xff] ^
1194 Td3[s1 & 0xff] ^ rk[36];
1195 t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) & 0xff] ^
1196 Td3[s2 & 0xff] ^ rk[37];
1197 t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) & 0xff] ^
1198 Td3[s3 & 0xff] ^ rk[38];
1199 t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) & 0xff] ^
1200 Td3[s0 & 0xff] ^ rk[39];
1201 if (Nr > 10) {
1202 /* round 10: */
1203 s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >> 8) &
1204 0xff] ^ Td3[t1
1205 &
1206 0xff]
1207 ^ rk[40];
1208 s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >> 8) &
1209 0xff] ^ Td3[t2
1210 &
1211 0xff]
1212 ^ rk[41];
1213 s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >> 8) &
1214 0xff] ^ Td3[t3
1215 &
1216 0xff]
1217 ^ rk[42];
1218 s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >> 8) &
1219 0xff] ^ Td3[t0
1220 &
1221 0xff]
1222 ^ rk[43];
1223 /* round 11: */
1224 t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) &
1225 0xff] ^ Td3[s1
1226 &
1227 0xff]
1228 ^ rk[44];
1229 t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) &
1230 0xff] ^ Td3[s2
1231 &
1232 0xff]
1233 ^ rk[45];
1234 t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) &
1235 0xff] ^ Td3[s3
1236 &
1237 0xff]
1238 ^ rk[46];
1239 t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) &
1240 0xff] ^ Td3[s0
1241 &
1242 0xff]
1243 ^ rk[47];
1244 if (Nr > 12) {
1245 /* round 12: */
1246 s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^
1247 Td2[(t2 >> 8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[48];
1248 s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^
1249 Td2[(t3 >> 8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[49];
1250 s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^
1251 Td2[(t0 >> 8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[50];
1252 s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^
1253 Td2[(t1 >> 8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[51];
1254 /* round 13: */
1255 t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^
1256 Td2[(s2 >> 8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[52];
1257 t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^
1258 Td2[(s3 >> 8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[53];
1259 t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^
1260 Td2[(s0 >> 8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[54];
1261 t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^
1262 Td2[(s1 >> 8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[55];
1263 }
1264 }
1265 rk += Nr << 2;
1266#else /* !FULL_UNROLL */
1267 /*
1268 * Nr - 1 full rounds:
1269 */
1270 r = Nr >> 1;
1271 for (;;) {
1272 t0 = Td0[(s0 >> 24)] ^
1273 Td1[(s3 >> 16) & 0xff] ^
1274 Td2[(s2 >> 8) & 0xff] ^ Td3[(s1) & 0xff] ^ rk[4];
1275 t1 = Td0[(s1 >> 24)] ^
1276 Td1[(s0 >> 16) & 0xff] ^
1277 Td2[(s3 >> 8) & 0xff] ^ Td3[(s2) & 0xff] ^ rk[5];
1278 t2 = Td0[(s2 >> 24)] ^
1279 Td1[(s1 >> 16) & 0xff] ^
1280 Td2[(s0 >> 8) & 0xff] ^ Td3[(s3) & 0xff] ^ rk[6];
1281 t3 = Td0[(s3 >> 24)] ^
1282 Td1[(s2 >> 16) & 0xff] ^
1283 Td2[(s1 >> 8) & 0xff] ^ Td3[(s0) & 0xff] ^ rk[7];
1284
1285 rk += 8;
1286 if (--r == 0) {
1287 break;
1288 }
1289
1290 s0 = Td0[(t0 >> 24)] ^
1291 Td1[(t3 >> 16) & 0xff] ^
1292 Td2[(t2 >> 8) & 0xff] ^ Td3[(t1) & 0xff] ^ rk[0];
1293 s1 = Td0[(t1 >> 24)] ^
1294 Td1[(t0 >> 16) & 0xff] ^
1295 Td2[(t3 >> 8) & 0xff] ^ Td3[(t2) & 0xff] ^ rk[1];
1296 s2 = Td0[(t2 >> 24)] ^
1297 Td1[(t1 >> 16) & 0xff] ^
1298 Td2[(t0 >> 8) & 0xff] ^ Td3[(t3) & 0xff] ^ rk[2];
1299 s3 = Td0[(t3 >> 24)] ^
1300 Td1[(t2 >> 16) & 0xff] ^
1301 Td2[(t1 >> 8) & 0xff] ^ Td3[(t0) & 0xff] ^ rk[3];
1302 }
1303#endif /* ?FULL_UNROLL */
1304 /*
1305 * apply last round and
1306 * map cipher state to byte array block:
1307 */
1308 s0 = (Td4[(t0 >> 24)] & 0xff000000) ^
1309 (Td4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
1310 (Td4[(t2 >> 8) & 0xff] & 0x0000ff00) ^
1311 (Td4[(t1) & 0xff] & 0x000000ff) ^ rk[0];
1312 PUTU32(pt, s0);
1313 s1 = (Td4[(t1 >> 24)] & 0xff000000) ^
1314 (Td4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
1315 (Td4[(t3 >> 8) & 0xff] & 0x0000ff00) ^
1316 (Td4[(t2) & 0xff] & 0x000000ff) ^ rk[1];
1317 PUTU32(pt + 4, s1);
1318 s2 = (Td4[(t2 >> 24)] & 0xff000000) ^
1319 (Td4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
1320 (Td4[(t0 >> 8) & 0xff] & 0x0000ff00) ^
1321 (Td4[(t3) & 0xff] & 0x000000ff) ^ rk[2];
1322 PUTU32(pt + 8, s2);
1323 s3 = (Td4[(t3 >> 24)] & 0xff000000) ^
1324 (Td4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
1325 (Td4[(t1 >> 8) & 0xff] & 0x0000ff00) ^
1326 (Td4[(t0) & 0xff] & 0x000000ff) ^ rk[3];
1327 PUTU32(pt + 12, s3);
1328}
PUTU32
#define PUTU32(ct, st)
Definition crypt_aes_impl.c:733
Td2
static const u32 Td2[256]
Definition crypt_aes_impl.c:518
Td3
static const u32 Td3[256]
Definition crypt_aes_impl.c:586
Td0
static const u32 Td0[256]
Definition crypt_aes_impl.c:384
Td4
static const u32 Td4[256]
Definition crypt_aes_impl.c:653
GETU32
#define GETU32(pt)
Definition crypt_aes_impl.c:732
Td1
static const u32 Td1[256]
Definition crypt_aes_impl.c:451
u32
unsigned int u32
Definition cuda_dxt.cu:12

References GETU32, PUTU32, Td0, Td1, Td2, Td3, and Td4.

Referenced by blockDecrypt(), and padDecrypt().

◆ rijndaelDecryptRound()

void rijndaelDecryptRound ( const u32 rk[],
int Nr,
u8 block[16],
int rounds )

Definition at line 1405 of file crypt_aes_impl.c.

1407{
1408 int r;
1409 u32 s0, s1, s2, s3, t0, t1, t2, t3;
1410
1411 /*
1412 * map byte array block to cipher state
1413 * and add initial round key:
1414 */
1415 s0 = GETU32(block) ^ rk[0];
1416 s1 = GETU32(block + 4) ^ rk[1];
1417 s2 = GETU32(block + 8) ^ rk[2];
1418 s3 = GETU32(block + 12) ^ rk[3];
1419 rk += 4;
1420
1421 /*
1422 * Nr - 1 full rounds:
1423 */
1424 for (r = (rounds < Nr ? rounds : Nr) - 1; r > 0; r--) {
1425 t0 = Td0[(s0 >> 24)] ^
1426 Td1[(s3 >> 16) & 0xff] ^
1427 Td2[(s2 >> 8) & 0xff] ^ Td3[(s1) & 0xff] ^ rk[0];
1428 t1 = Td0[(s1 >> 24)] ^
1429 Td1[(s0 >> 16) & 0xff] ^
1430 Td2[(s3 >> 8) & 0xff] ^ Td3[(s2) & 0xff] ^ rk[1];
1431 t2 = Td0[(s2 >> 24)] ^
1432 Td1[(s1 >> 16) & 0xff] ^
1433 Td2[(s0 >> 8) & 0xff] ^ Td3[(s3) & 0xff] ^ rk[2];
1434 t3 = Td0[(s3 >> 24)] ^
1435 Td1[(s2 >> 16) & 0xff] ^
1436 Td2[(s1 >> 8) & 0xff] ^ Td3[(s0) & 0xff] ^ rk[3];
1437
1438 s0 = t0;
1439 s1 = t1;
1440 s2 = t2;
1441 s3 = t3;
1442 rk += 4;
1443
1444 }
1445
1446 /*
1447 * complete the last round and
1448 * map cipher state to byte array block:
1449 */
1450 t0 = (Td4[(s0 >> 24)] & 0xff000000) ^
1451 (Td4[(s3 >> 16) & 0xff] & 0x00ff0000) ^
1452 (Td4[(s2 >> 8) & 0xff] & 0x0000ff00) ^
1453 (Td4[(s1) & 0xff] & 0x000000ff);
1454 t1 = (Td4[(s1 >> 24)] & 0xff000000) ^
1455 (Td4[(s0 >> 16) & 0xff] & 0x00ff0000) ^
1456 (Td4[(s3 >> 8) & 0xff] & 0x0000ff00) ^
1457 (Td4[(s2) & 0xff] & 0x000000ff);
1458 t2 = (Td4[(s2 >> 24)] & 0xff000000) ^
1459 (Td4[(s1 >> 16) & 0xff] & 0x00ff0000) ^
1460 (Td4[(s0 >> 8) & 0xff] & 0x0000ff00) ^
1461 (Td4[(s3) & 0xff] & 0x000000ff);
1462 t3 = (Td4[(s3 >> 24)] & 0xff000000) ^
1463 (Td4[(s2 >> 16) & 0xff] & 0x00ff0000) ^
1464 (Td4[(s1 >> 8) & 0xff] & 0x0000ff00) ^
1465 (Td4[(s0) & 0xff] & 0x000000ff);
1466
1467 if (rounds == Nr) {
1468 t0 ^= rk[0];
1469 t1 ^= rk[1];
1470 t2 ^= rk[2];
1471 t3 ^= rk[3];
1472 }
1473
1474 PUTU32(block, t0);
1475 PUTU32(block + 4, t1);
1476 PUTU32(block + 8, t2);
1477 PUTU32(block + 12, t3);
1478}

References GETU32, PUTU32, Td0, Td1, Td2, Td3, and Td4.

Referenced by cipherUpdateRounds().

◆ rijndaelEncrypt()

void rijndaelEncrypt ( const u32 rk[],
int Nr,
const u8 pt[16],
u8 ct[16] )

Definition at line 876 of file crypt_aes_impl.c.

878{
879 u32 s0, s1, s2, s3, t0, t1, t2, t3;
880#ifndef FULL_UNROLL
881 int r;
882#endif /* ?FULL_UNROLL */
883
884 /*
885 * map byte array block to cipher state
886 * and add initial round key:
887 */
888 s0 = GETU32(pt) ^ rk[0];
889 s1 = GETU32(pt + 4) ^ rk[1];
890 s2 = GETU32(pt + 8) ^ rk[2];
891 s3 = GETU32(pt + 12) ^ rk[3];
892#ifdef FULL_UNROLL
893 /* round 1: */
894 t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^
895 Te3[s3 & 0xff] ^ rk[4];
896 t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^
897 Te3[s0 & 0xff] ^ rk[5];
898 t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^
899 Te3[s1 & 0xff] ^ rk[6];
900 t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^
901 Te3[s2 & 0xff] ^ rk[7];
902 /* round 2: */
903 s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^
904 Te3[t3 & 0xff] ^ rk[8];
905 s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^
906 Te3[t0 & 0xff] ^ rk[9];
907 s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^
908 Te3[t1 & 0xff] ^ rk[10];
909 s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^
910 Te3[t2 & 0xff] ^ rk[11];
911 /* round 3: */
912 t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^
913 Te3[s3 & 0xff] ^ rk[12];
914 t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^
915 Te3[s0 & 0xff] ^ rk[13];
916 t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^
917 Te3[s1 & 0xff] ^ rk[14];
918 t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^
919 Te3[s2 & 0xff] ^ rk[15];
920 /* round 4: */
921 s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^
922 Te3[t3 & 0xff] ^ rk[16];
923 s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^
924 Te3[t0 & 0xff] ^ rk[17];
925 s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^
926 Te3[t1 & 0xff] ^ rk[18];
927 s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^
928 Te3[t2 & 0xff] ^ rk[19];
929 /* round 5: */
930 t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^
931 Te3[s3 & 0xff] ^ rk[20];
932 t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^
933 Te3[s0 & 0xff] ^ rk[21];
934 t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^
935 Te3[s1 & 0xff] ^ rk[22];
936 t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^
937 Te3[s2 & 0xff] ^ rk[23];
938 /* round 6: */
939 s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^
940 Te3[t3 & 0xff] ^ rk[24];
941 s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^
942 Te3[t0 & 0xff] ^ rk[25];
943 s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^
944 Te3[t1 & 0xff] ^ rk[26];
945 s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^
946 Te3[t2 & 0xff] ^ rk[27];
947 /* round 7: */
948 t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^
949 Te3[s3 & 0xff] ^ rk[28];
950 t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^
951 Te3[s0 & 0xff] ^ rk[29];
952 t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^
953 Te3[s1 & 0xff] ^ rk[30];
954 t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^
955 Te3[s2 & 0xff] ^ rk[31];
956 /* round 8: */
957 s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^
958 Te3[t3 & 0xff] ^ rk[32];
959 s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^
960 Te3[t0 & 0xff] ^ rk[33];
961 s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^
962 Te3[t1 & 0xff] ^ rk[34];
963 s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^
964 Te3[t2 & 0xff] ^ rk[35];
965 /* round 9: */
966 t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^
967 Te3[s3 & 0xff] ^ rk[36];
968 t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^
969 Te3[s0 & 0xff] ^ rk[37];
970 t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^
971 Te3[s1 & 0xff] ^ rk[38];
972 t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^
973 Te3[s2 & 0xff] ^ rk[39];
974 if (Nr > 10) {
975 /* round 10: */
976 s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) &
977 0xff] ^ Te3[t3
978 &
979 0xff]
980 ^ rk[40];
981 s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) &
982 0xff] ^ Te3[t0
983 &
984 0xff]
985 ^ rk[41];
986 s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) &
987 0xff] ^ Te3[t1
988 &
989 0xff]
990 ^ rk[42];
991 s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) &
992 0xff] ^ Te3[t2
993 &
994 0xff]
995 ^ rk[43];
996 /* round 11: */
997 t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) &
998 0xff] ^ Te3[s3
999 &
1000 0xff]
1001 ^ rk[44];
1002 t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) &
1003 0xff] ^ Te3[s0
1004 &
1005 0xff]
1006 ^ rk[45];
1007 t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) &
1008 0xff] ^ Te3[s1
1009 &
1010 0xff]
1011 ^ rk[46];
1012 t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) &
1013 0xff] ^ Te3[s2
1014 &
1015 0xff]
1016 ^ rk[47];
1017 if (Nr > 12) {
1018 /* round 12: */
1019 s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^
1020 Te2[(t2 >> 8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[48];
1021 s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^
1022 Te2[(t3 >> 8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[49];
1023 s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^
1024 Te2[(t0 >> 8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[50];
1025 s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^
1026 Te2[(t1 >> 8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[51];
1027 /* round 13: */
1028 t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^
1029 Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[52];
1030 t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^
1031 Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[53];
1032 t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^
1033 Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[54];
1034 t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^
1035 Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[55];
1036 }
1037 }
1038 rk += Nr << 2;
1039#else /* !FULL_UNROLL */
1040 /*
1041 * Nr - 1 full rounds:
1042 */
1043 r = Nr >> 1;
1044 for (;;) {
1045 t0 = Te0[(s0 >> 24)] ^
1046 Te1[(s1 >> 16) & 0xff] ^
1047 Te2[(s2 >> 8) & 0xff] ^ Te3[(s3) & 0xff] ^ rk[4];
1048 t1 = Te0[(s1 >> 24)] ^
1049 Te1[(s2 >> 16) & 0xff] ^
1050 Te2[(s3 >> 8) & 0xff] ^ Te3[(s0) & 0xff] ^ rk[5];
1051 t2 = Te0[(s2 >> 24)] ^
1052 Te1[(s3 >> 16) & 0xff] ^
1053 Te2[(s0 >> 8) & 0xff] ^ Te3[(s1) & 0xff] ^ rk[6];
1054 t3 = Te0[(s3 >> 24)] ^
1055 Te1[(s0 >> 16) & 0xff] ^
1056 Te2[(s1 >> 8) & 0xff] ^ Te3[(s2) & 0xff] ^ rk[7];
1057
1058 rk += 8;
1059 if (--r == 0) {
1060 break;
1061 }
1062
1063 s0 = Te0[(t0 >> 24)] ^
1064 Te1[(t1 >> 16) & 0xff] ^
1065 Te2[(t2 >> 8) & 0xff] ^ Te3[(t3) & 0xff] ^ rk[0];
1066 s1 = Te0[(t1 >> 24)] ^
1067 Te1[(t2 >> 16) & 0xff] ^
1068 Te2[(t3 >> 8) & 0xff] ^ Te3[(t0) & 0xff] ^ rk[1];
1069 s2 = Te0[(t2 >> 24)] ^
1070 Te1[(t3 >> 16) & 0xff] ^
1071 Te2[(t0 >> 8) & 0xff] ^ Te3[(t1) & 0xff] ^ rk[2];
1072 s3 = Te0[(t3 >> 24)] ^
1073 Te1[(t0 >> 16) & 0xff] ^
1074 Te2[(t1 >> 8) & 0xff] ^ Te3[(t2) & 0xff] ^ rk[3];
1075 }
1076#endif /* ?FULL_UNROLL */
1077 /*
1078 * apply last round and
1079 * map cipher state to byte array block:
1080 */
1081 s0 = (Te4[(t0 >> 24)] & 0xff000000) ^
1082 (Te4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
1083 (Te4[(t2 >> 8) & 0xff] & 0x0000ff00) ^
1084 (Te4[(t3) & 0xff] & 0x000000ff) ^ rk[0];
1085 PUTU32(ct, s0);
1086 s1 = (Te4[(t1 >> 24)] & 0xff000000) ^
1087 (Te4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
1088 (Te4[(t3 >> 8) & 0xff] & 0x0000ff00) ^
1089 (Te4[(t0) & 0xff] & 0x000000ff) ^ rk[1];
1090 PUTU32(ct + 4, s1);
1091 s2 = (Te4[(t2 >> 24)] & 0xff000000) ^
1092 (Te4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
1093 (Te4[(t0 >> 8) & 0xff] & 0x0000ff00) ^
1094 (Te4[(t1) & 0xff] & 0x000000ff) ^ rk[2];
1095 PUTU32(ct + 8, s2);
1096 s3 = (Te4[(t3 >> 24)] & 0xff000000) ^
1097 (Te4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
1098 (Te4[(t1 >> 8) & 0xff] & 0x0000ff00) ^
1099 (Te4[(t2) & 0xff] & 0x000000ff) ^ rk[3];
1100 PUTU32(ct + 12, s3);
1101}
Te0
static const u32 Te0[256]
Definition crypt_aes_impl.c:48
Te2
static const u32 Te2[256]
Definition crypt_aes_impl.c:182
Te1
static const u32 Te1[256]
Definition crypt_aes_impl.c:115
Te4
static const u32 Te4[256]
Definition crypt_aes_impl.c:317
Te3
static const u32 Te3[256]
Definition crypt_aes_impl.c:249

References GETU32, PUTU32, Te0, Te1, Te2, Te3, and Te4.

Referenced by blockDecrypt(), blockEncrypt(), and padEncrypt().

◆ rijndaelEncryptRound()

void rijndaelEncryptRound ( const u32 rk[],
int Nr,
u8 block[16],
int rounds )

Definition at line 1330 of file crypt_aes_impl.c.

1332{
1333 int r;
1334 u32 s0, s1, s2, s3, t0, t1, t2, t3;
1335
1336 /*
1337 * map byte array block to cipher state
1338 * and add initial round key:
1339 */
1340 s0 = GETU32(block) ^ rk[0];
1341 s1 = GETU32(block + 4) ^ rk[1];
1342 s2 = GETU32(block + 8) ^ rk[2];
1343 s3 = GETU32(block + 12) ^ rk[3];
1344 rk += 4;
1345
1346 /*
1347 * Nr - 1 full rounds:
1348 */
1349 for (r = (rounds < Nr ? rounds : Nr - 1); r > 0; r--) {
1350 t0 = Te0[(s0 >> 24)] ^
1351 Te1[(s1 >> 16) & 0xff] ^
1352 Te2[(s2 >> 8) & 0xff] ^ Te3[(s3) & 0xff] ^ rk[0];
1353 t1 = Te0[(s1 >> 24)] ^
1354 Te1[(s2 >> 16) & 0xff] ^
1355 Te2[(s3 >> 8) & 0xff] ^ Te3[(s0) & 0xff] ^ rk[1];
1356 t2 = Te0[(s2 >> 24)] ^
1357 Te1[(s3 >> 16) & 0xff] ^
1358 Te2[(s0 >> 8) & 0xff] ^ Te3[(s1) & 0xff] ^ rk[2];
1359 t3 = Te0[(s3 >> 24)] ^
1360 Te1[(s0 >> 16) & 0xff] ^
1361 Te2[(s1 >> 8) & 0xff] ^ Te3[(s2) & 0xff] ^ rk[3];
1362
1363 s0 = t0;
1364 s1 = t1;
1365 s2 = t2;
1366 s3 = t3;
1367 rk += 4;
1368
1369 }
1370
1371 /*
1372 * apply last round and
1373 * map cipher state to byte array block:
1374 */
1375 if (rounds == Nr) {
1376 t0 = (Te4[(s0 >> 24)] & 0xff000000) ^
1377 (Te4[(s1 >> 16) & 0xff] & 0x00ff0000) ^
1378 (Te4[(s2 >> 8) & 0xff] & 0x0000ff00) ^
1379 (Te4[(s3) & 0xff] & 0x000000ff) ^ rk[0];
1380 t1 = (Te4[(s1 >> 24)] & 0xff000000) ^
1381 (Te4[(s2 >> 16) & 0xff] & 0x00ff0000) ^
1382 (Te4[(s3 >> 8) & 0xff] & 0x0000ff00) ^
1383 (Te4[(s0) & 0xff] & 0x000000ff) ^ rk[1];
1384 t2 = (Te4[(s2 >> 24)] & 0xff000000) ^
1385 (Te4[(s3 >> 16) & 0xff] & 0x00ff0000) ^
1386 (Te4[(s0 >> 8) & 0xff] & 0x0000ff00) ^
1387 (Te4[(s1) & 0xff] & 0x000000ff) ^ rk[2];
1388 t3 = (Te4[(s3 >> 24)] & 0xff000000) ^
1389 (Te4[(s0 >> 16) & 0xff] & 0x00ff0000) ^
1390 (Te4[(s1 >> 8) & 0xff] & 0x0000ff00) ^
1391 (Te4[(s2) & 0xff] & 0x000000ff) ^ rk[3];
1392
1393 s0 = t0;
1394 s1 = t1;
1395 s2 = t2;
1396 s3 = t3;
1397 }
1398
1399 PUTU32(block, s0);
1400 PUTU32(block + 4, s1);
1401 PUTU32(block + 8, s2);
1402 PUTU32(block + 12, s3);
1403}

References GETU32, PUTU32, Te0, Te1, Te2, Te3, and Te4.

Referenced by cipherUpdateRounds().

◆ rijndaelKeySetupDec()

int rijndaelKeySetupDec ( u32 rk[],
const u8 cipherKey[],
int keyBits )

Expand the cipher key into the decryption key schedule.

Returns
the number of rounds for the given cipher key size.

Definition at line 826 of file crypt_aes_impl.c.

828{
829 int Nr, i, j;
830 u32 temp;
831
832 /* expand the cipher key: */
833 Nr = rijndaelKeySetupEnc(rk, cipherKey, keyBits);
834 /* invert the order of the round keys: */
835 for (i = 0, j = 4 * Nr; i < j; i += 4, j -= 4) {
836 temp = rk[i];
837 rk[i] = rk[j];
838 rk[j] = temp;
839 temp = rk[i + 1];
840 rk[i + 1] = rk[j + 1];
841 rk[j + 1] = temp;
842 temp = rk[i + 2];
843 rk[i + 2] = rk[j + 2];
844 rk[j + 2] = temp;
845 temp = rk[i + 3];
846 rk[i + 3] = rk[j + 3];
847 rk[j + 3] = temp;
848 }
849 /* apply the inverse MixColumn transform to all round keys but the first and the last: */
850 for (i = 1; i < Nr; i++) {
851 rk += 4;
852 rk[0] =
853 Td0[Te4[(rk[0] >> 24)] & 0xff] ^
854 Td1[Te4[(rk[0] >> 16) & 0xff] & 0xff] ^
855 Td2[Te4[(rk[0] >> 8) & 0xff] & 0xff] ^
856 Td3[Te4[(rk[0]) & 0xff] & 0xff];
857 rk[1] =
858 Td0[Te4[(rk[1] >> 24)] & 0xff] ^
859 Td1[Te4[(rk[1] >> 16) & 0xff] & 0xff] ^
860 Td2[Te4[(rk[1] >> 8) & 0xff] & 0xff] ^
861 Td3[Te4[(rk[1]) & 0xff] & 0xff];
862 rk[2] =
863 Td0[Te4[(rk[2] >> 24)] & 0xff] ^
864 Td1[Te4[(rk[2] >> 16) & 0xff] & 0xff] ^
865 Td2[Te4[(rk[2] >> 8) & 0xff] & 0xff] ^
866 Td3[Te4[(rk[2]) & 0xff] & 0xff];
867 rk[3] =
868 Td0[Te4[(rk[3] >> 24)] & 0xff] ^
869 Td1[Te4[(rk[3] >> 16) & 0xff] & 0xff] ^
870 Td2[Te4[(rk[3] >> 8) & 0xff] & 0xff] ^
871 Td3[Te4[(rk[3]) & 0xff] & 0xff];
872 }
873 return Nr;
874}
rijndaelKeySetupEnc
int rijndaelKeySetupEnc(u32 rk[], const u8 cipherKey[], int keyBits)
Definition crypt_aes_impl.c:741

References rijndaelKeySetupEnc(), Td0, Td1, Td2, Td3, and Te4.

Referenced by makeKey().

Here is the call graph for this function:

◆ rijndaelKeySetupEnc()

int rijndaelKeySetupEnc ( u32 rk[],
const u8 cipherKey[],
int keyBits )

Expand the cipher key into the encryption key schedule.

Returns
the number of rounds for the given cipher key size.

Definition at line 741 of file crypt_aes_impl.c.

743{
744 int i = 0;
745 u32 temp;
746
747 rk[0] = GETU32(cipherKey);
748 rk[1] = GETU32(cipherKey + 4);
749 rk[2] = GETU32(cipherKey + 8);
750 rk[3] = GETU32(cipherKey + 12);
751 if (keyBits == 128) {
752 for (;;) {
753 temp = rk[3];
754 rk[4] = rk[0] ^
755 (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
756 (Te4[(temp >> 8) & 0xff] & 0x00ff0000) ^
757 (Te4[(temp) & 0xff] & 0x0000ff00) ^
758 (Te4[(temp >> 24)] & 0x000000ff) ^ rcon[i];
759 rk[5] = rk[1] ^ rk[4];
760 rk[6] = rk[2] ^ rk[5];
761 rk[7] = rk[3] ^ rk[6];
762 if (++i == 10) {
763 return 10;
764 }
765 rk += 4;
766 }
767 }
768 rk[4] = GETU32(cipherKey + 16);
769 rk[5] = GETU32(cipherKey + 20);
770 if (keyBits == 192) {
771 for (;;) {
772 temp = rk[5];
773 rk[6] = rk[0] ^
774 (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
775 (Te4[(temp >> 8) & 0xff] & 0x00ff0000) ^
776 (Te4[(temp) & 0xff] & 0x0000ff00) ^
777 (Te4[(temp >> 24)] & 0x000000ff) ^ rcon[i];
778 rk[7] = rk[1] ^ rk[6];
779 rk[8] = rk[2] ^ rk[7];
780 rk[9] = rk[3] ^ rk[8];
781 if (++i == 8) {
782 return 12;
783 }
784 rk[10] = rk[4] ^ rk[9];
785 rk[11] = rk[5] ^ rk[10];
786 rk += 6;
787 }
788 }
789 rk[6] = GETU32(cipherKey + 24);
790 rk[7] = GETU32(cipherKey + 28);
791 if (keyBits == 256) {
792 for (;;) {
793 temp = rk[7];
794 rk[8] = rk[0] ^
795 (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
796 (Te4[(temp >> 8) & 0xff] & 0x00ff0000) ^
797 (Te4[(temp) & 0xff] & 0x0000ff00) ^
798 (Te4[(temp >> 24)] & 0x000000ff) ^ rcon[i];
799 rk[9] = rk[1] ^ rk[8];
800 rk[10] = rk[2] ^ rk[9];
801 rk[11] = rk[3] ^ rk[10];
802 if (++i == 7) {
803 return 14;
804 }
805 temp = rk[11];
806 rk[12] = rk[4] ^
807 (Te4[(temp >> 24)] & 0xff000000) ^
808 (Te4[(temp >> 16) & 0xff] & 0x00ff0000) ^
809 (Te4[(temp >> 8) & 0xff] & 0x0000ff00) ^
810 (Te4[(temp) & 0xff] & 0x000000ff);
811 rk[13] = rk[5] ^ rk[12];
812 rk[14] = rk[6] ^ rk[13];
813 rk[15] = rk[7] ^ rk[14];
814
815 rk += 8;
816 }
817 }
818 return 0;
819}
rcon
static const u32 rcon[]
Definition crypt_aes_impl.c:720

References GETU32, rcon, and Te4.

Referenced by makeKey(), and rijndaelKeySetupDec().

Generated on Wed Sep 25 2024 14:27:30 for UltraGrid by doxygen 1.12.0