libexif: fix CVE-2016-6328 and CVE-2018-20030

(From OE-Core rev: 037b544431076b94e85281c7deb527a44a600f5a)

Signed-off-by: Ross Burton <ross.burton@intel.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>

3 files changed, 182 insertions, 1 deletions

diff --git a/meta/recipes-support/libexif/libexif/CVE-2016-6328.patch b/meta/recipes-support/libexif/libexif/CVE-2016-6328.patch
new file mode 100644
index 0000000000..a6f307439b
--- /dev/null
+++ b/meta/recipes-support/libexif/libexif/CVE-2016-6328.patch
@@ -0,0 +1,64 @@
+CVE: CVE-2016-6328
+Upstream-Status: Backport
+Signed-off-by: Ross Burton <ross.burton@intel.com>
+
+From 41bd04234b104312f54d25822f68738ba8d7133d Mon Sep 17 00:00:00 2001
+From: Marcus Meissner <marcus@jet.franken.de>
+Date: Tue, 25 Jul 2017 23:44:44 +0200
+Subject: [PATCH] fixes some (not all) buffer overreads during decoding pentax
+ makernote entries.
+
+This should fix:
+https://sourceforge.net/p/libexif/bugs/125/ CVE-2016-6328
+---
+ libexif/pentax/mnote-pentax-entry.c | 16 +++++++++++++---
+ 1 file changed, 13 insertions(+), 3 deletions(-)
+
+diff --git a/libexif/pentax/mnote-pentax-entry.c b/libexif/pentax/mnote-pentax-entry.c
+index d03d159..ea0429a 100644
+--- a/libexif/pentax/mnote-pentax-entry.c
++++ b/libexif/pentax/mnote-pentax-entry.c
+@@ -425,24 +425,34 @@ mnote_pentax_entry_get_value (MnotePentaxEntry *entry,
+                case EXIF_FORMAT_SHORT:
+                  {
+                        const unsigned char *data = entry->data;
+-                       size_t k, len = strlen(val);
++                       size_t k, len = strlen(val), sizeleft;
++
++                       sizeleft = entry->size;
+                        for(k=0; k<entry->components; k++) {
++                               if (sizeleft < 2)
++                                       break;
+                                vs = exif_get_short (data, entry->order);
+                                snprintf (val+len, maxlen-len, "%i ", vs);
+                                len = strlen(val);
+                                data += 2;
++                               sizeleft -= 2;
+                        }
+                  }
+                  break;
+                case EXIF_FORMAT_LONG:
+                  {
+                        const unsigned char *data = entry->data;
+-                       size_t k, len = strlen(val);
++                       size_t k, len = strlen(val), sizeleft;
++
++                       sizeleft = entry->size;
+                        for(k=0; k<entry->components; k++) {
++                               if (sizeleft < 4)
++                                       break;
+                                vl = exif_get_long (data, entry->order);
+                                snprintf (val+len, maxlen-len, "%li", (long int) vl);
+                                len = strlen(val);
+                                data += 4;
++                               sizeleft -= 4;
+                        }
+                  }
+                  break;
+@@ -455,5 +465,5 @@ mnote_pentax_entry_get_value (MnotePentaxEntry *entry,
+                break;
+        }
+ 
+-       return (val);
++       return val;
+ }
diff --git a/meta/recipes-support/libexif/libexif/CVE-2018-20030.patch b/meta/recipes-support/libexif/libexif/CVE-2018-20030.patch
new file mode 100644
index 0000000000..76233e6dc9
--- /dev/null
+++ b/meta/recipes-support/libexif/libexif/CVE-2018-20030.patch
@@ -0,0 +1,115 @@
+CVE: CVE-2018-20030
+Upstream-Status: Backport
+Signed-off-by: Ross Burton <ross.burton@intel.com>
+
+From 6aa11df549114ebda520dde4cdaea2f9357b2c89 Mon Sep 17 00:00:00 2001
+From: Dan Fandrich <dan@coneharvesters.com>
+Date: Fri, 12 Oct 2018 16:01:45 +0200
+Subject: [PATCH] Improve deep recursion detection in
+ exif_data_load_data_content.
+
+The existing detection was still vulnerable to pathological cases
+causing DoS by wasting CPU. The new algorithm takes the number of tags
+into account to make it harder to abuse by cases using shallow recursion
+but with a very large number of tags.  This improves on commit 5d28011c
+which wasn't sufficient to counter this kind of case.
+
+The limitation in the previous fix was discovered by Laurent Delosieres,
+Secunia Research at Flexera (Secunia Advisory SA84652) and is assigned
+the identifier CVE-2018-20030.
+
+diff --git a/libexif/exif-data.c b/libexif/exif-data.c
+index 67df4db..8d9897e 100644
+--- a/libexif/exif-data.c
++++ b/libexif/exif-data.c
+@@ -35,6 +35,7 @@
+ #include <libexif/olympus/exif-mnote-data-olympus.h>
+ #include <libexif/pentax/exif-mnote-data-pentax.h>
+ 
++#include <math.h>
+ #include <stdlib.h>
+ #include <stdio.h>
+ #include <string.h>
+@@ -344,6 +345,20 @@ if (data->ifd[(i)]->count) {                               \
+        break;                                          \
+ }
+ 
++/*! Calculate the recursion cost added by one level of IFD loading.
++ *
++ * The work performed is related to the cost in the exponential relation
++ *   work=1.1**cost
++ */
++static unsigned int
++level_cost(unsigned int n)
++{
++    static const double log_1_1 = 0.09531017980432493;
++
++       /* Adding 0.1 protects against the case where n==1 */
++       return ceil(log(n + 0.1)/log_1_1);
++}
++
+ /*! Load data for an IFD.
+  *
+  * \param[in,out] data #ExifData
+@@ -351,13 +366,13 @@ if (data->ifd[(i)]->count) {                              \
+  * \param[in] d pointer to buffer containing raw IFD data
+  * \param[in] ds size of raw data in buffer at \c d
+  * \param[in] offset offset into buffer at \c d at which IFD starts
+- * \param[in] recursion_depth number of times this function has been
+- * recursively called without returning
++ * \param[in] recursion_cost factor indicating how expensive this recursive
++ * call could be
+  */
+ static void
+ exif_data_load_data_content (ExifData *data, ExifIfd ifd,
+                             const unsigned char *d,
+-                            unsigned int ds, unsigned int offset, unsigned int recursion_depth)
++                            unsigned int ds, unsigned int offset, unsigned int recursion_cost)
+ {
+        ExifLong o, thumbnail_offset = 0, thumbnail_length = 0;
+        ExifShort n;
+@@ -372,9 +387,20 @@ exif_data_load_data_content (ExifData *data, ExifIfd ifd,
+        if ((((int)ifd) < 0) || ( ((int)ifd) >= EXIF_IFD_COUNT))
+          return;
+ 
+-       if (recursion_depth > 30) {
++       if (recursion_cost > 170) {
++               /*
++                * recursion_cost is a logarithmic-scale indicator of how expensive this
++                * recursive call might end up being. It is an indicator of the depth of
++                * recursion as well as the potential for worst-case future recursive
++                * calls. Since it's difficult to tell ahead of time how often recursion
++                * will occur, this assumes the worst by assuming every tag could end up
++                * causing recursion.
++                * The value of 170 was chosen to limit typical EXIF structures to a
++                * recursive depth of about 6, but pathological ones (those with very
++                * many tags) to only 2.
++                */
+                exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
+-                         "Deep recursion detected!");
++                         "Deep/expensive recursion detected!");
+                return;
+        }
+ 
+@@ -416,15 +442,18 @@ exif_data_load_data_content (ExifData *data, ExifIfd ifd,
+                        switch (tag) {
+                        case EXIF_TAG_EXIF_IFD_POINTER:
+                                CHECK_REC (EXIF_IFD_EXIF);
+-                               exif_data_load_data_content (data, EXIF_IFD_EXIF, d, ds, o, recursion_depth + 1);
++                               exif_data_load_data_content (data, EXIF_IFD_EXIF, d, ds, o,
++                                       recursion_cost + level_cost(n));
+                                break;
+                        case EXIF_TAG_GPS_INFO_IFD_POINTER:
+                                CHECK_REC (EXIF_IFD_GPS);
+-                               exif_data_load_data_content (data, EXIF_IFD_GPS, d, ds, o, recursion_depth + 1);
++                               exif_data_load_data_content (data, EXIF_IFD_GPS, d, ds, o,
++                                       recursion_cost + level_cost(n));
+                                break;
+                        case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
+                                CHECK_REC (EXIF_IFD_INTEROPERABILITY);
+-                               exif_data_load_data_content (data, EXIF_IFD_INTEROPERABILITY, d, ds, o, recursion_depth + 1);
++                               exif_data_load_data_content (data, EXIF_IFD_INTEROPERABILITY, d, ds, o,
++                                       recursion_cost + level_cost(n));
+                                break;
+                        case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
+                                thumbnail_offset = o;
diff --git a/meta/recipes-support/libexif/libexif_0.6.21.bb b/meta/recipes-support/libexif/libexif_0.6.21.bb
index a6c9c647c8..d847beab18 100644
--- a/meta/recipes-support/libexif/libexif_0.6.21.bb
+++ b/meta/recipes-support/libexif/libexif_0.6.21.bb
@@ -5,7 +5,9 @@ LICENSE = "LGPLv2.1"
 LIC_FILES_CHKSUM = "file://COPYING;md5=243b725d71bb5df4a1e5920b344b86ad"
 
 SRC_URI = "${SOURCEFORGE_MIRROR}/libexif/libexif-${PV}.tar.bz2 \
-           file://CVE-2017-7544.patch"
+           file://CVE-2017-7544.patch \
+           file://CVE-2016-6328.patch \
+           file://CVE-2018-20030.patch"
 
 SRC_URI[md5sum] = "27339b89850f28c8f1c237f233e05b27"
 SRC_URI[sha256sum] = "16cdaeb62eb3e6dfab2435f7d7bccd2f37438d21c5218ec4e58efa9157d4d41a"