summaryrefslogtreecommitdiffstats
path: root/external/poppler/0001-Partially-revert-814fbda28cc8a37fed3134c2db8da28f86f.patch.1
diff options
context:
space:
mode:
Diffstat (limited to 'external/poppler/0001-Partially-revert-814fbda28cc8a37fed3134c2db8da28f86f.patch.1')
-rw-r--r--external/poppler/0001-Partially-revert-814fbda28cc8a37fed3134c2db8da28f86f.patch.1999
1 files changed, 999 insertions, 0 deletions
diff --git a/external/poppler/0001-Partially-revert-814fbda28cc8a37fed3134c2db8da28f86f.patch.1 b/external/poppler/0001-Partially-revert-814fbda28cc8a37fed3134c2db8da28f86f.patch.1
new file mode 100644
index 000000000000..05b2346d131f
--- /dev/null
+++ b/external/poppler/0001-Partially-revert-814fbda28cc8a37fed3134c2db8da28f86f.patch.1
@@ -0,0 +1,999 @@
+[PATCH] Partially revert 814fbda28cc8a37fed3134c2db8da28f86fb5ee0
+
+"Run clang-format" in poppler/Decrypt.cc
+---
+ poppler/Decrypt.cc | 848 +++++++++++++++++++++++----------------------
+ 1 file changed, 437 insertions(+), 411 deletions(-)
+
+diff --git a/poppler/Decrypt.cc b/poppler/Decrypt.cc
+index 62b11702..4b388ab9 100644
+--- a/poppler/Decrypt.cc
++++ b/poppler/Decrypt.cc
+@@ -599,139 +599,167 @@ static unsigned char rc4DecryptByte(unsigned char *state, unsigned char *x, unsi
+ // Returns false if EOF was reached, true otherwise
+ static bool aesReadBlock(Stream *str, unsigned char *in, bool addPadding)
+ {
+- int c, i;
++ int c, i;
+
+- for (i = 0; i < 16; ++i) {
+- if ((c = str->getChar()) != EOF) {
+- in[i] = (unsigned char)c;
+- } else {
+- break;
+- }
++ for (i = 0; i < 16; ++i) {
++ if ((c = str->getChar()) != EOF) {
++ in[i] = (unsigned char)c;
++ } else {
++ break;
+ }
++ }
+
+- if (i == 16) {
+- return true;
+- } else {
+- if (addPadding) {
+- c = 16 - i;
+- while (i < 16) {
+- in[i++] = (unsigned char)c;
+- }
+- }
+- return false;
++ if (i == 16) {
++ return true;
++ } else {
++ if (addPadding) {
++ c = 16 - i;
++ while (i < 16) {
++ in[i++] = (unsigned char)c;
++ }
+ }
++ return false;
++ }
+ }
+
+-static const unsigned char sbox[256] = { 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 unsigned char invSbox[256] = { 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 unsigned int rcon[11] = { 0x00000000, // unused
+- 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1b000000, 0x36000000 };
+-
+-static inline unsigned int subWord(unsigned int x)
+-{
+- return (sbox[x >> 24] << 24) | (sbox[(x >> 16) & 0xff] << 16) | (sbox[(x >> 8) & 0xff] << 8) | sbox[x & 0xff];
+-}
++static const unsigned char sbox[256] = {
++ 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 inline unsigned int rotWord(unsigned int x)
+-{
+- return ((x << 8) & 0xffffffff) | (x >> 24);
+-}
++static const unsigned char invSbox[256] = {
++ 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 inline void subBytes(unsigned char *state)
+-{
+- int i;
++static const unsigned int rcon[11] = {
++ 0x00000000, // unused
++ 0x01000000,
++ 0x02000000,
++ 0x04000000,
++ 0x08000000,
++ 0x10000000,
++ 0x20000000,
++ 0x40000000,
++ 0x80000000,
++ 0x1b000000,
++ 0x36000000
++};
+
+- for (i = 0; i < 16; ++i) {
+- state[i] = sbox[state[i]];
+- }
++static inline unsigned int subWord(unsigned int x) {
++ return (sbox[x >> 24] << 24)
++ | (sbox[(x >> 16) & 0xff] << 16)
++ | (sbox[(x >> 8) & 0xff] << 8)
++ | sbox[x & 0xff];
+ }
+
+-static inline void invSubBytes(unsigned char *state)
+-{
+- int i;
++static inline unsigned int rotWord(unsigned int x) {
++ return ((x << 8) & 0xffffffff) | (x >> 24);
++}
+
+- for (i = 0; i < 16; ++i) {
+- state[i] = invSbox[state[i]];
+- }
++static inline void subBytes(unsigned char *state) {
++ int i;
++
++ for (i = 0; i < 16; ++i) {
++ state[i] = sbox[state[i]];
++ }
+ }
+
+-static inline void shiftRows(unsigned char *state)
+-{
+- unsigned char t;
++static inline void invSubBytes(unsigned char *state) {
++ int i;
+
+- t = state[4];
+- state[4] = state[5];
+- state[5] = state[6];
+- state[6] = state[7];
+- state[7] = t;
+-
+- t = state[8];
+- state[8] = state[10];
+- state[10] = t;
+- t = state[9];
+- state[9] = state[11];
+- state[11] = t;
+-
+- t = state[15];
+- state[15] = state[14];
+- state[14] = state[13];
+- state[13] = state[12];
+- state[12] = t;
++ for (i = 0; i < 16; ++i) {
++ state[i] = invSbox[state[i]];
++ }
+ }
+
+-static inline void invShiftRows(unsigned char *state)
+-{
+- unsigned char t;
++static inline void shiftRows(unsigned char *state) {
++ unsigned char t;
++
++ t = state[4];
++ state[4] = state[5];
++ state[5] = state[6];
++ state[6] = state[7];
++ state[7] = t;
++
++ t = state[8];
++ state[8] = state[10];
++ state[10] = t;
++ t = state[9];
++ state[9] = state[11];
++ state[11] = t;
++
++ t = state[15];
++ state[15] = state[14];
++ state[14] = state[13];
++ state[13] = state[12];
++ state[12] = t;
++}
+
+- t = state[7];
+- state[7] = state[6];
+- state[6] = state[5];
+- state[5] = state[4];
+- state[4] = t;
+-
+- t = state[8];
+- state[8] = state[10];
+- state[10] = t;
+- t = state[9];
+- state[9] = state[11];
+- state[11] = t;
+-
+- t = state[12];
+- state[12] = state[13];
+- state[13] = state[14];
+- state[14] = state[15];
+- state[15] = t;
++static inline void invShiftRows(unsigned char *state) {
++ unsigned char t;
++
++ t = state[7];
++ state[7] = state[6];
++ state[6] = state[5];
++ state[5] = state[4];
++ state[4] = t;
++
++ t = state[8];
++ state[8] = state[10];
++ state[10] = t;
++ t = state[9];
++ state[9] = state[11];
++ state[11] = t;
++
++ t = state[12];
++ state[12] = state[13];
++ state[13] = state[14];
++ state[14] = state[15];
++ state[15] = t;
+ }
+
+ // {02} \cdot s
+ struct Mul02Table
+ {
+- constexpr Mul02Table() : values()
+- {
+- for (int s = 0; s < 256; s++) {
+- values[s] = (s & 0x80) ? ((s << 1) ^ 0x1b) : (s << 1);
+- }
++ constexpr Mul02Table() : values()
++ {
++ for(int s = 0; s < 256; s++) {
++ values[s] = (s & 0x80) ? ((s << 1) ^ 0x1b) : (s << 1);
+ }
++ }
+
+- constexpr unsigned char operator()(uint8_t i) const { return values[i]; }
++ constexpr unsigned char operator()(uint8_t i) const { return values[i]; }
+
+- unsigned char values[256];
++ unsigned char values[256];
+ };
+
+ static constexpr Mul02Table mul02;
+@@ -739,17 +767,17 @@ static constexpr Mul02Table mul02;
+ // {03} \cdot s
+ struct Mul03Table
+ {
+- constexpr Mul03Table() : values()
+- {
+- for (int s = 0; s < 256; s++) {
+- const unsigned char s2 = (s & 0x80) ? ((s << 1) ^ 0x1b) : (s << 1);
+- values[s] = s ^ s2;
+- }
++ constexpr Mul03Table() : values()
++ {
++ for(int s=0; s<256; s++) {
++ const unsigned char s2 = (s & 0x80) ? ((s << 1) ^ 0x1b) : (s << 1);
++ values[s] = s ^ s2;
+ }
++ }
+
+- constexpr unsigned char operator()(uint8_t i) const { return values[i]; }
++ constexpr unsigned char operator()(uint8_t i) const { return values[i]; }
+
+- unsigned char values[256];
++ unsigned char values[256];
+ };
+
+ static constexpr Mul03Table mul03;
+@@ -757,19 +785,19 @@ static constexpr Mul03Table mul03;
+ // {09} \cdot s
+ struct Mul09Table
+ {
+- constexpr Mul09Table() : values()
+- {
+- for (int s = 0; s < 256; s++) {
+- const unsigned char s2 = (s & 0x80) ? ((s << 1) ^ 0x1b) : (s << 1);
+- const unsigned char s4 = (s2 & 0x80) ? ((s2 << 1) ^ 0x1b) : (s2 << 1);
+- const unsigned char s8 = (s4 & 0x80) ? ((s4 << 1) ^ 0x1b) : (s4 << 1);
+- values[s] = s ^ s8;
+- }
++ constexpr Mul09Table() : values()
++ {
++ for(int s=0; s<256; s++) {
++ const unsigned char s2 = (s & 0x80) ? ((s << 1) ^ 0x1b) : (s << 1);
++ const unsigned char s4 = (s2 & 0x80) ? ((s2 << 1) ^ 0x1b) : (s2 << 1);
++ const unsigned char s8 = (s4 & 0x80) ? ((s4 << 1) ^ 0x1b) : (s4 << 1);
++ values[s] = s ^ s8;
+ }
++ }
+
+- constexpr unsigned char operator()(uint8_t i) const { return values[i]; }
++ constexpr unsigned char operator()(uint8_t i) const { return values[i]; }
+
+- unsigned char values[256];
++ unsigned char values[256];
+ };
+
+ static constexpr Mul09Table mul09;
+@@ -777,19 +805,19 @@ static constexpr Mul09Table mul09;
+ // {0b} \cdot s
+ struct Mul0bTable
+ {
+- constexpr Mul0bTable() : values()
+- {
+- for (int s = 0; s < 256; s++) {
+- const unsigned char s2 = (s & 0x80) ? ((s << 1) ^ 0x1b) : (s << 1);
+- const unsigned char s4 = (s2 & 0x80) ? ((s2 << 1) ^ 0x1b) : (s2 << 1);
+- const unsigned char s8 = (s4 & 0x80) ? ((s4 << 1) ^ 0x1b) : (s4 << 1);
+- values[s] = s ^ s2 ^ s8;
+- }
++ constexpr Mul0bTable() : values()
++ {
++ for(int s=0; s<256; s++) {
++ const unsigned char s2 = (s & 0x80) ? ((s << 1) ^ 0x1b) : (s << 1);
++ const unsigned char s4 = (s2 & 0x80) ? ((s2 << 1) ^ 0x1b) : (s2 << 1);
++ const unsigned char s8 = (s4 & 0x80) ? ((s4 << 1) ^ 0x1b) : (s4 << 1);
++ values[s] = s ^ s2 ^ s8;
+ }
++ }
+
+- constexpr unsigned char operator()(uint8_t i) const { return values[i]; }
++ constexpr unsigned char operator()(uint8_t i) const { return values[i]; }
+
+- unsigned char values[256];
++ unsigned char values[256];
+ };
+
+ static constexpr Mul0bTable mul0b;
+@@ -797,19 +825,19 @@ static constexpr Mul0bTable mul0b;
+ // {0d} \cdot s
+ struct Mul0dTable
+ {
+- constexpr Mul0dTable() : values()
+- {
+- for (int s = 0; s < 256; s++) {
+- const unsigned char s2 = (s & 0x80) ? ((s << 1) ^ 0x1b) : (s << 1);
+- const unsigned char s4 = (s2 & 0x80) ? ((s2 << 1) ^ 0x1b) : (s2 << 1);
+- const unsigned char s8 = (s4 & 0x80) ? ((s4 << 1) ^ 0x1b) : (s4 << 1);
+- values[s] = s ^ s4 ^ s8;
+- }
++ constexpr Mul0dTable() : values()
++ {
++ for(int s=0; s<256; s++) {
++ const unsigned char s2 = (s & 0x80) ? ((s << 1) ^ 0x1b) : (s << 1);
++ const unsigned char s4 = (s2 & 0x80) ? ((s2 << 1) ^ 0x1b) : (s2 << 1);
++ const unsigned char s8 = (s4 & 0x80) ? ((s4 << 1) ^ 0x1b) : (s4 << 1);
++ values[s] = s ^ s4 ^ s8;
+ }
++ }
+
+- constexpr unsigned char operator()(uint8_t i) const { return values[i]; }
++ constexpr unsigned char operator()(uint8_t i) const { return values[i]; }
+
+- unsigned char values[256];
++ unsigned char values[256];
+ };
+
+ static constexpr Mul0dTable mul0d;
+@@ -817,329 +845,327 @@ static constexpr Mul0dTable mul0d;
+ // {0e} \cdot s
+ struct Mul0eTable
+ {
+- constexpr Mul0eTable() : values()
+- {
+- for (int s = 0; s < 256; s++) {
+- const unsigned char s2 = (s & 0x80) ? ((s << 1) ^ 0x1b) : (s << 1);
+- const unsigned char s4 = (s2 & 0x80) ? ((s2 << 1) ^ 0x1b) : (s2 << 1);
+- const unsigned char s8 = (s4 & 0x80) ? ((s4 << 1) ^ 0x1b) : (s4 << 1);
+- values[s] = s2 ^ s4 ^ s8;
+- }
++ constexpr Mul0eTable() : values()
++ {
++ for(int s=0; s<256; s++) {
++ const unsigned char s2 = (s & 0x80) ? ((s << 1) ^ 0x1b) : (s << 1);
++ const unsigned char s4 = (s2 & 0x80) ? ((s2 << 1) ^ 0x1b) : (s2 << 1);
++ const unsigned char s8 = (s4 & 0x80) ? ((s4 << 1) ^ 0x1b) : (s4 << 1);
++ values[s] = s2 ^ s4 ^ s8;
+ }
++ }
+
+- constexpr unsigned char operator()(uint8_t i) const { return values[i]; }
++ constexpr unsigned char operator()(uint8_t i) const { return values[i]; }
+
+- unsigned char values[256];
++ unsigned char values[256];
+ };
+
+ static constexpr Mul0eTable mul0e;
+
+-static inline void mixColumns(unsigned char *state)
+-{
+- int c;
+- unsigned char s0, s1, s2, s3;
+-
+- for (c = 0; c < 4; ++c) {
+- s0 = state[c];
+- s1 = state[4 + c];
+- s2 = state[8 + c];
+- s3 = state[12 + c];
+- state[c] = mul02(s0) ^ mul03(s1) ^ s2 ^ s3;
+- state[4 + c] = s0 ^ mul02(s1) ^ mul03(s2) ^ s3;
+- state[8 + c] = s0 ^ s1 ^ mul02(s2) ^ mul03(s3);
+- state[12 + c] = mul03(s0) ^ s1 ^ s2 ^ mul02(s3);
+- }
++static inline void mixColumns(unsigned char *state) {
++ int c;
++ unsigned char s0, s1, s2, s3;
++
++ for (c = 0; c < 4; ++c) {
++ s0 = state[c];
++ s1 = state[4+c];
++ s2 = state[8+c];
++ s3 = state[12+c];
++ state[c] = mul02(s0) ^ mul03(s1) ^ s2 ^ s3;
++ state[4+c] = s0 ^ mul02(s1) ^ mul03(s2) ^ s3;
++ state[8+c] = s0 ^ s1 ^ mul02(s2) ^ mul03(s3);
++ state[12+c] = mul03(s0) ^ s1 ^ s2 ^ mul02(s3);
++ }
+ }
+
+-static inline void invMixColumns(unsigned char *state)
+-{
+- int c;
+- unsigned char s0, s1, s2, s3;
+-
+- for (c = 0; c < 4; ++c) {
+- s0 = state[c];
+- s1 = state[4 + c];
+- s2 = state[8 + c];
+- s3 = state[12 + c];
+- state[c] = mul0e(s0) ^ mul0b(s1) ^ mul0d(s2) ^ mul09(s3);
+- state[4 + c] = mul09(s0) ^ mul0e(s1) ^ mul0b(s2) ^ mul0d(s3);
+- state[8 + c] = mul0d(s0) ^ mul09(s1) ^ mul0e(s2) ^ mul0b(s3);
+- state[12 + c] = mul0b(s0) ^ mul0d(s1) ^ mul09(s2) ^ mul0e(s3);
+- }
++static inline void invMixColumns(unsigned char *state) {
++ int c;
++ unsigned char s0, s1, s2, s3;
++
++ for (c = 0; c < 4; ++c) {
++ s0 = state[c];
++ s1 = state[4+c];
++ s2 = state[8+c];
++ s3 = state[12+c];
++ state[c] = mul0e(s0) ^ mul0b(s1) ^ mul0d(s2) ^ mul09(s3);
++ state[4+c] = mul09(s0) ^ mul0e(s1) ^ mul0b(s2) ^ mul0d(s3);
++ state[8+c] = mul0d(s0) ^ mul09(s1) ^ mul0e(s2) ^ mul0b(s3);
++ state[12+c] = mul0b(s0) ^ mul0d(s1) ^ mul09(s2) ^ mul0e(s3);
++ }
+ }
+
+-static inline void invMixColumnsW(unsigned int *w)
+-{
+- int c;
+- unsigned char s0, s1, s2, s3;
+-
+- for (c = 0; c < 4; ++c) {
+- s0 = w[c] >> 24;
+- s1 = w[c] >> 16;
+- s2 = w[c] >> 8;
+- s3 = w[c];
+- w[c] = ((mul0e(s0) ^ mul0b(s1) ^ mul0d(s2) ^ mul09(s3)) << 24) | ((mul09(s0) ^ mul0e(s1) ^ mul0b(s2) ^ mul0d(s3)) << 16) | ((mul0d(s0) ^ mul09(s1) ^ mul0e(s2) ^ mul0b(s3)) << 8) | (mul0b(s0) ^ mul0d(s1) ^ mul09(s2) ^ mul0e(s3));
+- }
++static inline void invMixColumnsW(unsigned int *w) {
++ int c;
++ unsigned char s0, s1, s2, s3;
++
++ for (c = 0; c < 4; ++c) {
++ s0 = w[c] >> 24;
++ s1 = w[c] >> 16;
++ s2 = w[c] >> 8;
++ s3 = w[c];
++ w[c] = ((mul0e(s0) ^ mul0b(s1) ^ mul0d(s2) ^ mul09(s3)) << 24)
++ | ((mul09(s0) ^ mul0e(s1) ^ mul0b(s2) ^ mul0d(s3)) << 16)
++ | ((mul0d(s0) ^ mul09(s1) ^ mul0e(s2) ^ mul0b(s3)) << 8)
++ | (mul0b(s0) ^ mul0d(s1) ^ mul09(s2) ^ mul0e(s3));
++ }
+ }
+
+-static inline void addRoundKey(unsigned char *state, const unsigned int *w)
+-{
+- int c;
++static inline void addRoundKey(unsigned char *state, const unsigned int *w) {
++ int c;
+
+- for (c = 0; c < 4; ++c) {
+- state[c] ^= w[c] >> 24;
+- state[4 + c] ^= w[c] >> 16;
+- state[8 + c] ^= w[c] >> 8;
+- state[12 + c] ^= w[c];
+- }
++ for (c = 0; c < 4; ++c) {
++ state[c] ^= w[c] >> 24;
++ state[4+c] ^= w[c] >> 16;
++ state[8+c] ^= w[c] >> 8;
++ state[12+c] ^= w[c];
++ }
+ }
+
+-static void aesKeyExpansion(DecryptAESState *s, const unsigned char *objKey, int /*objKeyLen*/, bool decrypt)
+-{
+- unsigned int temp;
+- int i, round;
++static void aesKeyExpansion(DecryptAESState *s,
++ const unsigned char *objKey, int /*objKeyLen*/, bool decrypt) {
++ unsigned int temp;
++ int i, round;
+
+- //~ this assumes objKeyLen == 16
++ //~ this assumes objKeyLen == 16
+
+- for (i = 0; i < 4; ++i) {
+- s->w[i] = (objKey[4 * i] << 24) + (objKey[4 * i + 1] << 16) + (objKey[4 * i + 2] << 8) + objKey[4 * i + 3];
+- }
+- for (i = 4; i < 44; ++i) {
+- temp = s->w[i - 1];
+- if (!(i & 3)) {
+- temp = subWord(rotWord(temp)) ^ rcon[i / 4];
+- }
+- s->w[i] = s->w[i - 4] ^ temp;
++ for (i = 0; i < 4; ++i) {
++ s->w[i] = (objKey[4*i] << 24) + (objKey[4*i+1] << 16) +
++ (objKey[4*i+2] << 8) + objKey[4*i+3];
++ }
++ for (i = 4; i < 44; ++i) {
++ temp = s->w[i-1];
++ if (!(i & 3)) {
++ temp = subWord(rotWord(temp)) ^ rcon[i/4];
+ }
++ s->w[i] = s->w[i-4] ^ temp;
++ }
+
+- /* In case of decryption, adjust the key schedule for the equivalent inverse cipher */
+- if (decrypt) {
+- for (round = 1; round <= 9; ++round) {
+- invMixColumnsW(&s->w[round * 4]);
+- }
++ /* In case of decryption, adjust the key schedule for the equivalent inverse cipher */
++ if (decrypt) {
++ for (round = 1; round <= 9; ++round) {
++ invMixColumnsW(&s->w[round * 4]);
+ }
++ }
+ }
+
+-static void aesEncryptBlock(DecryptAESState *s, const unsigned char *in)
+-{
+- int c, round;
+-
+- // initial state (input is xor'd with previous output because of CBC)
+- for (c = 0; c < 4; ++c) {
+- s->state[c] = in[4 * c] ^ s->buf[4 * c];
+- s->state[4 + c] = in[4 * c + 1] ^ s->buf[4 * c + 1];
+- s->state[8 + c] = in[4 * c + 2] ^ s->buf[4 * c + 2];
+- s->state[12 + c] = in[4 * c + 3] ^ s->buf[4 * c + 3];
+- }
++static void aesEncryptBlock(DecryptAESState *s, const unsigned char *in) {
++ int c, round;
+
+- // round 0
+- addRoundKey(s->state, &s->w[0]);
++ // initial state (input is xor'd with previous output because of CBC)
++ for (c = 0; c < 4; ++c) {
++ s->state[c] = in[4*c] ^ s->buf[4*c];
++ s->state[4+c] = in[4*c+1] ^ s->buf[4*c+1];
++ s->state[8+c] = in[4*c+2] ^ s->buf[4*c+2];
++ s->state[12+c] = in[4*c+3] ^ s->buf[4*c+3];
++ }
+
+- // rounds 1-9
+- for (round = 1; round <= 9; ++round) {
+- subBytes(s->state);
+- shiftRows(s->state);
+- mixColumns(s->state);
+- addRoundKey(s->state, &s->w[round * 4]);
+- }
++ // round 0
++ addRoundKey(s->state, &s->w[0]);
+
+- // round 10
++ // rounds 1-9
++ for (round = 1; round <= 9; ++round) {
+ subBytes(s->state);
+ shiftRows(s->state);
+- addRoundKey(s->state, &s->w[10 * 4]);
+-
+- for (c = 0; c < 4; ++c) {
+- s->buf[4 * c] = s->state[c];
+- s->buf[4 * c + 1] = s->state[4 + c];
+- s->buf[4 * c + 2] = s->state[8 + c];
+- s->buf[4 * c + 3] = s->state[12 + c];
+- }
+-
+- s->bufIdx = 0;
++ mixColumns(s->state);
++ addRoundKey(s->state, &s->w[round * 4]);
++ }
++
++ // round 10
++ subBytes(s->state);
++ shiftRows(s->state);
++ addRoundKey(s->state, &s->w[10 * 4]);
++
++ for (c = 0; c < 4; ++c) {
++ s->buf[4*c] = s->state[c];
++ s->buf[4*c+1] = s->state[4+c];
++ s->buf[4*c+2] = s->state[8+c];
++ s->buf[4*c+3] = s->state[12+c];
++ }
++
++ s->bufIdx = 0;
+ }
+
+-static void aesDecryptBlock(DecryptAESState *s, const unsigned char *in, bool last)
+-{
+- int c, round, n, i;
+-
+- // initial state
+- for (c = 0; c < 4; ++c) {
+- s->state[c] = in[4 * c];
+- s->state[4 + c] = in[4 * c + 1];
+- s->state[8 + c] = in[4 * c + 2];
+- s->state[12 + c] = in[4 * c + 3];
+- }
++static void aesDecryptBlock(DecryptAESState *s, const unsigned char *in, bool last) {
++ int c, round, n, i;
+
+- // round 0
+- addRoundKey(s->state, &s->w[10 * 4]);
++ // initial state
++ for (c = 0; c < 4; ++c) {
++ s->state[c] = in[4*c];
++ s->state[4+c] = in[4*c+1];
++ s->state[8+c] = in[4*c+2];
++ s->state[12+c] = in[4*c+3];
++ }
+
+- // rounds 1-9
+- for (round = 9; round >= 1; --round) {
+- invSubBytes(s->state);
+- invShiftRows(s->state);
+- invMixColumns(s->state);
+- addRoundKey(s->state, &s->w[round * 4]);
+- }
++ // round 0
++ addRoundKey(s->state, &s->w[10 * 4]);
+
+- // round 10
++ // rounds 1-9
++ for (round = 9; round >= 1; --round) {
+ invSubBytes(s->state);
+ invShiftRows(s->state);
+- addRoundKey(s->state, &s->w[0]);
+-
+- // CBC
+- for (c = 0; c < 4; ++c) {
+- s->buf[4 * c] = s->state[c] ^ s->cbc[4 * c];
+- s->buf[4 * c + 1] = s->state[4 + c] ^ s->cbc[4 * c + 1];
+- s->buf[4 * c + 2] = s->state[8 + c] ^ s->cbc[4 * c + 2];
+- s->buf[4 * c + 3] = s->state[12 + c] ^ s->cbc[4 * c + 3];
+- }
+-
+- // save the input block for the next CBC
+- for (i = 0; i < 16; ++i) {
+- s->cbc[i] = in[i];
+- }
+-
+- // remove padding
+- s->bufIdx = 0;
+- if (last) {
+- n = s->buf[15];
+- if (n < 1 || n > 16) { // this should never happen
+- n = 16;
+- }
+- for (i = 15; i >= n; --i) {
+- s->buf[i] = s->buf[i - n];
+- }
+- s->bufIdx = n;
+- }
++ invMixColumns(s->state);
++ addRoundKey(s->state, &s->w[round * 4]);
++ }
++
++ // round 10
++ invSubBytes(s->state);
++ invShiftRows(s->state);
++ addRoundKey(s->state, &s->w[0]);
++
++ // CBC
++ for (c = 0; c < 4; ++c) {
++ s->buf[4*c] = s->state[c] ^ s->cbc[4*c];
++ s->buf[4*c+1] = s->state[4+c] ^ s->cbc[4*c+1];
++ s->buf[4*c+2] = s->state[8+c] ^ s->cbc[4*c+2];
++ s->buf[4*c+3] = s->state[12+c] ^ s->cbc[4*c+3];
++ }
++
++ // save the input block for the next CBC
++ for (i = 0; i < 16; ++i) {
++ s->cbc[i] = in[i];
++ }
++
++ // remove padding
++ s->bufIdx = 0;
++ if (last) {
++ n = s->buf[15];
++ if (n < 1 || n > 16) { // this should never happen
++ n = 16;
++ }
++ for (i = 15; i >= n; --i) {
++ s->buf[i] = s->buf[i-n];
++ }
++ s->bufIdx = n;
++ }
+ }
+
+ //------------------------------------------------------------------------
+ // AES-256 decryption
+ //------------------------------------------------------------------------
+
+-static void aes256KeyExpansion(DecryptAES256State *s, const unsigned char *objKey, int objKeyLen, bool decrypt)
+-{
+- unsigned int temp;
+- int i, round;
+-
+- //~ this assumes objKeyLen == 32
+-
+- for (i = 0; i < 8; ++i) {
+- s->w[i] = (objKey[4 * i] << 24) + (objKey[4 * i + 1] << 16) + (objKey[4 * i + 2] << 8) + objKey[4 * i + 3];
+- }
+- for (i = 8; i < 60; ++i) {
+- temp = s->w[i - 1];
+- if ((i & 7) == 0) {
+- temp = subWord(rotWord(temp)) ^ rcon[i / 8];
+- } else if ((i & 7) == 4) {
+- temp = subWord(temp);
+- }
+- s->w[i] = s->w[i - 8] ^ temp;
+- }
+-
+- /* In case of decryption, adjust the key schedule for the equivalent inverse cipher */
+- if (decrypt) {
+- for (round = 1; round <= 13; ++round) {
+- invMixColumnsW(&s->w[round * 4]);
+- }
++static void aes256KeyExpansion(DecryptAES256State *s,
++ const unsigned char *objKey, int objKeyLen, bool decrypt) {
++ unsigned int temp;
++ int i, round;
++
++ //~ this assumes objKeyLen == 32
++
++ for (i = 0; i < 8; ++i) {
++ s->w[i] = (objKey[4*i] << 24) + (objKey[4*i+1] << 16) +
++ (objKey[4*i+2] << 8) + objKey[4*i+3];
++ }
++ for (i = 8; i < 60; ++i) {
++ temp = s->w[i-1];
++ if ((i & 7) == 0) {
++ temp = subWord(rotWord(temp)) ^ rcon[i/8];
++ } else if ((i & 7) == 4) {
++ temp = subWord(temp);
++ }
++ s->w[i] = s->w[i-8] ^ temp;
++ }
++
++ /* In case of decryption, adjust the key schedule for the equivalent inverse cipher */
++ if (decrypt) {
++ for (round = 1; round <= 13; ++round) {
++ invMixColumnsW(&s->w[round * 4]);
+ }
++ }
+ }
+
+-static void aes256EncryptBlock(DecryptAES256State *s, const unsigned char *in)
+-{
+- int c, round;
+-
+- // initial state (input is xor'd with previous output because of CBC)
+- for (c = 0; c < 4; ++c) {
+- s->state[c] = in[4 * c] ^ s->buf[4 * c];
+- s->state[4 + c] = in[4 * c + 1] ^ s->buf[4 * c + 1];
+- s->state[8 + c] = in[4 * c + 2] ^ s->buf[4 * c + 2];
+- s->state[12 + c] = in[4 * c + 3] ^ s->buf[4 * c + 3];
+- }
++static void aes256EncryptBlock(DecryptAES256State *s, const unsigned char *in) {
++ int c, round;
+
+- // round 0
+- addRoundKey(s->state, &s->w[0]);
++ // initial state (input is xor'd with previous output because of CBC)
++ for (c = 0; c < 4; ++c) {
++ s->state[c] = in[4*c] ^ s->buf[4*c];
++ s->state[4+c] = in[4*c+1] ^ s->buf[4*c+1];
++ s->state[8+c] = in[4*c+2] ^ s->buf[4*c+2];
++ s->state[12+c] = in[4*c+3] ^ s->buf[4*c+3];
++ }
+
+- // rounds 1-13
+- for (round = 1; round <= 13; ++round) {
+- subBytes(s->state);
+- shiftRows(s->state);
+- mixColumns(s->state);
+- addRoundKey(s->state, &s->w[round * 4]);
+- }
++ // round 0
++ addRoundKey(s->state, &s->w[0]);
+
+- // round 14
++ // rounds 1-13
++ for (round = 1; round <= 13; ++round) {
+ subBytes(s->state);
+ shiftRows(s->state);
+- addRoundKey(s->state, &s->w[14 * 4]);
+-
+- for (c = 0; c < 4; ++c) {
+- s->buf[4 * c] = s->state[c];
+- s->buf[4 * c + 1] = s->state[4 + c];
+- s->buf[4 * c + 2] = s->state[8 + c];
+- s->buf[4 * c + 3] = s->state[12 + c];
+- }
+-
+- s->bufIdx = 0;
++ mixColumns(s->state);
++ addRoundKey(s->state, &s->w[round * 4]);
++ }
++
++ // round 14
++ subBytes(s->state);
++ shiftRows(s->state);
++ addRoundKey(s->state, &s->w[14 * 4]);
++
++ for (c = 0; c < 4; ++c) {
++ s->buf[4*c] = s->state[c];
++ s->buf[4*c+1] = s->state[4+c];
++ s->buf[4*c+2] = s->state[8+c];
++ s->buf[4*c+3] = s->state[12+c];
++ }
++
++ s->bufIdx = 0;
+ }
+
+-static void aes256DecryptBlock(DecryptAES256State *s, const unsigned char *in, bool last)
+-{
+- int c, round, n, i;
+-
+- // initial state
+- for (c = 0; c < 4; ++c) {
+- s->state[c] = in[4 * c];
+- s->state[4 + c] = in[4 * c + 1];
+- s->state[8 + c] = in[4 * c + 2];
+- s->state[12 + c] = in[4 * c + 3];
+- }
++static void aes256DecryptBlock(DecryptAES256State *s, const unsigned char *in, bool last) {
++ int c, round, n, i;
+
+- // round 0
+- addRoundKey(s->state, &s->w[14 * 4]);
++ // initial state
++ for (c = 0; c < 4; ++c) {
++ s->state[c] = in[4*c];
++ s->state[4+c] = in[4*c+1];
++ s->state[8+c] = in[4*c+2];
++ s->state[12+c] = in[4*c+3];
++ }
+
+- // rounds 13-1
+- for (round = 13; round >= 1; --round) {
+- invSubBytes(s->state);
+- invShiftRows(s->state);
+- invMixColumns(s->state);
+- addRoundKey(s->state, &s->w[round * 4]);
+- }
++ // round 0
++ addRoundKey(s->state, &s->w[14 * 4]);
+
+- // round 14
++ // rounds 13-1
++ for (round = 13; round >= 1; --round) {
+ invSubBytes(s->state);
+ invShiftRows(s->state);
+- addRoundKey(s->state, &s->w[0]);
+-
+- // CBC
+- for (c = 0; c < 4; ++c) {
+- s->buf[4 * c] = s->state[c] ^ s->cbc[4 * c];
+- s->buf[4 * c + 1] = s->state[4 + c] ^ s->cbc[4 * c + 1];
+- s->buf[4 * c + 2] = s->state[8 + c] ^ s->cbc[4 * c + 2];
+- s->buf[4 * c + 3] = s->state[12 + c] ^ s->cbc[4 * c + 3];
+- }
+-
+- // save the input block for the next CBC
+- for (i = 0; i < 16; ++i) {
+- s->cbc[i] = in[i];
+- }
+-
+- // remove padding
+- s->bufIdx = 0;
+- if (last) {
+- n = s->buf[15];
+- if (n < 1 || n > 16) { // this should never happen
+- n = 16;
+- }
+- for (i = 15; i >= n; --i) {
+- s->buf[i] = s->buf[i - n];
+- }
+- s->bufIdx = n;
+- if (n > 16) {
+- error(errSyntaxError, -1, "Reducing bufIdx from {0:d} to 16 to not crash", n);
+- s->bufIdx = 16;
+- }
++ invMixColumns(s->state);
++ addRoundKey(s->state, &s->w[round * 4]);
++ }
++
++ // round 14
++ invSubBytes(s->state);
++ invShiftRows(s->state);
++ addRoundKey(s->state, &s->w[0]);
++
++ // CBC
++ for (c = 0; c < 4; ++c) {
++ s->buf[4*c] = s->state[c] ^ s->cbc[4*c];
++ s->buf[4*c+1] = s->state[4+c] ^ s->cbc[4*c+1];
++ s->buf[4*c+2] = s->state[8+c] ^ s->cbc[4*c+2];
++ s->buf[4*c+3] = s->state[12+c] ^ s->cbc[4*c+3];
++ }
++
++ // save the input block for the next CBC
++ for (i = 0; i < 16; ++i) {
++ s->cbc[i] = in[i];
++ }
++
++ // remove padding
++ s->bufIdx = 0;
++ if (last) {
++ n = s->buf[15];
++ if (n < 1 || n > 16) { // this should never happen
++ n = 16;
++ }
++ for (i = 15; i >= n; --i) {
++ s->buf[i] = s->buf[i-n];
++ }
++ s->bufIdx = n;
++ if (n > 16)
++ {
++ error(errSyntaxError, -1, "Reducing bufIdx from {0:d} to 16 to not crash", n);
++ s->bufIdx = 16;
+ }
++ }
+ }
+
+ //------------------------------------------------------------------------
+--
+2.29.2
+
generated by cgit (git 2.34.1) at 2024-05-06 21:08:21 +0000