diff --git a/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/ExifMarkerSegment.java b/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/ExifMarkerSegment.java
new file mode 100644
index 0000000000000..479de42d96fba
--- /dev/null
+++ b/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/ExifMarkerSegment.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.sun.imageio.plugins.jpeg;
+
+import com.sun.imageio.plugins.tiff.TIFFImageReader;
+
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReader;
+import javax.imageio.stream.ImageInputStream;
+import javax.imageio.stream.MemoryCacheImageInputStream;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * An Exif (Exchangeable Image File Format) APP1 (Application-Specific)
+ * marker segment. This implementation only supports reading thumbnails
+ * and the image creation time.
+ */
+class ExifMarkerSegment extends MarkerSegment {
+
+    static class ImageFileDirectory implements Cloneable {
+        static class Entry implements Cloneable {
+            final int tagNumber, dataFormat;
+            final long componentCount, fieldValue;
+
+            Entry(ImageInputStream in) throws IOException {
+                tagNumber = in.readUnsignedShort();
+                dataFormat = in.readUnsignedShort();
+                componentCount = in.readUnsignedInt();
+                fieldValue = in.readUnsignedInt();
+            }
+
+            @Override
+            public String toString() {
+                return "Entry[ tagNumber: " + tagNumber +
+                        ", dataFormat: " + dataFormat +
+                        ", componentCount: " + componentCount +
+                        ", fieldValue: " + fieldValue + "]";
+            }
+        }
+        static final int[] bytesPerComponent = new int[] {1, 1, 1, 2, 4, 8, 1};
+
+        Map<Integer, Entry> entriesByTag = new LinkedHashMap<>();
+        long nextIFD;
+
+        ImageFileDirectory(ImageInputStream in, long pos) throws IOException {
+            in.seek(pos);
+            int entryCount = in.readUnsignedShort();
+            for (int a = 0; a < entryCount; a++) {
+                Entry e = new Entry(in);
+                entriesByTag.put(e.tagNumber, e);
+            }
+
+            // The next 4 bytes SHOULD be the position of the next IFD.
+
+            // However in rare cases: the position of the next IFD header is missing. We can detect
+            // this by checking to see if any of the IFD entries we just read appear where the
+            // next IFD position *should* be:
+
+            long streamPos = in.getStreamPosition();
+            for (Entry e : entriesByTag.values()) {
+                int byteLength = e.dataFormat < bytesPerComponent.length ?
+                        (int) (e.componentCount * bytesPerComponent[e.dataFormat]) :
+                        // this is an unknown data format, so let's just assume its 1 byte
+                        1;
+                if (byteLength > 4) {
+                    long valuePos = e.fieldValue;
+                    if (valuePos <= streamPos) {
+                        nextIFD = 0;
+                        return;
+                    }
+                }
+            }
+
+            nextIFD = in.readUnsignedInt();
+        }
+
+        int getTagValueAsInt(int tagID) {
+            ImageFileDirectory.Entry e = entriesByTag.get(tagID);
+            if (e == null) {
+                return NO_VALUE;
+            }
+            return (int) e.fieldValue;
+        }
+    }
+
+    private static final int NO_VALUE = -1;
+
+    private static final int TIFF_BIG_ENDIAN = 0x4d4d;
+    private static final int TIFF_MAGIC = 42;
+    private static final int TIFF_TYPE_SHORT = 3;
+    private static final int TAG_IMAGE_WIDTH = 256;
+    private static final int TAG_IMAGE_HEIGHT = 257;
+    private static final int TAG_DATE_TIME = 306;
+    private static final int TAG_JPEG_INTERCHANGE_FORMAT = 513;
+    private static final int TAG_JPEG_INTERCHANGE_FORMAT_LENGTH = 514;
+
+    int thumbnailPos = -1;
+    int thumbnailLength = -1;
+    boolean isThumbnailJPEG;
+
+    int thumbnailWidth = -1;
+    int thumbnailHeight = -1;
+
+    final long firstIFDOffset;
+    final List<ImageFileDirectory> imageFileDirectories = new LinkedList<>();
+
+    ExifMarkerSegment(MarkerSegment originalSegment) throws IOException {
+        super(originalSegment.tag);
+        this.length = originalSegment.length;
+        this.data = originalSegment.data;
+
+        ByteArrayInputStream in = new ByteArrayInputStream(data, 6, data.length - 6);
+
+        // we aren't actually going to read anything as an image yet, but ImageInputStream
+        // has useful helper methods:
+        ImageInputStream input = new MemoryCacheImageInputStream(in);
+        input.setByteOrder(input.readUnsignedShort() == TIFF_BIG_ENDIAN ?
+                ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN);
+        if (input.readUnsignedShort() != TIFF_MAGIC) {
+            throw new IllegalArgumentException("Bad magic number");
+        }
+
+        firstIFDOffset = input.readUnsignedInt();
+        ImageFileDirectory ifd1 = null;
+        ImageFileDirectory ifd2 = null;
+        if (firstIFDOffset != 0) {
+            ifd1 = new ImageFileDirectory(input, firstIFDOffset);
+            imageFileDirectories.add(ifd1);
+
+            long secondIFDOffset = ifd1.nextIFD;
+            if (secondIFDOffset != 0) {
+                ifd2 = new ImageFileDirectory(input, secondIFDOffset);
+                imageFileDirectories.add(ifd2);
+            }
+        }
+
+        if (ifd2 != null) {
+            // the thumbnail should always be described in the 2nd IFD (if it exists at all)
+
+            thumbnailPos = ifd2.getTagValueAsInt(TAG_JPEG_INTERCHANGE_FORMAT);
+            thumbnailLength = ifd2.getTagValueAsInt(TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
+            if (thumbnailPos != NO_VALUE && thumbnailLength != NO_VALUE) {
+                // The `compression` tag (259) should also help inform whether we read this
+                // image as a JPEG or TIFF. But in reality this is tricky: the docs say
+                // the value for a JPEG encoding is 0x0006, but the `jdk_8160327-plastic-wrap.jpg`
+                // file shows it can also sometimes be 0x60000. I've also observed it to be
+                // undefined, 0x0007, or several variations of 0x????0006. Similarly the same
+                // tag should be 0x0001 for TIFFs, but I also observed a case where it as 0x10000.
+                isThumbnailJPEG = true;
+            } else {
+                thumbnailWidth = ifd2.getTagValueAsInt(TAG_IMAGE_WIDTH);
+                thumbnailHeight = ifd2.getTagValueAsInt(TAG_IMAGE_HEIGHT);
+                thumbnailPos = 0;
+                thumbnailLength = data.length - 6;
+                isThumbnailJPEG = false;
+            }
+        }
+    }
+
+    LocalDateTime getImageCreationTime() {
+        LocalDateTime imageCreationTime = null;
+
+        if (!imageFileDirectories.isEmpty()) {
+            ImageFileDirectory ifd = imageFileDirectories.get(0);
+            int dateTimeOffset = ifd.getTagValueAsInt(TAG_DATE_TIME);
+            if (dateTimeOffset != NO_VALUE) {
+                try {
+                    String dateTime = new String(data, dateTimeOffset + 6, 19, StandardCharsets.US_ASCII);
+                    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("uuuu:MM:dd HH:mm:ss");
+                    imageCreationTime = LocalDateTime.parse(dateTime, formatter);
+                } catch(Exception e) {
+                    // intentionally empty
+                }
+            }
+        }
+
+        return imageCreationTime;
+    }
+
+    @Override
+    void print() {
+        printTag("Exif APP1");
+        for (int a = 0; a < imageFileDirectories.size(); a++) {
+            System.out.println("ImageFileDirectory #" + a + ", offset = " + firstIFDOffset);
+            int entryCtr = 0;
+            for (ImageFileDirectory.Entry entry : imageFileDirectories.get(a).entriesByTag.values()) {
+                System.out.println("Entry #" + (entryCtr++) + ": " + entry.toString());
+            }
+            System.out.println("next directory: " + imageFileDirectories.get(a).nextIFD);
+        }
+    }
+
+    int getNumThumbnails() {
+        return thumbnailPos >= 0 && thumbnailLength > 0 ? 1 : 0;
+    }
+
+    int getThumbnailWidth() throws IOException {
+        // this should only be called if there is a thumbnail
+
+        if (thumbnailWidth == -1) {
+            populateJPEGThumbnailDimensions();
+        }
+        return thumbnailWidth;
+    }
+
+    int getThumbnailHeight() throws IOException {
+        // this should only be called if there is a thumbnail
+
+        if (thumbnailHeight == -1) {
+            populateJPEGThumbnailDimensions();
+        }
+        return thumbnailHeight;
+    }
+
+    /**
+     * Use a JPEGImageReader to identify the size of the thumbnail. This
+     * populates the `thumbnailWidth` and `thumbnailHeight` fields.
+     */
+    private void populateJPEGThumbnailDimensions() throws IOException {
+        // this method will never be invoked for TIFF thumbnails, because TIFF
+        // thumbnails clearly define their thumbnail size via IFD entries.
+        JPEGImageReader reader = new JPEGImageReader(null);
+        try {
+            reader.setInput(ImageIO.createImageInputStream(new ByteArrayInputStream(
+                    data, thumbnailPos + 6, thumbnailLength)));
+            thumbnailWidth = reader.getWidth(0);
+            thumbnailHeight = reader.getHeight(0);
+        } finally {
+            reader.dispose();
+        }
+    }
+
+    BufferedImage getThumbnail(JPEGImageReader callbackReader) throws IOException {
+        // this should only be called if there is a thumbnail
+
+        callbackReader.thumbnailStarted(0);
+        ImageReader thumbReader;
+        int imageIndex = 0;
+        if (isThumbnailJPEG) {
+            thumbReader = new JPEGImageReader(null);
+            imageIndex = 0;
+        } else {
+            thumbReader = new TIFFImageReader(null);
+            imageIndex = 1;
+        }
+        try {
+            InputStream byteIn = new ByteArrayInputStream(data, thumbnailPos + 6, thumbnailLength);
+            ImageInputStream input = new MemoryCacheImageInputStream(byteIn);
+            thumbReader.setInput(input);
+            thumbReader.addIIOReadProgressListener(new JFIFMarkerSegment.JFIFThumbJPEG.ThumbnailReadListener(callbackReader));
+            BufferedImage thumbnailImage = thumbReader.read(imageIndex);
+            thumbnailWidth = thumbnailImage.getWidth();
+            thumbnailHeight = thumbnailImage.getHeight();
+            callbackReader.thumbnailComplete();
+            return thumbnailImage;
+        } finally {
+            thumbReader.dispose();
+        }
+    }
+}
diff --git a/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/JFIFMarkerSegment.java b/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/JFIFMarkerSegment.java
index 8b95d8adc65fe..c8fd2a5fbc431 100644
--- a/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/JFIFMarkerSegment.java
+++ b/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/JFIFMarkerSegment.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -1234,7 +1234,7 @@ int getHeight() {
             return retval;
         }
 
-        private static class ThumbnailReadListener
+        static class ThumbnailReadListener
             implements IIOReadProgressListener {
             JPEGImageReader reader = null;
             ThumbnailReadListener (JPEGImageReader reader) {
diff --git a/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/JPEGImageReader.java b/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/JPEGImageReader.java
index 3ddf2009efe51..77c15c7c7fc2b 100644
--- a/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/JPEGImageReader.java
+++ b/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/JPEGImageReader.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -1636,6 +1636,13 @@ public boolean readerSupportsThumbnails() {
         return true;
     }
 
+    private int getNumJFIFThumbnails(JFIFMarkerSegment jfif) throws IOException {
+        if (jfif == null) {
+            return 0;
+        }
+        return ((jfif.thumb == null) ? 0 : 1) + jfif.extSegments.size();
+    }
+
     @Override
     public int getNumThumbnails(int imageIndex) throws IOException {
         setThreadLock();
@@ -1643,16 +1650,22 @@ public int getNumThumbnails(int imageIndex) throws IOException {
             cbLock.check();
 
             getImageMetadata(imageIndex);  // checks iis state for us
-            // Now check the jfif segments
+
+            // Check the jfif segments
             JFIFMarkerSegment jfif =
-                (JFIFMarkerSegment) imageMetadata.findMarkerSegment
-                (JFIFMarkerSegment.class, true);
-            int retval = 0;
-            if (jfif != null) {
-                retval = (jfif.thumb == null) ? 0 : 1;
-                retval += jfif.extSegments.size();
+                    (JFIFMarkerSegment) imageMetadata.findMarkerSegment
+                            (JFIFMarkerSegment.class, true);
+            int numThumbnails = getNumJFIFThumbnails(jfif);
+
+            // Check the Exif segment
+            ExifMarkerSegment exifMarkerSegment =
+                    (ExifMarkerSegment) imageMetadata.findMarkerSegment
+                            (ExifMarkerSegment.class, true);
+            if (exifMarkerSegment != null) {
+                numThumbnails += exifMarkerSegment.getNumThumbnails();
             }
-            return retval;
+
+            return numThumbnails;
         } finally {
             clearThreadLock();
         }
@@ -1669,11 +1682,22 @@ public int getThumbnailWidth(int imageIndex, int thumbnailIndex)
                 || (thumbnailIndex >= getNumThumbnails(imageIndex))) {
                 throw new IndexOutOfBoundsException("No such thumbnail");
             }
-            // Now we know that there is a jfif segment
+
+            // Check the JFIF segment
             JFIFMarkerSegment jfif =
                 (JFIFMarkerSegment) imageMetadata.findMarkerSegment
                 (JFIFMarkerSegment.class, true);
-            return  jfif.getThumbnailWidth(thumbnailIndex);
+
+            int numJFIFThumbnails = getNumJFIFThumbnails(jfif);
+            if (thumbnailIndex < numJFIFThumbnails) {
+                return jfif.getThumbnailWidth(thumbnailIndex);
+            }
+
+            // Check the Exif segment
+            ExifMarkerSegment exifMarkerSegment =
+                    (ExifMarkerSegment) imageMetadata.findMarkerSegment
+                            (ExifMarkerSegment.class, true);
+            return exifMarkerSegment.getThumbnailWidth();
         } finally {
             clearThreadLock();
         }
@@ -1690,11 +1714,22 @@ public int getThumbnailHeight(int imageIndex, int thumbnailIndex)
                 || (thumbnailIndex >= getNumThumbnails(imageIndex))) {
                 throw new IndexOutOfBoundsException("No such thumbnail");
             }
-            // Now we know that there is a jfif segment
+
+            // Check the JFIF segment
             JFIFMarkerSegment jfif =
-                (JFIFMarkerSegment) imageMetadata.findMarkerSegment
-                (JFIFMarkerSegment.class, true);
-            return  jfif.getThumbnailHeight(thumbnailIndex);
+                    (JFIFMarkerSegment) imageMetadata.findMarkerSegment
+                            (JFIFMarkerSegment.class, true);
+
+            int numJFIFThumbnails = getNumJFIFThumbnails(jfif);
+            if (thumbnailIndex < numJFIFThumbnails) {
+                return jfif.getThumbnailHeight(thumbnailIndex);
+            }
+
+            // Check the Exif segment
+            ExifMarkerSegment exifMarkerSegment =
+                    (ExifMarkerSegment) imageMetadata.findMarkerSegment
+                            (ExifMarkerSegment.class, true);
+            return exifMarkerSegment.getThumbnailHeight();
         } finally {
             clearThreadLock();
         }
@@ -1712,11 +1747,21 @@ public BufferedImage readThumbnail(int imageIndex,
                 || (thumbnailIndex >= getNumThumbnails(imageIndex))) {
                 throw new IndexOutOfBoundsException("No such thumbnail");
             }
-            // Now we know that there is a jfif segment and that iis is good
+
+            // Check the JFIF segment
             JFIFMarkerSegment jfif =
-                (JFIFMarkerSegment) imageMetadata.findMarkerSegment
-                (JFIFMarkerSegment.class, true);
-            return  jfif.getThumbnail(iis, thumbnailIndex, this);
+                    (JFIFMarkerSegment) imageMetadata.findMarkerSegment
+                            (JFIFMarkerSegment.class, true);
+            int numJFIFThumbnails = getNumJFIFThumbnails(jfif);
+            if (thumbnailIndex < numJFIFThumbnails) {
+                return jfif.getThumbnail(iis, thumbnailIndex, this);
+            }
+
+            // Check the Exif segment
+            ExifMarkerSegment exifMarkerSegment =
+                    (ExifMarkerSegment) imageMetadata.findMarkerSegment
+                            (ExifMarkerSegment.class, true);
+            return exifMarkerSegment.getThumbnail(this);
         } finally {
             clearThreadLock();
         }
