Throw an exception if trying to write a JPEG APP1 segment that's too large

jpeg_with_full_app_segment.jpg is an image taken with a Samsung A32
with a nearly-full APP1 segment due to a 64,000 byte thumbnail:

$ exiftool -v3 jpeg_with_exif_full_app1_segment.jpg
<snip>
JPEG APP1 (65072 bytes):
<snip>
  | 5)  ThumbnailLength = 64000

Bug: 263747161
Test: ./gradlew :exifinterface:exifinterface:connectedAndroidTest

Change-Id: Id421cd36d974ad4f29a2c6d6c730d99d8986d917

Author: icbaker

exifinterface/exifinterface/build.gradle

@@ -9,6 +9,7 @@ dependencies {
     implementation("androidx.annotation:annotation:1.2.0")
 
     androidTestImplementation(libs.testExtJunit)
+    androidTestImplementation(libs.testExtTruth)
     androidTestImplementation(libs.testCore)
     androidTestImplementation(libs.testRunner)
     androidTestImplementation(libs.testRules)

exifinterface/exifinterface/src/androidTest/java/androidx/exifinterface/media/ExifInterfaceTest.java

@@ -18,10 +18,13 @@
 
 import static androidx.test.core.app.ApplicationProvider.getApplicationContext;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
@@ -64,6 +67,7 @@
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Objects;
 import java.util.Random;
@@ -88,6 +92,8 @@ public class ExifInterfaceTest {
     private static final String JPEG_WITH_EXIF_BYTE_ORDER_II = "jpeg_with_exif_byte_order_ii.jpg";
     private static final String JPEG_WITH_EXIF_BYTE_ORDER_MM = "jpeg_with_exif_byte_order_mm.jpg";
     private static final String JPEG_WITH_EXIF_INVALID_OFFSET = "jpeg_with_exif_invalid_offset.jpg";
+    private static final String JPEG_WITH_EXIF_FULL_APP1_SEGMENT =
+            "jpeg_with_exif_full_app1_segment.jpg";
 
     private static final String DNG_WITH_EXIF_WITH_XMP = "dng_with_exif_with_xmp.dng";
     private static final String JPEG_WITH_EXIF_WITH_XMP = "jpeg_with_exif_with_xmp.jpg";
@@ -110,6 +116,7 @@ public class ExifInterfaceTest {
             R.raw.jpeg_with_exif_byte_order_ii,
             R.raw.jpeg_with_exif_byte_order_mm,
             R.raw.jpeg_with_exif_invalid_offset,
+            R.raw.jpeg_with_exif_full_app1_segment,
             R.raw.dng_with_exif_with_xmp,
             R.raw.jpeg_with_exif_with_xmp,
             R.raw.png_with_exif_byte_order_ii,
@@ -126,6 +133,7 @@ public class ExifInterfaceTest {
             JPEG_WITH_EXIF_BYTE_ORDER_II,
             JPEG_WITH_EXIF_BYTE_ORDER_MM,
             JPEG_WITH_EXIF_INVALID_OFFSET,
+            JPEG_WITH_EXIF_FULL_APP1_SEGMENT,
             DNG_WITH_EXIF_WITH_XMP,
             JPEG_WITH_EXIF_WITH_XMP,
             PNG_WITH_EXIF_BYTE_ORDER_II,
@@ -466,6 +474,28 @@ public void testJpegWithInvalidOffset() throws Throwable {
         writeToFilesWithExif(JPEG_WITH_EXIF_INVALID_OFFSET, R.array.jpeg_with_exif_invalid_offset);
     }
 
+    // https://issuetracker.google.com/263747161
+    @Test
+    @LargeTest
+    public void testJpegWithFullApp1Segment() throws Throwable {
+        File srcFile = getFileFromExternalDir(JPEG_WITH_EXIF_FULL_APP1_SEGMENT);
+        File imageFile = clone(srcFile);
+        ExifInterface exifInterface = new ExifInterface(imageFile.getAbsolutePath());
+        // Add a really long string that makes the Exif data too large for the JPEG APP1 segment.
+        char[] longStringChars = new char[500];
+        Arrays.fill(longStringChars, 'a');
+        String longString = new String(longStringChars);
+        exifInterface.setAttribute(ExifInterface.TAG_MAKE, longString);
+
+        IOException expected = assertThrows(IOException.class,
+                exifInterface::saveAttributes);
+        assertThat(expected)
+                .hasCauseThat()
+                .hasMessageThat()
+                .contains("exceeds the max size of a JPEG APP1 segment");
+        assertBitmapsEquivalent(srcFile, imageFile);
+    }
+
     @Test
     @LargeTest
     public void testDngWithExifAndXmp() throws Throwable {

exifinterface/exifinterface/src/androidTest/res/raw/jpeg_with_exif_full_app1_segment.jpg

@@ -7483,6 +7483,11 @@ private int writeExifSegment(ByteOrderedDataOutputStream dataOutputStream) throw
 
         switch (mMimeType) {
             case IMAGE_TYPE_JPEG:
+                if (totalSize > 0xFFFF) {
+                    throw new IllegalStateException(
+                            "Size of exif data (" + totalSize + " bytes) exceeds the max size of a "
+                            + "JPEG APP1 segment (65536 bytes)");
+                }
                 // Write JPEG specific data (APP1 size, APP1 identifier)
                 dataOutputStream.writeUnsignedShort(totalSize);
                 dataOutputStream.write(IDENTIFIER_EXIF_APP1);
@@ -8015,10 +8020,18 @@ public void writeInt(int val) throws IOException {
         }
 
         public void writeUnsignedShort(int val) throws IOException {
+            if (val > 0xFFFF) {
+                throw new IllegalArgumentException("val is larger than the maximum value of a "
+                        + "16-bit unsigned integer");
+            }
             writeShort((short) val);
         }
 
         public void writeUnsignedInt(long val) throws IOException {
+            if (val > 0xFFFF_FFFFL) {
+                throw new IllegalArgumentException("val is larger than the maximum value of a "
+                        + "32-bit unsigned integer");
+            }
             writeInt((int) val);
         }
     }