poppler: upgrade to release 21.01.0

Fixes CVE-2020-27778, CVE-2020-35702
and changelogs mention lots of fuzzing fixes.

Reviewed-on: https://gerrit.libreoffice.org/c/core/+/108912
Tested-by: Jenkins
Reviewed-by: Michael Stahl <michael.stahl@allotropia.de>
(cherry picked from commit 48e8b32a9b66722bbb28fc15840b3706a461aeb7)
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/108904
Tested-by: Michael Stahl <michael.stahl@allotropia.de>
Reviewed-by: Thorsten Behrens <thorsten.behrens@allotropia.de>
(cherry picked from commit fb185106492f5aabac6ab57ae90cd81d51480093)

Change-Id: Ib07bdee726905e74afc13a01bbbd53f218121744
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/108956
Tested-by: Thorsten Behrens <thorsten.behrens@allotropia.de>
Reviewed-by: Thorsten Behrens <thorsten.behrens@allotropia.de>

6 files changed, 1050 insertions, 64 deletions

diff --git a/download.lst b/download.lst
index 8d4dadec8b89..a00967e260c9 100644
--- a/download.lst
+++ b/download.lst
@@ -206,8 +206,8 @@ export PIXMAN_SHA256SUM := 21b6b249b51c6800dc9553b65106e1e37d0e25df942c90531d4c3
 export PIXMAN_TARBALL := e80ebae4da01e77f68744319f01d52a3-pixman-0.34.0.tar.gz
 export LIBPNG_SHA256SUM := 505e70834d35383537b6491e7ae8641f1a4bed1876dbfe361201fc80868d88ca
 export LIBPNG_TARBALL := libpng-1.6.37.tar.xz
-export POPPLER_SHA256SUM := 234f8e573ea57fb6a008e7c1e56bfae1af5d1adf0e65f47555e1ae103874e4df
-export POPPLER_TARBALL := poppler-0.82.0.tar.xz
+export POPPLER_SHA256SUM := 016dde34e5f868ea98a32ca99b643325a9682281500942b7113f4ec88d20e2f3
+export POPPLER_TARBALL := poppler-21.01.0.tar.xz
 export POSTGRESQL_SHA256SUM := a754c02f7051c2f21e52f8669a421b50485afcde9a581674d6106326b189d126
 export POSTGRESQL_TARBALL := postgresql-9.2.24.tar.bz2
 export PYTHON_SHA256SUM := 285892899bf4d5737fd08482aa6171c6b2564a45b9102dfacfb72826aebdc7dc
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
+
diff --git a/external/poppler/StaticLibrary_poppler.mk b/external/poppler/StaticLibrary_poppler.mk
index ae03836f2ba6..994b175fee6e 100644
--- a/external/poppler/StaticLibrary_poppler.mk
+++ b/external/poppler/StaticLibrary_poppler.mk
@@ -51,6 +51,23 @@ endif
 
 $(eval $(call gb_StaticLibrary_set_generated_cxx_suffix,poppler,cc))
 