diff --git a/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/JPEGMetadata.java b/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/JPEGMetadata.java
index a2fe287bc3dbe..c7ad982b35a2f 100644
--- a/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/JPEGMetadata.java
+++ b/src/java.desktop/share/classes/com/sun/imageio/plugins/jpeg/JPEGMetadata.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -32,6 +32,7 @@
 import java.awt.image.BufferedImage;
 import java.awt.image.ColorModel;
 import java.io.IOException;
+import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
@@ -252,6 +253,24 @@ public class JPEGMetadata extends IIOMetadata implements Cloneable {
                     newGuy.loadData(buffer);
                 }
                 break;
+            case JPEG.APP1:
+                newGuy = new MarkerSegment(buffer);
+                newGuy.loadData(buffer);
+
+                if (newGuy.data.length > 5 &&
+                        newGuy.data[0] == 'E' &&
+                        newGuy.data[1] == 'x' &&
+                        newGuy.data[2] == 'i' &&
+                        newGuy.data[3] == 'f' &&
+                        newGuy.data[4] == 0) {
+                    try {
+                        newGuy = new ExifMarkerSegment(newGuy);
+                    } catch(Exception e) {
+                        // This is intentionally empty.
+                        // Now we fallback to keeping the generic MarkerSegment
+                    }
+                }
+                break;
             case JPEG.APP2:
                 // Either an ICC profile or unknown APP2
                 buffer.loadBuf(15); // tag, length, id
