[Libreoffice-commits] core.git: Branch 'distro/cib/libreoffice-6-1' - 5 commits - download.lst external/openssl external/poppler javaunohelper/com sdext/source
Stephan Bergmann (via logerrit)
logerrit at kemper.freedesktop.org
Fri Jan 8 09:34:58 UTC 2021
download.lst | 4
external/openssl/UnpackedTarball_openssl.mk | 1
external/openssl/openssl-1.0.2k-cve-2020-1971.patch.1 | 578 +++++
external/poppler/0001-Partially-revert-814fbda28cc8a37fed3134c2db8da28f86f.patch.1 | 999 ++++++++++
external/poppler/StaticLibrary_poppler.mk | 22
external/poppler/UnpackedTarball_poppler.mk | 1
external/poppler/poppler-c++11.patch.1 | 16
external/poppler/poppler-config.patch.1 | 72
javaunohelper/com/sun/star/lib/uno/helper/InterfaceContainer.java | 48
sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx | 11
sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.hxx | 4
sdext/source/pdfimport/xpdfwrapper/wrapper_gpl.cxx | 4
12 files changed, 1671 insertions(+), 89 deletions(-)
New commits:
commit 40ec60ffb086843fbaf7a7679b361a7d773c218c
Author: Stephan Bergmann <sbergman at redhat.com>
AuthorDate: Wed Oct 10 14:19:53 2018 +0200
Commit: Michael Stahl <michael.stahl at allotropia.de>
CommitDate: Fri Jan 8 10:12:30 2021 +0100
HTML tt -> code in JavaDoc comments
...to avoid "error: tag not supported in the generated HTML version: tt" with
JDK 11
Change-Id: I761c987257f42d01f24c88440495698cac6226d2
Reviewed-on: https://gerrit.libreoffice.org/61614
Tested-by: Jenkins
Reviewed-by: Stephan Bergmann <sbergman at redhat.com>
(cherry picked from commit 07721a4dea1aab898a993662a24c5ab68ecc1edf)
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/108957
Tested-by: Thorsten Behrens <thorsten.behrens at allotropia.de>
Reviewed-by: Thorsten Behrens <thorsten.behrens at allotropia.de>
diff --git a/javaunohelper/com/sun/star/lib/uno/helper/InterfaceContainer.java b/javaunohelper/com/sun/star/lib/uno/helper/InterfaceContainer.java
index cd751c5af7ef..b0419771870e 100644
--- a/javaunohelper/com/sun/star/lib/uno/helper/InterfaceContainer.java
+++ b/javaunohelper/com/sun/star/lib/uno/helper/InterfaceContainer.java
@@ -127,9 +127,9 @@ public class InterfaceContainer implements Cloneable
}
/**
- * Trims the capacity of this <tt>ArrayList</tt> instance to be the
+ * Trims the capacity of this <code>ArrayList</code> instance to be the
* list's current size. An application can use this operation to minimize
- * the storage of an <tt>ArrayList</tt> instance.
+ * the storage of an <code>ArrayList</code> instance.
*/
synchronized public void trimToSize()
{
@@ -143,7 +143,7 @@ public class InterfaceContainer implements Cloneable
}
/**
- * Increases the capacity of this <tt>ArrayList</tt> instance, if
+ * Increases the capacity of this <code>ArrayList</code> instance, if
* necessary, to ensure that it can hold at least the number of elements
* specified by the minimum capacity argument.
*
@@ -167,7 +167,7 @@ public class InterfaceContainer implements Cloneable
* Appends the specified element to the end of this list.
*
* @param o element to be appended to this list.
- * @return <tt>true</tt> (as per the general contract of Collection.add).
+ * @return <code>true</code> (as per the general contract of Collection.add).
*/
synchronized public boolean add(Object o)
{
@@ -189,7 +189,7 @@ public class InterfaceContainer implements Cloneable
* @param index index at which the specified element is to be inserted.
* @param element element to be inserted.
* @throws IndexOutOfBoundsException if index is out of range
- * <tt>(index < 0 || index > size())</tt>.
+ * <code>(index < 0 || index > size())</code>.
*/
synchronized public void add(int index, Object element)
{
@@ -218,8 +218,8 @@ public class InterfaceContainer implements Cloneable
* list is nonempty.)
*
* @param c the elements to be inserted into this list.
- * @throws IndexOutOfBoundsException if index out of range <tt>(index
- * < 0 || index > size())</tt>.
+ * @throws IndexOutOfBoundsException if index out of range <code>(index
+ * < 0 || index > size())</code>.
* @return true if an element was inserted.
*/
synchronized public boolean addAll(Collection c)
@@ -247,8 +247,8 @@ public class InterfaceContainer implements Cloneable
* @param index index at which to insert first element
* from the specified collection.
* @param c elements to be inserted into this list.
- * @throws IndexOutOfBoundsException if index out of range <tt>(index
- * < 0 || index > size())</tt>.
+ * @throws IndexOutOfBoundsException if index out of range <code>(index
+ * < 0 || index > size())</code>.
* @return true if an element was inserted.
*/
synchronized public boolean addAll(int index, Collection c)
@@ -304,10 +304,10 @@ public class InterfaceContainer implements Cloneable
}
}
/**
- * Returns <tt>true</tt> if this list contains the specified element.
+ * Returns <code>true</code> if this list contains the specified element.
*
* @param elem element whose presence in this List is to be tested.
- * @return <tt>true</tt> if this list contains the specified element.
+ * @return <code>true</code> if this list contains the specified element.
*/
synchronized public boolean contains(Object elem)
{
@@ -337,8 +337,8 @@ public class InterfaceContainer implements Cloneable
*
* @param index index of element to return.
* @return the element at the specified position in this list.
- * @throws IndexOutOfBoundsException if index is out of range <tt>(index
- * < 0 || index >= size())</tt>.
+ * @throws IndexOutOfBoundsException if index is out of range <code>(index
+ * < 0 || index >= size())</code>.
*/
synchronized public Object get(int index)
{
@@ -352,11 +352,11 @@ public class InterfaceContainer implements Cloneable
/**
* Searches for the first occurrence of the given argument, testing
- * for equality using the <tt>equals</tt> method.
+ * for equality using the <code>equals</code> method.
*
* @param elem an object.
* @return the index of the first occurrence of the argument in this
- * list; returns <tt>-1</tt> if the object is not found.
+ * list; returns <code>-1</code> if the object is not found.
* @see Object#equals(Object)
*/
synchronized public int indexOf(Object elem)
@@ -392,8 +392,8 @@ public class InterfaceContainer implements Cloneable
/**
* Tests if this list has no elements.
*
- * @return <tt>true</tt> if this list has no elements;
- * <tt>false</tt> otherwise.
+ * @return <code>true</code> if this list has no elements;
+ * <code>false</code> otherwise.
*/
synchronized public boolean isEmpty()
{
@@ -448,10 +448,10 @@ public class InterfaceContainer implements Cloneable
}
/**
- * Returns a shallow copy of this <tt>ArrayList</tt> instance. The contained
+ * Returns a shallow copy of this <code>ArrayList</code> instance. The contained
* references are copied but the objects not.
*
- * @return a clone of this <tt>List</tt> instance.
+ * @return a clone of this <code>List</code> instance.
*/
@Override
synchronized public Object clone()
@@ -492,8 +492,8 @@ public class InterfaceContainer implements Cloneable
*
* @param index the index of the element to removed.
* @return the element that was removed from the list.
- * @throws IndexOutOfBoundsException if index out of range <tt>(index
- * < 0 || index >= size())</tt>.
+ * @throws IndexOutOfBoundsException if index out of range <code>(index
+ * < 0 || index >= size())</code>.
*/
synchronized public Object remove(int index)
{
@@ -606,7 +606,7 @@ public class InterfaceContainer implements Cloneable
* @param element element to be stored at the specified position.
* @return the element previously at the specified position.
* @throws IndexOutOfBoundsException if index out of range
- * <tt>(index < 0 || index >= size())</tt>.
+ * <code>(index < 0 || index >= size())</code>.
*/
synchronized public Object set(int index, Object element)
{
@@ -661,9 +661,9 @@ public class InterfaceContainer implements Cloneable
* If the list fits in the specified array with room to spare (i.e., the
* array has more elements than the list), the element in the array
* immediately following the end of the collection is set to
- * <tt>null</tt>. This is useful in determining the length of the list
+ * <code>null</code>. This is useful in determining the length of the list
* <i>only</i> if the caller knows that the list does not contain any
- * <tt>null</tt> elements.
+ * <code>null</code> elements.
*
* @param a the array into which the elements of the list are to
* be stored, if it is big enough; otherwise, a new array of the
commit a7e4f42308d962ea5a0523b91500bd01afd06c16
Author: Michael Stahl <michael.stahl at allotropia.de>
AuthorDate: Wed Jan 6 19:30:07 2021 +0100
Commit: Michael Stahl <michael.stahl at allotropia.de>
CommitDate: Fri Jan 8 10:12:22 2021 +0100
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 at allotropia.de>
(cherry picked from commit 48e8b32a9b66722bbb28fc15840b3706a461aeb7)
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/108904
Tested-by: Michael Stahl <michael.stahl at allotropia.de>
Reviewed-by: Thorsten Behrens <thorsten.behrens at 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 at allotropia.de>
Reviewed-by: Thorsten Behrens <thorsten.behrens at allotropia.de>
diff --git a/download.lst b/download.lst
index 0844f34a0a46..9da3fa3c1192 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 := db61d498105a7d5fe46185e67ac830c878cdd7dc1f82a87f06b842217924c461
export POSTGRESQL_TARBALL := c0b4799ea9850eae3ead14f0a60e9418-postgresql-9.2.1.tar.bz2
export PYTHON_SHA256SUM := c24a37c63a67f53bdd09c5f287b5cff8e8b98f857bf348c577d454d3f74db049
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 at hiberis.nl>
+// Copyright (C) 2016 Tor Lillqvist <tml at collabora.com>
+// Copyright (C) 2017 Adrian Johnson <ajohnson at redneon.com>
++// Copyright (C) 2018 Adam Reichold <adam.reichold at t-online.de>
++// Copyright (C) 2018 Stefan Brüns <stefan.bruens at rwth-aachen.de>
++// Copyright (C) 2020 Albert Astals Cid <aacid at 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
commit 4f9c4a98ad6a33826eb9920d0435066ca93f837b
Author: Martin Whitaker <foss at martin-whitaker.me.uk>
AuthorDate: Fri May 8 21:47:25 2020 +0200
Commit: Michael Stahl <michael.stahl at allotropia.de>
CommitDate: Fri Jan 8 10:12:14 2021 +0100
tdf#131353: Fix build with poppler 0.86.0
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/93789
Tested-by: René Engelhard <rene at debian.org>
Tested-by: Jenkins
Reviewed-by: Tomáš Chvátal <tchvatal at suse.com>
(cherry picked from commit b42ab78fb871924896b3cc38a7b2f1257151f711)
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/96639
Reviewed-by: Adolfo Jayme Barrientos <fitojb at ubuntu.com>
(cherry picked from commit d40f36bf47814c324a1ec467c566255fb187444b)
Change-Id: I89b4635a6a3e3a5522172d6f4c3f14e6c14994b1
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/108955
Tested-by: Thorsten Behrens <thorsten.behrens at allotropia.de>
Reviewed-by: Thorsten Behrens <thorsten.behrens at allotropia.de>
diff --git a/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx b/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx
index 2875d72a72e5..83c734c9bf6f 100644
--- a/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx
+++ b/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx
@@ -562,7 +562,9 @@ void PDFOutDev::processLink(Link* link, Catalog*)
LinkAction* pAction = link->getAction();
if (pAction && pAction->getKind() == actionURI)
{
-#if POPPLER_CHECK_VERSION(0, 72, 0)
+#if POPPLER_CHECK_VERSION(0, 86, 0)
+ const char* pURI = static_cast<LinkURI*>(pAction)->getURI().c_str();
+#elif POPPLER_CHECK_VERSION(0, 72, 0)
const char* pURI = static_cast<LinkURI*>(pAction)->getURI()->c_str();
#else
const char* pURI = static_cast<LinkURI*>(pAction)->getURI()->getCString();
commit 1af73c923a8f1a7455b210d2073111cfc6052ca2
Author: Martin Milata <martin at martinmilata.cz>
AuthorDate: Wed Dec 4 02:37:40 2019 +0100
Commit: Michael Stahl <michael.stahl at allotropia.de>
CommitDate: Thu Jan 7 20:32:04 2021 +0100
Fix build with poppler-0.83
Change-Id: I7a3684932b8f9c403a3368b42fa4d8039c67f1a9
Reviewed-on: https://gerrit.libreoffice.org/84384
Tested-by: Jenkins
Reviewed-by: Michael Stahl <michael.stahl at cib.de>
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/86905
Reviewed-by: Tomáš Chvátal <tchvatal at suse.com>
Tested-by: Tomáš Chvátal <tchvatal at suse.com>
(cherry picked from commit 035830400393e075fca364a444e04c40516730b2)
diff --git a/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx b/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx
index a5d8109589be..2875d72a72e5 100644
--- a/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx
+++ b/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx
@@ -491,11 +491,18 @@ void PDFOutDev::writeFontFile( GfxFont* gfxFont ) const
gfree(pBuf);
}
+#if POPPLER_CHECK_VERSION(0, 83, 0)
+void PDFOutDev::printPath( const GfxPath* pPath )
+#else
void PDFOutDev::printPath( GfxPath* pPath )
+#endif
{
int nSubPaths = pPath ? pPath->getNumSubpaths() : 0;
for( int i=0; i<nSubPaths; i++ )
{
+#if POPPLER_CHECK_VERSION(0, 83, 0)
+ const
+#endif
GfxSubpath* pSub = pPath->getSubpath( i );
const int nPoints = pSub->getNumPoints();
diff --git a/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.hxx b/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.hxx
index ccf5b8fa9535..8766a2f1be6a 100644
--- a/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.hxx
+++ b/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.hxx
@@ -149,7 +149,11 @@ namespace pdfi
int parseFont( long long nNewId, GfxFont* pFont, GfxState* state ) const;
void writeFontFile( GfxFont* gfxFont ) const;
+#if POPPLER_CHECK_VERSION(0, 83, 0)
+ static void printPath( const GfxPath* pPath );
+#else
static void printPath( GfxPath* pPath );
+#endif
public:
explicit PDFOutDev( PDFDoc* pDoc );
diff --git a/sdext/source/pdfimport/xpdfwrapper/wrapper_gpl.cxx b/sdext/source/pdfimport/xpdfwrapper/wrapper_gpl.cxx
index f2049a6a6e48..48d6160a8c10 100644
--- a/sdext/source/pdfimport/xpdfwrapper/wrapper_gpl.cxx
+++ b/sdext/source/pdfimport/xpdfwrapper/wrapper_gpl.cxx
@@ -68,7 +68,11 @@ int main(int argc, char **argv)
}
// read config file
+#if POPPLER_CHECK_VERSION(0, 83, 0)
+ globalParams = std::make_unique<GlobalParams>();
+#else
globalParams = new GlobalParams();
+#endif
globalParams->setErrQuiet(true);
#if defined(_MSC_VER)
globalParams->setupBaseFonts(nullptr);
commit 7aeee390b3d6684b5ace336751d4e2c5cf8e074e
Author: Michael Stahl <michael.stahl at allotropia.de>
AuthorDate: Wed Jan 6 17:39:19 2021 +0100
Commit: Michael Stahl <michael.stahl at allotropia.de>
CommitDate: Thu Jan 7 19:32:18 2021 +0100
openssl: add patch to fix CVE-2020-1971
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/108884
Tested-by: Jenkins
Reviewed-by: Thorsten Behrens <thorsten.behrens at allotropia.de>
(cherry picked from commit b4c5bd9b330068e8c550e398cf761457ec9b6aa4)
Change-Id: Ia756f1fa642eeb6dcadc867cc9730732a73c11b4
diff --git a/external/openssl/UnpackedTarball_openssl.mk b/external/openssl/UnpackedTarball_openssl.mk
index 719b8b0e5842..ad600cce1412 100644
--- a/external/openssl/UnpackedTarball_openssl.mk
+++ b/external/openssl/UnpackedTarball_openssl.mk
@@ -21,6 +21,7 @@ $(eval $(call gb_UnpackedTarball_add_patches,openssl,\
external/openssl/opensslosxppc.patch \
external/openssl/openssl-3650-masm.patch.1 \
external/openssl/openssl-fixbuild.patch.1 \
+ external/openssl/openssl-1.0.2k-cve-2020-1971.patch.1 \
))
# vim: set noet sw=4 ts=4:
diff --git a/external/openssl/openssl-1.0.2k-cve-2020-1971.patch.1 b/external/openssl/openssl-1.0.2k-cve-2020-1971.patch.1
new file mode 100644
index 000000000000..313f9cd870d7
--- /dev/null
+++ b/external/openssl/openssl-1.0.2k-cve-2020-1971.patch.1
@@ -0,0 +1,578 @@
+diff -up openssl-1.0.2k/crypto/asn1/asn1_err.c.null-dereference openssl-1.0.2k/crypto/asn1/asn1_err.c
+--- openssl-1.0.2k/crypto/asn1/asn1_err.c.null-dereference 2020-12-04 10:08:08.506247597 +0100
++++ openssl-1.0.2k/crypto/asn1/asn1_err.c 2020-12-04 10:12:31.901956486 +0100
+@@ -1,6 +1,6 @@
+ /* crypto/asn1/asn1_err.c */
+ /* ====================================================================
+- * Copyright (c) 1999-2018 The OpenSSL Project. All rights reserved.
++ * Copyright (c) 1999-2020 The OpenSSL Project. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+@@ -103,6 +103,7 @@ static ERR_STRING_DATA ASN1_str_functs[]
+ {ERR_FUNC(ASN1_F_ASN1_ITEM_DUP), "ASN1_item_dup"},
+ {ERR_FUNC(ASN1_F_ASN1_ITEM_EX_COMBINE_NEW), "ASN1_ITEM_EX_COMBINE_NEW"},
+ {ERR_FUNC(ASN1_F_ASN1_ITEM_EX_D2I), "ASN1_ITEM_EX_D2I"},
++ {ERR_PACK(ERR_LIB_ASN1, ASN1_F_ASN1_ITEM_EX_I2D, 0), "ASN1_item_ex_i2d"},
+ {ERR_FUNC(ASN1_F_ASN1_ITEM_I2D_BIO), "ASN1_item_i2d_bio"},
+ {ERR_FUNC(ASN1_F_ASN1_ITEM_I2D_FP), "ASN1_item_i2d_fp"},
+ {ERR_FUNC(ASN1_F_ASN1_ITEM_PACK), "ASN1_item_pack"},
+@@ -202,6 +203,7 @@ static ERR_STRING_DATA ASN1_str_reasons[
+ {ERR_REASON(ASN1_R_AUX_ERROR), "aux error"},
+ {ERR_REASON(ASN1_R_BAD_CLASS), "bad class"},
+ {ERR_REASON(ASN1_R_BAD_OBJECT_HEADER), "bad object header"},
++ {ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_BAD_TEMPLATE), "bad template"},
+ {ERR_REASON(ASN1_R_BAD_PASSWORD_READ), "bad password read"},
+ {ERR_REASON(ASN1_R_BAD_TAG), "bad tag"},
+ {ERR_REASON(ASN1_R_BMPSTRING_IS_WRONG_LENGTH),
+diff -up openssl-1.0.2k/crypto/asn1/asn1.h.null-dereference openssl-1.0.2k/crypto/asn1/asn1.h
+--- openssl-1.0.2k/crypto/asn1/asn1.h.null-dereference 2020-12-04 11:00:06.896637900 +0100
++++ openssl-1.0.2k/crypto/asn1/asn1.h 2020-12-04 11:04:47.079562987 +0100
+@@ -1202,6 +1202,7 @@ void ERR_load_ASN1_strings(void);
+ # define ASN1_F_ASN1_ITEM_DUP 191
+ # define ASN1_F_ASN1_ITEM_EX_COMBINE_NEW 121
+ # define ASN1_F_ASN1_ITEM_EX_D2I 120
++# define ASN1_F_ASN1_ITEM_EX_I2D 231
+ # define ASN1_F_ASN1_ITEM_I2D_BIO 192
+ # define ASN1_F_ASN1_ITEM_I2D_FP 193
+ # define ASN1_F_ASN1_ITEM_PACK 198
+@@ -1298,6 +1299,7 @@ void ERR_load_ASN1_strings(void);
+ # define ASN1_R_AUX_ERROR 100
+ # define ASN1_R_BAD_CLASS 101
+ # define ASN1_R_BAD_OBJECT_HEADER 102
++# define ASN1_R_BAD_TEMPLATE 230
+ # define ASN1_R_BAD_PASSWORD_READ 103
+ # define ASN1_R_BAD_TAG 104
+ # define ASN1_R_BMPSTRING_IS_WRONG_LENGTH 214
+diff -up openssl-1.0.2k/crypto/asn1/tasn_dec.c.null-dereference openssl-1.0.2k/crypto/asn1/tasn_dec.c
+--- openssl-1.0.2k/crypto/asn1/tasn_dec.c.null-dereference 2020-12-04 10:12:42.036057323 +0100
++++ openssl-1.0.2k/crypto/asn1/tasn_dec.c 2020-12-04 10:17:45.685035333 +0100
+@@ -223,6 +223,15 @@ static int asn1_item_ex_d2i(ASN1_VALUE *
+ break;
+
+ case ASN1_ITYPE_MSTRING:
++ /*
++ * It never makes sense for multi-strings to have implicit tagging, so
++ * if tag != -1, then this looks like an error in the template.
++ */
++ if (tag != -1) {
++ ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_BAD_TEMPLATE);
++ goto err;
++ }
++
+ p = *in;
+ /* Just read in tag and class */
+ ret = asn1_check_tlen(NULL, &otag, &oclass, NULL, NULL,
+@@ -240,6 +249,7 @@ static int asn1_item_ex_d2i(ASN1_VALUE *
+ ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_MSTRING_NOT_UNIVERSAL);
+ goto err;
+ }
++
+ /* Check tag matches bit map */
+ if (!(ASN1_tag2bit(otag) & it->utype)) {
+ /* If OPTIONAL, assume this is OK */
+@@ -316,6 +326,15 @@ static int asn1_item_ex_d2i(ASN1_VALUE *
+ goto err;
+
+ case ASN1_ITYPE_CHOICE:
++ /*
++ * It never makes sense for CHOICE types to have implicit tagging, so
++ * if tag != -1, then this looks like an error in the template.
++ */
++ if (tag != -1) {
++ ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_BAD_TEMPLATE);
++ goto err;
++ }
++
+ if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL))
+ goto auxerr;
+ if (*pval) {
+diff -up openssl-1.0.2k/crypto/asn1/tasn_enc.c.null-dereference openssl-1.0.2k/crypto/asn1/tasn_enc.c
+--- openssl-1.0.2k/crypto/asn1/tasn_enc.c.null-dereference 2020-12-04 10:18:30.261472002 +0100
++++ openssl-1.0.2k/crypto/asn1/tasn_enc.c 2020-12-04 10:21:14.310078987 +0100
+@@ -151,9 +151,25 @@ int ASN1_item_ex_i2d(ASN1_VALUE **pval,
+ break;
+
+ case ASN1_ITYPE_MSTRING:
++ /*
++ * It never makes sense for multi-strings to have implicit tagging, so
++ * if tag != -1, then this looks like an error in the template.
++ */
++ if (tag != -1) {
++ ASN1err(ASN1_F_ASN1_ITEM_EX_I2D, ASN1_R_BAD_TEMPLATE);
++ return -1;
++ }
+ return asn1_i2d_ex_primitive(pval, out, it, -1, aclass);
+
+ case ASN1_ITYPE_CHOICE:
++ /*
++ * It never makes sense for CHOICE types to have implicit tagging, so
++ * if tag != -1, then this looks like an error in the template.
++ */
++ if (tag != -1) {
++ ASN1err(ASN1_F_ASN1_ITEM_EX_I2D, ASN1_R_BAD_TEMPLATE);
++ return -1;
++ }
+ if (asn1_cb && !asn1_cb(ASN1_OP_I2D_PRE, pval, it, NULL))
+ return 0;
+ i = asn1_get_choice_selector(pval, it);
+diff -up openssl-1.0.2k/crypto/x509v3/v3_genn.c.null-dereference openssl-1.0.2k/crypto/x509v3/v3_genn.c
+--- openssl-1.0.2k/crypto/x509v3/v3_genn.c.null-dereference 2020-12-04 10:28:02.374237945 +0100
++++ openssl-1.0.2k/crypto/x509v3/v3_genn.c 2020-12-04 10:36:51.156138263 +0100
+@@ -72,8 +72,9 @@ ASN1_SEQUENCE(OTHERNAME) = {
+ IMPLEMENT_ASN1_FUNCTIONS(OTHERNAME)
+
+ ASN1_SEQUENCE(EDIPARTYNAME) = {
+- ASN1_IMP_OPT(EDIPARTYNAME, nameAssigner, DIRECTORYSTRING, 0),
+- ASN1_IMP_OPT(EDIPARTYNAME, partyName, DIRECTORYSTRING, 1)
++ /* DirectoryString is a CHOICE type so use explicit tagging */
++ ASN1_EXP_OPT(EDIPARTYNAME, nameAssigner, DIRECTORYSTRING, 0),
++ ASN1_EXP(EDIPARTYNAME, partyName, DIRECTORYSTRING, 1)
+ } ASN1_SEQUENCE_END(EDIPARTYNAME)
+
+ IMPLEMENT_ASN1_FUNCTIONS(EDIPARTYNAME)
+@@ -107,6 +108,37 @@ GENERAL_NAME *GENERAL_NAME_dup(GENERAL_N
+ (char *)a);
+ }
+
++static int edipartyname_cmp(const EDIPARTYNAME *a, const EDIPARTYNAME *b)
++{
++ int res;
++
++ if (a == NULL || b == NULL) {
++ /*
++ * Shouldn't be possible in a valid GENERAL_NAME, but we handle it
++ * anyway. OTHERNAME_cmp treats NULL != NULL so we do the same here
++ */
++ return -1;
++ }
++ if (a->nameAssigner == NULL && b->nameAssigner != NULL)
++ return -1;
++ if (a->nameAssigner != NULL && b->nameAssigner == NULL)
++ return 1;
++ /* If we get here then both have nameAssigner set, or both unset */
++ if (a->nameAssigner != NULL) {
++ res = ASN1_STRING_cmp(a->nameAssigner, b->nameAssigner);
++ if (res != 0)
++ return res;
++ }
++ /*
++ * partyName is required, so these should never be NULL. We treat it in
++ * the same way as the a == NULL || b == NULL case above
++ */
++ if (a->partyName == NULL || b->partyName == NULL)
++ return -1;
++
++ return ASN1_STRING_cmp(a->partyName, b->partyName);
++}
++
+ /* Returns 0 if they are equal, != 0 otherwise. */
+ int GENERAL_NAME_cmp(GENERAL_NAME *a, GENERAL_NAME *b)
+ {
+@@ -116,8 +148,11 @@ int GENERAL_NAME_cmp(GENERAL_NAME *a, GE
+ return -1;
+ switch (a->type) {
+ case GEN_X400:
++ result = ASN1_TYPE_cmp(a->d.x400Address, b->d.x400Address);
++ break;
++
+ case GEN_EDIPARTY:
+- result = ASN1_TYPE_cmp(a->d.other, b->d.other);
++ result = edipartyname_cmp(a->d.ediPartyName, b->d.ediPartyName);
+ break;
+
+ case GEN_OTHERNAME:
+@@ -164,8 +199,11 @@ void GENERAL_NAME_set0_value(GENERAL_NAM
+ {
+ switch (type) {
+ case GEN_X400:
++ a->d.x400Address = value;
++ break;
++
+ case GEN_EDIPARTY:
+- a->d.other = value;
++ a->d.ediPartyName = value;
+ break;
+
+ case GEN_OTHERNAME:
+@@ -199,8 +237,10 @@ void *GENERAL_NAME_get0_value(GENERAL_NA
+ *ptype = a->type;
+ switch (a->type) {
+ case GEN_X400:
++ return a->d.x400Address;
++
+ case GEN_EDIPARTY:
+- return a->d.other;
++ return a->d.ediPartyName;
+
+ case GEN_OTHERNAME:
+ return a->d.otherName;
+diff -up openssl-1.0.2k/crypto/x509v3/v3nametest.c.null-dereference openssl-1.0.2k/crypto/x509v3/v3nametest.c
+--- openssl-1.0.2k/crypto/x509v3/v3nametest.c.null-dereference 2020-12-04 10:28:02.374237945 +0100
++++ openssl-1.0.2k/crypto/x509v3/v3nametest.c 2020-12-04 10:36:51.156138263 +0100
+@@ -321,6 +321,356 @@ static void run_cert(X509 *crt, const ch
+ }
+ }
+
++struct gennamedata {
++ const unsigned char der[22];
++ size_t derlen;
++} gennames[] = {
++ {
++ /*
++ * [0] {
++ * OBJECT_IDENTIFIER { 1.2.840.113554.4.1.72585.2.1 }
++ * [0] {
++ * SEQUENCE {}
++ * }
++ * }
++ */
++ {
++ 0xa0, 0x13, 0x06, 0x0d, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x04,
++ 0x01, 0x84, 0xb7, 0x09, 0x02, 0x01, 0xa0, 0x02, 0x30, 0x00
++ },
++ 21
++ }, {
++ /*
++ * [0] {
++ * OBJECT_IDENTIFIER { 1.2.840.113554.4.1.72585.2.1 }
++ * [0] {
++ * [APPLICATION 0] {}
++ * }
++ * }
++ */
++ {
++ 0xa0, 0x13, 0x06, 0x0d, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x04,
++ 0x01, 0x84, 0xb7, 0x09, 0x02, 0x01, 0xa0, 0x02, 0x60, 0x00
++ },
++ 21
++ }, {
++ /*
++ * [0] {
++ * OBJECT_IDENTIFIER { 1.2.840.113554.4.1.72585.2.1 }
++ * [0] {
++ * UTF8String { "a" }
++ * }
++ * }
++ */
++ {
++ 0xa0, 0x14, 0x06, 0x0d, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x04,
++ 0x01, 0x84, 0xb7, 0x09, 0x02, 0x01, 0xa0, 0x03, 0x0c, 0x01, 0x61
++ },
++ 22
++ }, {
++ /*
++ * [0] {
++ * OBJECT_IDENTIFIER { 1.2.840.113554.4.1.72585.2.2 }
++ * [0] {
++ * UTF8String { "a" }
++ * }
++ * }
++ */
++ {
++ 0xa0, 0x14, 0x06, 0x0d, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x04,
++ 0x01, 0x84, 0xb7, 0x09, 0x02, 0x02, 0xa0, 0x03, 0x0c, 0x01, 0x61
++ },
++ 22
++ }, {
++ /*
++ * [0] {
++ * OBJECT_IDENTIFIER { 1.2.840.113554.4.1.72585.2.1 }
++ * [0] {
++ * UTF8String { "b" }
++ * }
++ * }
++ */
++ {
++ 0xa0, 0x14, 0x06, 0x0d, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x04,
++ 0x01, 0x84, 0xb7, 0x09, 0x02, 0x01, 0xa0, 0x03, 0x0c, 0x01, 0x62
++ },
++ 22
++ }, {
++ /*
++ * [0] {
++ * OBJECT_IDENTIFIER { 1.2.840.113554.4.1.72585.2.1 }
++ * [0] {
++ * BOOLEAN { TRUE }
++ * }
++ * }
++ */
++ {
++ 0xa0, 0x14, 0x06, 0x0d, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x04,
++ 0x01, 0x84, 0xb7, 0x09, 0x02, 0x01, 0xa0, 0x03, 0x01, 0x01, 0xff
++ },
++ 22
++ }, {
++ /*
++ * [0] {
++ * OBJECT_IDENTIFIER { 1.2.840.113554.4.1.72585.2.1 }
++ * [0] {
++ * BOOLEAN { FALSE }
++ * }
++ * }
++ */
++ {
++ 0xa0, 0x14, 0x06, 0x0d, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x04,
++ 0x01, 0x84, 0xb7, 0x09, 0x02, 0x01, 0xa0, 0x03, 0x01, 0x01, 0x00
++ },
++ 22
++ }, {
++ /* [1 PRIMITIVE] { "a" } */
++ {
++ 0x81, 0x01, 0x61
++ },
++ 3
++ }, {
++ /* [1 PRIMITIVE] { "b" } */
++ {
++ 0x81, 0x01, 0x62
++ },
++ 3
++ }, {
++ /* [2 PRIMITIVE] { "a" } */
++ {
++ 0x82, 0x01, 0x61
++ },
++ 3
++ }, {
++ /* [2 PRIMITIVE] { "b" } */
++ {
++ 0x82, 0x01, 0x62
++ },
++ 3
++ }, {
++ /*
++ * [4] {
++ * SEQUENCE {
++ * SET {
++ * SEQUENCE {
++ * # commonName
++ * OBJECT_IDENTIFIER { 2.5.4.3 }
++ * UTF8String { "a" }
++ * }
++ * }
++ * }
++ * }
++ */
++ {
++ 0xa4, 0x0e, 0x30, 0x0c, 0x31, 0x0a, 0x30, 0x08, 0x06, 0x03, 0x55,
++ 0x04, 0x03, 0x0c, 0x01, 0x61
++ },
++ 16
++ }, {
++ /*
++ * [4] {
++ * SEQUENCE {
++ * SET {
++ * SEQUENCE {
++ * # commonName
++ * OBJECT_IDENTIFIER { 2.5.4.3 }
++ * UTF8String { "b" }
++ * }
++ * }
++ * }
++ * }
++ */
++ {
++ 0xa4, 0x0e, 0x30, 0x0c, 0x31, 0x0a, 0x30, 0x08, 0x06, 0x03, 0x55,
++ 0x04, 0x03, 0x0c, 0x01, 0x62
++ },
++ 16
++ }, {
++ /*
++ * [5] {
++ * [1] {
++ * UTF8String { "a" }
++ * }
++ * }
++ */
++ {
++ 0xa5, 0x05, 0xa1, 0x03, 0x0c, 0x01, 0x61
++ },
++ 7
++ }, {
++ /*
++ * [5] {
++ * [1] {
++ * UTF8String { "b" }
++ * }
++ * }
++ */
++ {
++ 0xa5, 0x05, 0xa1, 0x03, 0x0c, 0x01, 0x62
++ },
++ 7
++ }, {
++ /*
++ * [5] {
++ * [0] {
++ * UTF8String {}
++ * }
++ * [1] {
++ * UTF8String { "a" }
++ * }
++ * }
++ */
++ {
++ 0xa5, 0x09, 0xa0, 0x02, 0x0c, 0x00, 0xa1, 0x03, 0x0c, 0x01, 0x61
++ },
++ 11
++ }, {
++ /*
++ * [5] {
++ * [0] {
++ * UTF8String { "a" }
++ * }
++ * [1] {
++ * UTF8String { "a" }
++ * }
++ * }
++ */
++ {
++ 0xa5, 0x0a, 0xa0, 0x03, 0x0c, 0x01, 0x61, 0xa1, 0x03, 0x0c, 0x01,
++ 0x61
++ },
++ 12
++ }, {
++ /*
++ * [5] {
++ * [0] {
++ * UTF8String { "b" }
++ * }
++ * [1] {
++ * UTF8String { "a" }
++ * }
++ * }
++ */
++ {
++ 0xa5, 0x0a, 0xa0, 0x03, 0x0c, 0x01, 0x62, 0xa1, 0x03, 0x0c, 0x01,
++ 0x61
++ },
++ 12
++ }, {
++ /* [6 PRIMITIVE] { "a" } */
++ {
++ 0x86, 0x01, 0x61
++ },
++ 3
++ }, {
++ /* [6 PRIMITIVE] { "b" } */
++ {
++ 0x86, 0x01, 0x62
++ },
++ 3
++ }, {
++ /* [7 PRIMITIVE] { `11111111` } */
++ {
++ 0x87, 0x04, 0x11, 0x11, 0x11, 0x11
++ },
++ 6
++ }, {
++ /* [7 PRIMITIVE] { `22222222`} */
++ {
++ 0x87, 0x04, 0x22, 0x22, 0x22, 0x22
++ },
++ 6
++ }, {
++ /* [7 PRIMITIVE] { `11111111111111111111111111111111` } */
++ {
++ 0x87, 0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
++ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11
++ },
++ 18
++ }, {
++ /* [7 PRIMITIVE] { `22222222222222222222222222222222` } */
++ {
++ 0x87, 0x10, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
++ 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22
++ },
++ 18
++ }, {
++ /* [8 PRIMITIVE] { 1.2.840.113554.4.1.72585.2.1 } */
++ {
++ 0x88, 0x0d, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x04, 0x01, 0x84,
++ 0xb7, 0x09, 0x02, 0x01
++ },
++ 15
++ }, {
++ /* [8 PRIMITIVE] { 1.2.840.113554.4.1.72585.2.2 } */
++ {
++ 0x88, 0x0d, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x04, 0x01, 0x84,
++ 0xb7, 0x09, 0x02, 0x02
++ },
++ 15
++ }
++};
++
++#define OSSL_NELEM(x) (sizeof(x)/sizeof((x)[0]))
++
++static int test_GENERAL_NAME_cmp(void)
++{
++ size_t i, j;
++ GENERAL_NAME **namesa = OPENSSL_malloc(sizeof(*namesa)
++ * OSSL_NELEM(gennames));
++ GENERAL_NAME **namesb = OPENSSL_malloc(sizeof(*namesb)
++ * OSSL_NELEM(gennames));
++ int testresult = 0;
++
++ if (namesa == NULL || namesb == NULL)
++ goto end;
++
++ for (i = 0; i < OSSL_NELEM(gennames); i++) {
++ const unsigned char *derp = gennames[i].der;
++
++ /*
++ * We create two versions of each GENERAL_NAME so that we ensure when
++ * we compare them they are always different pointers.
++ */
++ namesa[i] = d2i_GENERAL_NAME(NULL, &derp, gennames[i].derlen);
++ derp = gennames[i].der;
++ namesb[i] = d2i_GENERAL_NAME(NULL, &derp, gennames[i].derlen);
++ if (namesa[i] == NULL || namesb[i] == NULL)
++ goto end;
++ }
++
++ /* Every name should be equal to itself and not equal to any others. */
++ for (i = 0; i < OSSL_NELEM(gennames); i++) {
++ for (j = 0; j < OSSL_NELEM(gennames); j++) {
++ if (i == j) {
++ if (GENERAL_NAME_cmp(namesa[i], namesb[j]) != 0)
++ goto end;
++ } else {
++ if (GENERAL_NAME_cmp(namesa[i], namesb[j]) == 0)
++ goto end;
++ }
++ }
++ }
++ testresult = 1;
++
++ end:
++ for (i = 0; i < OSSL_NELEM(gennames); i++) {
++ if (namesa != NULL)
++ GENERAL_NAME_free(namesa[i]);
++ if (namesb != NULL)
++ GENERAL_NAME_free(namesb[i]);
++ }
++ OPENSSL_free(namesa);
++ OPENSSL_free(namesb);
++
++ if (!testresult)
++ fprintf(stderr, "test of GENERAL_NAME_cmp failed\n");
++
++ return testresult;
++}
++
++
++
+ int main(void)
+ {
+ const struct set_name_fn *pfn = name_fns;
+@@ -342,5 +692,8 @@ int main(void)
+ }
+ ++pfn;
+ }
++
++ errors += !test_GENERAL_NAME_cmp();
++
+ return errors > 0 ? 1 : 0;
+ }
More information about the Libreoffice-commits
mailing list