+$(eval $(call gb_StaticLibrary_add_generated_cobjects,poppler,\
+	UnpackedTarball/poppler/poppler/CourierWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/CourierBoldWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/CourierBoldObliqueWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/CourierObliqueWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/HelveticaWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/HelveticaBoldWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/HelveticaBoldObliqueWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/HelveticaObliqueWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/SymbolWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/TimesBoldWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/TimesBoldItalicWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/TimesItalicWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/TimesRomanWidths.pregenerated \
+	UnpackedTarball/poppler/poppler/ZapfDingbatsWidths.pregenerated \
+))
+
 $(eval $(call gb_StaticLibrary_add_generated_exception_objects,poppler,\
 	UnpackedTarball/poppler/goo/gfile \
 	UnpackedTarball/poppler/goo/GooTimer \
@@ -72,8 +89,7 @@ $(eval $(call gb_StaticLibrary_add_generated_exception_objects,poppler,\
 	UnpackedTarball/poppler/fofi/FoFiIdentifier \
 	UnpackedTarball/poppler/poppler/Annot \
 	UnpackedTarball/poppler/poppler/Array \
-	UnpackedTarball/poppler/poppler/BuiltinFont \
-	UnpackedTarball/poppler/poppler/BuiltinFontTables \
+	UnpackedTarball/poppler/poppler/BBoxOutputDev \
 	UnpackedTarball/poppler/poppler/CachedFile \
 	UnpackedTarball/poppler/poppler/Catalog \
 	UnpackedTarball/poppler/poppler/CertificateInfo \
@@ -95,6 +111,7 @@ $(eval $(call gb_StaticLibrary_add_generated_exception_objects,poppler,\
 	UnpackedTarball/poppler/poppler/Hints \
 	UnpackedTarball/poppler/poppler/JArithmeticDecoder \
 	UnpackedTarball/poppler/poppler/JBIG2Stream \
+	UnpackedTarball/poppler/poppler/JSInfo \
 	UnpackedTarball/poppler/poppler/Lexer \
 	UnpackedTarball/poppler/poppler/Link \
 	UnpackedTarball/poppler/poppler/Linearization \
@@ -109,6 +126,7 @@ $(eval $(call gb_StaticLibrary_add_generated_exception_objects,poppler,\
 	UnpackedTarball/poppler/poppler/PageTransition \
 	UnpackedTarball/poppler/poppler/Parser \
 	UnpackedTarball/poppler/poppler/PDFDoc \
+	UnpackedTarball/poppler/poppler/PDFDocBuilder \
 	UnpackedTarball/poppler/poppler/PDFDocEncoding \
 	UnpackedTarball/poppler/poppler/PDFDocFactory \
 	UnpackedTarball/poppler/poppler/ProfileData \
diff --git a/external/poppler/UnpackedTarball_poppler.mk b/external/poppler/UnpackedTarball_poppler.mk
index 76fd33236e5d..0f29d38e097c 100644
--- a/external/poppler/UnpackedTarball_poppler.mk
+++ b/external/poppler/UnpackedTarball_poppler.mk
@@ -14,6 +14,7 @@ $(eval $(call gb_UnpackedTarball_set_tarball,poppler,$(POPPLER_TARBALL),,poppler
 $(eval $(call gb_UnpackedTarball_add_patches,poppler,\
 	external/poppler/poppler-config.patch.1 \
 	external/poppler/poppler-c++11.patch.1 \
+	external/poppler/0001-Partially-revert-814fbda28cc8a37fed3134c2db8da28f86f.patch.1 \
 	external/poppler/0001-Revert-Make-the-mul-tables-be-calculated-at-compile-.patch.1 \
 ))
 
diff --git a/external/poppler/poppler-c++11.patch.1 b/external/poppler/poppler-c++11.patch.1
index 5a4d1a24e2e2..9e607b381de0 100644
--- a/external/poppler/poppler-c++11.patch.1
+++ b/external/poppler/poppler-c++11.patch.1
@@ -12,18 +12,18 @@ remove usage of newfangled C++ that baseline toolchains don't support
  namespace {
  
 @@ -366,7 +366,7 @@
-   }
+     }
  #else
-   // First try to atomically open the file with CLOEXEC
--  const std::string modeStr = mode + "e"s;
-+  const std::string modeStr = mode + std::string("e");
-   FILE *file = fopen(path, modeStr.c_str());
-   if (file != nullptr)
-     return file;
+     // First try to atomically open the file with CLOEXEC
+-    const std::string modeStr = mode + "e"s;
++    const std::string modeStr = mode + std::string("e");
+     FILE *file = fopen(path, modeStr.c_str());
+     if (file != nullptr)
+         return file;
 --- poppler/goo/gmem.h.orig	2019-01-16 11:25:28.161920038 +0100
 +++ poppler/goo/gmem.h	2019-01-16 11:25:53.756882295 +0100
 @@ -177,4 +177,6 @@
-   return std::strncpy(r, s, n);
+     return std::strncpy(r, s, n);
  }
  
 +#include <o3tl/make_unique.hxx>
diff --git a/external/poppler/poppler-config.patch.1 b/external/poppler/poppler-config.patch.1
index cb74cd66fb5e..b902402ea4e7 100644
--- a/external/poppler/poppler-config.patch.1
+++ b/external/poppler/poppler-config.patch.1
@@ -1,5 +1,7 @@
 *three* poppler config headers
 
+note: to get the 3rd one, use -DENABLE_CPP=on
+
 mkdir build && cd build && cmake .. -DENABLE_DCTDECODER=libjpeg -DHAVE_CAIRO=off -DENABLE_LIBOPENJPEG=none -DENABLE_CMS=none -DENABLE_LIBCURL=off -DENABLE_ZLIB=off -DENABLE_ZLIB_UNCOMPRESS=off -DENABLE_NSS3=off -DENABLE_LIBPNG=off -DENABLE_LIBTIFF=off -DENABLE_SPLASH=off -DENABLE_UTILS=off -DENABLE_CPP=off -DENABLE_GLIB=off -DENABLE_GOBJECT_INTROSPECTION=off -DENABLE_GTK_DOC=off -DENABLE_QT5=off
 
 manually disabled these because cmake failed to do it:
@@ -14,7 +16,7 @@ new file mode 100644
 index 0fbd336a..451213f8 100644
 --- /dev/null
 +++ b/config.h
-@@ -0,0 +1,248 @@
+@@ -0,0 +1,221 @@
 +/* config.h.  Generated from config.h.cmake by cmake.  */
 +
 +/* Build against libcurl. */
@@ -120,21 +122,6 @@ index 0fbd336a..451213f8 100644
 +#endif
 +
 +#if !defined(_WIN32)
-+/* Define to 1 if you have the `rand_r' function. */
-+#define HAVE_RAND_R 1
-+#endif
-+
-+#if defined(_WIN32)
-+/* Define to 1 if you have the `strcpy_s' function. */
-+#define HAVE_STRCPY_S 1
-+#endif
-+
-+#if defined(_WIN32)
-+/* Define to 1 if you have the `strcat_s' function. */
-+#define HAVE_STRCAT_S 1
-+#endif
-+
-+#if !defined(_WIN32)
 +/* Defines if strtok_r is available on your system */
 +#define HAVE_STRTOK_R 1
 +#endif
@@ -147,9 +134,6 @@ index 0fbd336a..451213f8 100644
 +#define HAVE_POPEN 1
 +#endif
 +
-+/* Use splash for rendering. */
-+/* #undef HAVE_SPLASH */
-+
 +#if !defined(__APPLE__) && !defined(_WIN32)
 +/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
 +   */
@@ -179,9 +163,6 @@ index 0fbd336a..451213f8 100644
 +/* Define as const if the declaration of iconv() needs const. */
 +#define ICONV_CONST 
 +
-+/* Enable multithreading support. */
-+#define MULTITHREADED 1
-+
 +/* Generate OPI comments in PS output. */
 +#define OPI_SUPPORT 1
 +
@@ -195,7 +176,7 @@ index 0fbd336a..451213f8 100644
 +#define PACKAGE_NAME "poppler"
 +
 +/* Define to the full name and version of this package. */
-+#define PACKAGE_STRING "poppler 0.82.0"
++#define PACKAGE_STRING "poppler 21.01.0"
 +
 +/* Define to the one symbol short name of this package. */
 +#define PACKAGE_TARNAME "poppler"
@@ -204,7 +185,7 @@ index 0fbd336a..451213f8 100644
 +#define PACKAGE_URL ""
 +
 +/* Define to the version of this package. */
-+#define PACKAGE_VERSION "0.82.0"
++#define PACKAGE_VERSION "21.01.0"
 +
 +/* Poppler data dir */
 +#define POPPLER_DATADIR "/usr/local/share/poppler"
@@ -212,23 +193,17 @@ index 0fbd336a..451213f8 100644
 +/* Support for curl based doc builder is compiled in. */
 +/* #undef POPPLER_HAS_CURL_SUPPORT */
 +
-+/* Include support for CMYK rasterization */
-+/* #undef SPLASH_CMYK */
-+
 +/* Enable word list support. */
 +#define TEXTOUT_WORD_LIST 1
 +
 +/* Defines if use cms */
 +/* #undef USE_CMS */
 +
-+/* Use fixed point arithmetic in the Splash backend */
-+/* #undef USE_FIXEDPOINT */
-+
 +/* Use single precision arithmetic in the Splash backend */
 +/* #undef USE_FLOAT */
 +
 +/* Version number of package */
-+#define VERSION "0.82.0"
++#define VERSION "21.01.0"
 +
 +#if defined(__APPLE__)
 +#elif defined (_WIN32)
@@ -268,7 +243,7 @@ new file mode 100644
 index 0fbd336a..451213f8 100644
 --- /dev/null
 +++ b/poppler/poppler-config.h
-@@ -0,0 +1,173 @@
+@@ -0,0 +1,166 @@
 +//================================================= -*- mode: c++ -*- ====
 +//
 +// poppler-config.h
@@ -288,6 +263,9 @@ index 0fbd336a..451213f8 100644
 +// Copyright (C) 2014 Hib Eris <hib@hiberis.nl>
 +// Copyright (C) 2016 Tor Lillqvist <tml@collabora.com>
 +// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com>
++// Copyright (C) 2018 Adam Reichold <adam.reichold@t-online.de>
++// Copyright (C) 2018 Stefan Brüns <stefan.bruens@rwth-aachen.de>
++// Copyright (C) 2020 Albert Astals Cid <aacid@kde.org>
 +//
 +// To see a description of the changes please see the Changelog file that
 +// came with your tarball or type make ChangeLog if you are building from git
@@ -304,17 +282,7 @@ index 0fbd336a..451213f8 100644
 +
 +/* Defines the poppler version. */
 +#ifndef POPPLER_VERSION
-+#define POPPLER_VERSION "0.82.0"
-+#endif
-+
-+/* Enable multithreading support. */
-+#ifndef MULTITHREADED
-+#define MULTITHREADED 1
-+#endif
-+
-+/* Use fixedpoint. */
-+#ifndef USE_FIXEDPOINT
-+/* #undef USE_FIXEDPOINT */
++#define POPPLER_VERSION "21.01.0"
 +#endif
 +
 +/* Use single precision arithmetic in the Splash backend */
@@ -401,17 +369,17 @@ index 0fbd336a..451213f8 100644
 +/* #undef USE_BOOST_HEADERS */
 +#endif
 +
-+// Also, there are preprocessor symbols in the header files
-+// that are used but never defined when building poppler using configure
-+// or cmake: DISABLE_OUTLINE, DEBUG_MEM,
-+// ENABLE_PLUGINS, DEBUG_FORMS
++/* Is splash backend available */
++#ifndef HAVE_SPLASH
++/* #undef HAVE_SPLASH */
++#endif
 +
 +//------------------------------------------------------------------------
 +// version
 +//------------------------------------------------------------------------
 +
 +// copyright notice
-+#define popplerCopyright "Copyright 2005-2018 The Poppler Developers - http://poppler.freedesktop.org"
++#define popplerCopyright "Copyright 2005-2021 The Poppler Developers - http://poppler.freedesktop.org"
 +#define xpdfCopyright "Copyright 1996-2011 Glyph & Cog, LLC"
 +
 +//------------------------------------------------------------------------
@@ -429,7 +397,7 @@ index 0fbd336a..451213f8 100644
 +//------------------------------------------------------------------------
 +
 +#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
-+#include <stdio.h> // __MINGW_PRINTF_FORMAT is defined in the mingw stdio.h
++#include <cstdio> // __MINGW_PRINTF_FORMAT is defined in the mingw stdio.h
 +#ifdef __MINGW_PRINTF_FORMAT
 +#define GCC_PRINTF_FORMAT(fmt_index, va_index) \
 +	__attribute__((__format__(__MINGW_PRINTF_FORMAT, fmt_index, va_index)))
@@ -471,9 +439,9 @@ index 0fbd336a..451213f8 100644
 +
 +#include "poppler-global.h"
 +
-+#define POPPLER_VERSION "0.82.0"
-+#define POPPLER_VERSION_MAJOR 0
-+#define POPPLER_VERSION_MINOR 82
++#define POPPLER_VERSION "21.01.0"
++#define POPPLER_VERSION_MAJOR 21
++#define POPPLER_VERSION_MINOR 1
 +#define POPPLER_VERSION_MICRO 0
 +
 +namespace poppler