@@ -1007,6 +1026,35 @@ protected IIOMetadataNode getStandardDimensionNode() {
         return dim;
     }
 
+    @Override
+    protected IIOMetadataNode getStandardDocumentNode() {
+        IIOMetadataNode doc = null;
+
+        ExifMarkerSegment exifMarkerSegment =
+                (ExifMarkerSegment) findMarkerSegment
+                        (ExifMarkerSegment.class, true);
+
+        if (exifMarkerSegment != null) {
+            // If there is an Exif marker segment get the image creation time.
+            LocalDateTime ict = exifMarkerSegment.getImageCreationTime();
+            if (ict != null) {
+                doc = new IIOMetadataNode("Document");
+                IIOMetadataNode dateTime = new IIOMetadataNode("ImageCreationTime");
+                dateTime.setAttribute("year", String.valueOf(ict.getYear()));
+                dateTime.setAttribute("month", String.valueOf(ict.getMonthValue()));
+                dateTime.setAttribute("day", String.valueOf(ict.getDayOfMonth()));
+                dateTime.setAttribute("hour", String.valueOf(ict.getHour()));
+                dateTime.setAttribute("minute", String.valueOf(ict.getMinute()));
+                dateTime.setAttribute("second", String.valueOf(ict.getSecond()));
+                doc.appendChild(dateTime);
+            }
+        } else {
+            doc = super.getStandardDocumentNode();
+        }
+
+        return doc;
+    }
+
     protected IIOMetadataNode getStandardTextNode() {
         IIOMetadataNode text = null;
         // Add a text entry for each COM Marker Segment
diff --git a/src/java.desktop/share/classes/javax/imageio/metadata/doc-files/jpeg_metadata.html b/src/java.desktop/share/classes/javax/imageio/metadata/doc-files/jpeg_metadata.html
index c5dd4044a1bf0..5eb0eb288c0c3 100644
--- a/src/java.desktop/share/classes/javax/imageio/metadata/doc-files/jpeg_metadata.html
+++ b/src/java.desktop/share/classes/javax/imageio/metadata/doc-files/jpeg_metadata.html
@@ -5,7 +5,7 @@
   <title>JPEG Metadata Format Specification and Usage Notes</title>
 </head>
 <!--
-Copyright (c) 2000, 2021, Oracle and/or its affiliates. All rights reserved.
+Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved.
 DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
 This code is free software; you can redistribute it and/or modify it
@@ -509,6 +509,17 @@ <h2>
 <h2>
 <a id=thumbs>Thumbnail Images</a>
 </h2>
+<h3>
+Reading Thumbnail Images
+</h3>
+Thumbnail images are read from JFIF, JFIF extension, and Exif marker segments.
+One or more thumbnails may be present in the JFIF segment(s), but at most one
+will be present in the Exif segment. As specified, JFIF and Exif marker segments
+should be mutually exclusive, but if they are both present, then any JFIF
+thumbnail(s) will precede any Exif thumbnail.
+<h3>
+Writing Thumbnail Images
+</h3>
 Thumbnails are supported by the use of JFIF and JFIF extension marker segments.
 Thumbnails provided on the write methods determine the thumbnails that will be
 included.  <code>app0JFIF</code> and <code>app0JFXX</code> nodes present in
diff --git a/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/JpegExifThumbnailTest.java b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/JpegExifThumbnailTest.java
new file mode 100644
index 0000000000000..dd43e7558feda
--- /dev/null
+++ b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/JpegExifThumbnailTest.java
@@ -0,0 +1,290 @@
+/*
+ * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 8160327
+ * @summary Test verifies thumbnails are read from sample JPEG images
+ *          that are encoded using Exif file format.
+ * @run     main JpegExifThumbnailTest
+ */
+
+
+import org.w3c.dom.Node;
+
+import java.awt.Dimension;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.util.Iterator;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReader;
+import javax.imageio.event.IIOReadProgressListener;
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.metadata.IIOMetadataFormatImpl;
+import javax.imageio.stream.ImageInputStream;
+
+public class JpegExifThumbnailTest {
+
+    private static void assertBoolean(boolean b, String errorMsg) {
+        if (!b) {
+            throw new Error(errorMsg);
+        }
+    }
+
+    private static void assertEquals(int expected, int observed) {
+        if (expected != observed) {
+            throw new Error("expected " + expected + ", but observed " + observed);
+        }
+    }
+
+    private static void assertEquals(Node node, String attributeName, int expectedAttributeValue) {
+        String s = node.getAttributes().getNamedItem(attributeName).getNodeValue();
+        if (!Integer.toString(expectedAttributeValue).equals(s))
+            throw new Error("expected \"" + attributeName + "\" to be " + expectedAttributeValue + ", but observed " + s);
+    }
+
+    static class MyListener implements IIOReadProgressListener {
+
+        boolean thumbnailStarted = false;
+        boolean thumbnailCompleted = false;
+        float thumbnailPercent = -1;
+
+        @Override
+        public void sequenceStarted(ImageReader source, int minIndex) {
+            throw new Error("sequenceStarted should not be called");
+        }
+
+        @Override
+        public void sequenceComplete(ImageReader source) {
+            throw new Error("sequenceComplete should not be called");
+        }
+
+        @Override
+        public void imageStarted(ImageReader source, int imageIndex) {
+            throw new Error("imageStarted should not be called");
+        }
+
+        @Override
+        public void imageProgress(ImageReader source, float percentageDone) {
+            throw new Error("imageProgress should not be called");
+        }
+
+        @Override
+        public void imageComplete(ImageReader source) {
+            throw new Error("imageComplete should not be called");
+        }
+
+        @Override
+        public void thumbnailStarted(ImageReader source, int imageIndex, int thumbnailIndex) {
+            if (thumbnailStarted || thumbnailCompleted || thumbnailPercent >= 0)
+                throw new Error();
+            thumbnailStarted = true;
+        }
+
+        @Override
+        public void thumbnailProgress(ImageReader source, float percentageDone) {
+            if (!thumbnailStarted || thumbnailCompleted || thumbnailPercent >= percentageDone)
+                throw new Error();
+            thumbnailPercent = percentageDone;
+        }
+
+        @Override
+        public void thumbnailComplete(ImageReader source) {
+            if (!thumbnailStarted || thumbnailCompleted)
+                throw new Error();
+            thumbnailCompleted = true;
+        }
+
+        @Override
+        public void readAborted(ImageReader source) {
+            throw new Error("readAborted should not be called");
+        }
+    }
+
+    public static void main (String[] args) throws IOException {
+        // all the timestamps were verified in a 3rd party app (such as Preview on Mac)
+
+        // this is little endian, and uses a compression type 0x00000006
+        new JpegExifThumbnailTest("SV650.jpg",
+                2015,6,24,10,3,55,
+                new Dimension(160, 120)).run();
+
+        // This Exif thumbnail is uncompressed (a TIFF). The exif marker uses
+        // a compression type of 0x00010000, and it is big endian
+        new JpegExifThumbnailTest("uncompressed-exif-thumbnail.jpg",
+                2025,2,24,14,22,36,
+                new Dimension(80, 60)).run();
+
+        // This includes a JFIF thumbnail and an EXIF thumbnail.
+        new JpegExifThumbnailTest("jfif-and-exif.jpg",
+                2025,2,21,1,14,51,
+                new Dimension(150, 200),
+                new Dimension(120, 160)).run();
+
+        // this includes Exif data, but the `compression` tag is 0x60000 instead of 0x6,
+        // also it doesn't include any date
+        new JpegExifThumbnailTest("plastic-wrap.jpg",
+                -1, -1, -1, -1, -1, -1,
+                new Dimension(200, 132)).run();
+
+        // here the timestamp doesn't match our parser, so we'll ignore it
+        new JpegExifThumbnailTest("bad-timestamp.jpg",
+                -1, -1, -1, -1, -1, -1).run();
+
+        // this ImageFileDirectory doesn't terminate like it should. We need to
+        // not fail with an EOFException in this case:
+        new JpegExifThumbnailTest("unusual-ImageFileDirectory.jpeg",
+                2007, 11, 10, 21, 23, 4).run();
+
+        // This file is a replica of SV650.jpg, except the 14th byte was changed
+        // so ExifMarkerSegment's constructor throws a "Bad magic number" exception.
+        // The expected behavior here is: we do NOT catch an exception, because internally
+        // JPEGMetaData just recorded a generic MarkerSegment instead of an ExifMarkerSegment
+        new JpegExifThumbnailTest("corrupt-magic-number.jpg",
+                -1, -1, -1, -1, -1, -1).run();
+
+        // This file is set up so ImageFileDirectory X points to Y,
+        // then Y points back to X. An early draft of the ExifMarkerSegment
+        // class would get stuck parsing this loop. (After a few minutes this
+        // would probably fail with an OutOfMemoryError as the list of IFDs
+        // grew too large.)
+        // The expected behavior here is to stop after reading 2 IFDs, and
+        // otherwise read the JPEG as usual
+        new JpegExifThumbnailTest("malicious-looping-IFD.jpg",
+                2025, 2, 16, 15, 48, 34,
+                new Dimension(60, 80)).run();
+    }
+
+    final String filename;
+    final Dimension[] thumbnailSizes;
+    final int year, month, day, hour, minute, second;
+
+    JpegExifThumbnailTest(String filename,
+                          int year, int month, int day,
+                          int hour, int minute, int second,
+                          Dimension... thumbnailSizes) {
+        this.filename = filename;
+        this.thumbnailSizes = thumbnailSizes;
+        this.year = year;
+        this.month = month;
+        this.day = day;
+        this.hour = hour;
+        this.minute = minute;
+        this.second = second;
+    }
+
+    public void run() throws IOException {
+        String sep = System.getProperty("file.separator");
+        String dir = System.getProperty("test.src", ".");
+        String filePath = dir+sep+filename;
+        File file = new File(filePath);
+
+        if (!file.exists())
+            throw new IOException("missing test file: " + file.getPath());
+        System.out.println("Testing " + file.getPath());
+
+        ImageReader reader = getJPEGImageReader();
+        ImageInputStream stream = ImageIO.createImageInputStream(file);
+        reader.setInput(stream);
+
+        int thumbnailCount = reader.getNumThumbnails(0);
+        if (thumbnailCount != thumbnailSizes.length)
+            throw new Error("expected " + thumbnailSizes.length + " thumbnails, but observed " + thumbnailCount);
+
+        for (int a = 0; a < thumbnailSizes.length; a++) {
+            MyListener listener = new MyListener();
+            reader.addIIOReadProgressListener(listener);
+            try {
+                int w = reader.getThumbnailWidth(0, a);
+                int h = reader.getThumbnailHeight(0, a);
+                System.out.println("\tthumbnail: " + w + "x" + h);
+                assertEquals(thumbnailSizes[a].width, w);
+                assertEquals(thumbnailSizes[a].height, h);
+
+                BufferedImage bi = reader.readThumbnail(0, a);
+                assertEquals(thumbnailSizes[a].width, bi.getWidth());
+                assertEquals(thumbnailSizes[a].height, bi.getHeight());
+
+                assertBoolean(listener.thumbnailStarted, "the IIOReadProgressListener was not notified that the thumbnail started");
+                assertBoolean(listener.thumbnailCompleted, "the IIOReadProgressListener was not notified that the thumbnail completed");
+            } finally {
+                reader.removeIIOReadProgressListener(listener);
+            }
+        }
+
+        IIOMetadata metadata = reader.getImageMetadata(0);
+        Node root = metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName);
+        Node docNode = findChild(root, "Document");
+        Node timeNode = findChild(docNode, "ImageCreationTime");
+
+        if (timeNode == null) {
+            // this is OK, it means there's no ImageCreationTime
+            assertEquals(-1, year);
+            assertEquals(-1, month);
+            assertEquals(-1, day);
+            assertEquals(-1, hour);
+            assertEquals(-1, minute);
+            assertEquals(-1, second);
+        } else {
+            StringBuilder sb = new StringBuilder();
+            for (int b = 0; b < timeNode.getAttributes().getLength(); b++) {
+                sb.append(timeNode.getAttributes().item(b).getNodeName() + "=" +
+                        timeNode.getAttributes().item(b).getNodeValue() + " ");
+            }
+            System.out.println("\tImageCreationTime: " + sb.toString().trim());
+
+            assertEquals(timeNode, "year", year);
+            assertEquals(timeNode, "month", month);
+            assertEquals(timeNode, "day", day);
+            assertEquals(timeNode, "hour", hour);
+            assertEquals(timeNode, "minute", minute);
+            assertEquals(timeNode, "second", second);
+        }
+    }
+
+    private static Node findChild(Node node, String nodeName) {
+        if (node == null) {
+            return null;
+        }
+        Node child = node.getFirstChild();
+        while (child != null) {
+            if (child.getNodeName().equals(nodeName))
+                return child;
+            child = child.getNextSibling();
+        }
+        return null;
+    }
+
+    private static ImageReader getJPEGImageReader() {
+        Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("jpeg");
+        ImageReader reader;
+        while(readers.hasNext()) {
+            reader = readers.next();
+            if(reader.canReadRaster()) {
+                return reader;
+            }
+        }
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/SV650.jpg b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/SV650.jpg
new file mode 100644
index 0000000000000..a7dc85f5258b4
Binary files /dev/null and b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/SV650.jpg differ
diff --git a/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/bad-timestamp.jpg b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/bad-timestamp.jpg
new file mode 100644
index 0000000000000..f53c899ff64f7
Binary files /dev/null and b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/bad-timestamp.jpg differ
diff --git a/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/corrupt-magic-number.jpg b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/corrupt-magic-number.jpg
new file mode 100644
index 0000000000000..c370119dd9597
Binary files /dev/null and b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/corrupt-magic-number.jpg differ
diff --git a/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/jfif-and-exif.jpg b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/jfif-and-exif.jpg
new file mode 100644
index 0000000000000..47856d7e75ca9
Binary files /dev/null and b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/jfif-and-exif.jpg differ
diff --git a/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/malicious-looping-IFD.jpg b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/malicious-looping-IFD.jpg
new file mode 100644
index 0000000000000..627fdf87fc566
Binary files /dev/null and b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/malicious-looping-IFD.jpg differ
diff --git a/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/plastic-wrap.jpg b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/plastic-wrap.jpg
new file mode 100644
index 0000000000000..860e7ad651205
Binary files /dev/null and b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/plastic-wrap.jpg differ
diff --git a/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/uncompressed-exif-thumbnail.jpg b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/uncompressed-exif-thumbnail.jpg
new file mode 100644
index 0000000000000..0682f81486c0f
Binary files /dev/null and b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/uncompressed-exif-thumbnail.jpg differ
diff --git a/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/unusual-ImageFileDirectory.jpeg b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/unusual-ImageFileDirectory.jpeg
new file mode 100644
index 0000000000000..d35397ad710f2
Binary files /dev/null and b/test/jdk/javax/imageio/plugins/jpeg/JpegExifThumbnail/unusual-ImageFileDirectory.jpeg differ