Exiv2 version 0.28.9 is released today, with fixes for 1 moderate and 6 low severity vulnerabilities. We are also planning to include a security-related change in the upcoming 0.29.0 release: more details at the end.

https://github.com/Exiv2/exiv2/security/advisories/GHSA-3695-mjv8-3r52 (moderate severity, CVE-2026-68546) Out-of-bounds write in RemoteIo::Impl::populateBlocks(). The bug is in the RemoteIo class, which is only used when Exiv2 is run on a URL, rather than a local file. In other words, to trigger the bug, Exiv2 needs to be run like this:

bash exiv2 https://dodgywebsite.com/poc.jpg

https://github.com/Exiv2/exiv2/security/advisories/GHSA-jcgh-p9v3-pw6j (low severity, CVE-2026-68547) Out-of-bounds read in RemoteIo::Impl::populateBlocks(). The bug is in the RemoteIo class, which is only used when Exiv2 is run on a URL, rather than a local file. In other words, to trigger the bug, Exiv2 needs to be run like this:

bash exiv2 https://dodgywebsite.com/poc.jpg

https://github.com/Exiv2/exiv2/security/advisories/GHSA-hxph-pv7w-8649 (low severity, CVE-2026-49275) Out-of-bounds read in CrwMap::decodeBasic(). The bug is reproducible with our fuzz target, but we have not been able to reproduce it with the exiv2 command line application.

https://github.com/Exiv2/exiv2/security/advisories/GHSA-vg6c-9f6h-4x5q (low severity, CVE requested) Out-of-bounds write in RemoteIo::mmap(). The bug is in the RemoteIo class, which is only used when Exiv2 is run on a URL, rather than a local file. Furthermore, the bug is only triggered when using Exiv2 to list available image previews (the -pp command line option). In other words, to trigger the bug, Exiv2 needs to be run like this:

bash exiv2 -pp https://dodgywebsite.com/poc.jpg

https://github.com/Exiv2/exiv2/security/advisories/GHSA-9v3x-mhg4-wwv2 (low severity, CVE requested) Out-of-bounds write in Exiv2::http(). The bug can only be triggered by running Exiv2 on a URL, rather than a local file. The easiest way to reproduce the bug is by calling Exiv2 with an unrealistically long command line argument:

bash exiv2 -pa python -c "print('http://127.0.0.1:8769/' + 'A' 100000)"

The above reproduction steps are a self-pwn, which would make this a regular bug, not a vulnerability. However, we are treating it as a vulnerability because there is also a possibility that the bug could be triggered by a command like this:

bash exiv2 -Mset Exif.Image.Artist PwnMe https://dodgywebsite.com/poc.jpg

https://github.com/Exiv2/exiv2/security/advisories/GHSA-fgw8-p7pr-37cp (low severity, CVE requested) Denial of service in QuickTimeVideo::userDataDecoder(): an invalid input file can cause QuickTimeVideo::userDataDecoder() to get stuck in an infinite loop during parsing. The vulnerability can be triggered by running Exiv2 on a crafted file, like this:

bash exiv2 poc.mov

https://github.com/Exiv2/exiv2/security/advisories/GHSA-pwvq-9w4q-786w (low severity, CVE requested) Denial of service in PgfImage::readMetadata(). The vulnerability can be triggered by running Exiv2 on a crafted file, like this:

bash exiv2 poc.pgf

This causes Exiv2 to rapidly allocate a very large amount of memory, which can impact system performance.

Security related note on the upcoming 0.29.0 release We have been receiving a very large number of "denial of service" vulnerability reports, all of them variations on the theme: "deeply nested file causes stack exhaustion". Exiv2 uses recursion to parse image files, so it is relatively easy for a crafted file to cause Exiv2 to run out of stack. On Linux, there is a very simple solution to this issue, which is to increase your stack size with the ulimit command. But that solution doesn't work on macOS and Windows which have relatively low hard limits on the stack size. So we are planning to fix this issue by adding a recursion depth limit to all the parsers. Unfortunately, this will involve changing libexiv2's public API, so we cannot do it in the 0.28.x series. We are planning to include this change in the upcoming 0.29.0 release instead. For more details on this issue, see https://github.com/Exiv2/exiv2/issues/9414

Exiv2 is a C++ library and a command-line utility to read, write, delete and modify Exif, IPTC, XMP and ICC image metadata. Prior to version 0.28.8, an out-of-bounds read was found. The vulnerability is in the CRW image parser. This issue has been patched in version 0.28.8.

Exiv2 is a C++ library and a command-line utility to read, write, delete and modify Exif, IPTC, XMP and ICC image metadata. Prior to version 0.28.8, an out-of-bounds read was found in Exiv2. The vulnerability is in the preview component, which is only triggered when running Exiv2 with an extra command line argument, like -pp. The out-of-bounds read is at a 4GB offset, which usually causes Exiv2 to crash. This issue has been patched in version 0.28.8.

Exiv2 is a C++ library and a command-line utility to read, write, delete and modify Exif, IPTC, XMP and ICC image metadata. Prior to version 0.28.8, an uncaught exception was found in Exiv2. The vulnerability is in the preview component, which is only triggered when running Exiv2 with an extra command line argument, like -pp. Due to an integer overflow, the code attempts to create a huge std::vector, which causes Exiv2 to crash with an uncaught exception. This issue has been patched in version 0.28.8.

Exiv2 version 0.28.8 was released yesterday (2026-03-01) with fixes for three CVEs:

CVE-2026-25884: Out-of-bounds read in CrwMap::decode0x0805 Impact: low severity, because we're only able to reproduce this with our fuzz target, not with the exiv2 command-line application. Credit: found by Google OSS-Fuzz

CVE-2026-27596: Integer overflow in LoaderNative::getData() causes out-of-bounds read Impact: low severity, because it is only triggered when running Exiv2 with an extra command line argument, like -pp. The out-of-bounds read is at a 4GB offset, which typically causes a crash. Credit: found by @zerojackyi

CVE-2026-27631: Uncaught exception: cannot create std::vector larger than maxsize() Impact: low severity, because it is only triggered when running Exiv2 with an extra command line argument, like -pp. This issue causes Exiv2 to crash with an uncaught exception. Credit: found by team Exiv2

The second issue (CVE-2026-27596) is perhaps the most interesting because it looks to me like it was found by AI. I think the report looks AI-generated, but it's also unusual for a poc to be written in Python, since most Exiv2 bugs are found by fuzzing. In the past, a poc like this would have indicated that it was hand-crafted by a human, but these days AI seems more likely. Although we've rated it low-severity, it was a useful report to receive because it uncovered a gap in our fuzzing coverage. We have now added a new fuzz-target to address that gap, which is how we found the third issue (CVE-2026-27631).

One more thing that I'd like to mention: we have stopped supporting older versions of Exiv2. If you haven't done so already, please consider upgrading to the 0.28 series.

Thanks,

Kev

Links: https://github.com/Exiv2/exiv2/releases/tag/v0.28.8 https://github.com/Exiv2/exiv2/security/advisories/GHSA-9mxq-4j5g-5wrp https://github.com/Exiv2/exiv2/security/advisories/GHSA-3wgv-fg4w-75x7 https://github.com/Exiv2/exiv2/security/advisories/GHSA-p2pw-7935-c73j

Impact A denial-of-service was found in Exiv2 version v0.28.5: a quadratic algorithm in the ICC profile parsing code in jpegBase::readMetadata() can cause Exiv2 to run for a long time. Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. The denial-of-service is triggered when Exiv2 is used to read the metadata of a crafted jpg image file.

Patches The bug is fixed in version v0.28.6.

References Issue: https://github.com/Exiv2/exiv2/issues/3333 Fixes: https://github.com/Exiv2/exiv2/pull/3335 (main branch), https://github.com/Exiv2/exiv2/pull/3345 (0.28.x branch)

For more information Please see our security policy for information about Exiv2 security.

Impact An out-of-bounds read was found in Exiv2 versions v0.28.5 and earlier. Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. The out-of-bounds read is triggered when Exiv2 is used to write metadata into a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service by crashing Exiv2, if they can trick the victim into running Exiv2 on a crafted image file.

Note that this bug is only triggered when writing the metadata, which is a less frequently used Exiv2 operation than reading the metadata. For example, to trigger the bug in the Exiv2 command-line application, you need to add an extra command-line argument such as delete.

Patches The bug is fixed in version v0.28.6.

Credit Thank you to @dragonArthurX for reporting this issue.

Details (from original report by @dragonArthurX ) Version: Tested on v0.28.5 (latest official release) Commit: 907169fa643c2c74c14fd4106e55eaeee3634d9f

Platform: Ubuntu 20.04.6 LTS (x8664)

Build Steps: bash git clone https://github.com/Exiv2/exiv2.git cd exiv2 git checkout v0.28.5 mkdir build-v0.28.5 && cd build-v0.28.5 cmake -DCMAKECCOMPILER=/fuzzer/afl-clang-fast -DCMAKECXXCOMPILER=/fuzzer/afl-clang-fast++ -DCMAKECFLAGS="-g -fsanitize=address" -DCMAKECXXFLAGS="-g -fsanitize=address" -DBUILDSHAREDLIBS=OFF ../

Command line to reproduce: bash /home/exiv2/build/bin/exiv2 -d a -f /home/poc

Crash Output: AddressSanitizer:DEADLYSIGNAL ================================================================ = ==376531==ERROR: AddressSanitizer: SEGV on unknown address 0x7fd92236b0e7 (pc 0x7fd82314dcd2 bp 0x7ffd540ceba0 sp 0x7ffd540ce358 T0) ==376531==The signal is caused by a READ memory access. #0 0x7fd82314dcd2 /build/glibc-B3wQXB/glibc-2.31/string/../sysdeps/x8664/multiarch/memmove-vec-unaligned-erms.S:383 #1 0x4ed131 in asanmemcpy (/home/exiv2/build-v0.28.5/bin/exiv2+0x4ed131) #2 0x6184b1 in Exiv2::MemIo::write(unsigned char const, unsigned long) /home/exiv2/src/basicio.cpp:704:5 #3 0xad336d in (anonymous namespace)::writeTemp(Exiv2::BasicIo&, unsigned char const, unsigned long) /home/exiv2/src/epsimage.cpp:90:14 #4 0xac3a07 in (anonymous namespace)::readWriteEpsMetadata(Exiv2::BasicIo&, std::cxx11::basicstring<char, std::chartraits<char>, std::allocator<char> >&, std::vector<Exiv2::NativePreview, std::allocator<Exiv2::NativePreview> >&, bool) /home/exiv2/src/epsimage.cpp:1009:7 #5 0xad1175 in Exiv2::EpsImage::writeMetadata() /home/exiv2/src/epsimage.cpp:1103:3 #6 0x5d2383 in Action::Erase::run(std::cxx11::basicstring<char, std::chartraits<char>, std::allocator<char> > const&) /home/exiv2/app/actions.cpp:713:14 #7 0x522d02 in main /home/exiv2/app/exiv2.cpp:177:25 #8 0x7fd8230b6082 in libcstartmain /build/glibc-B3wQXB/glibc-2.31/csu/../csu/libc-start.c:308:16 #9 0x4714dd in start (/home/exiv2/build-v0.28.5/bin/exiv2+0x4714dd)

AddressSanitizer can not provide additional info. SUMMARY: AddressSanitizer: SEGV /build/glibc-B3wQXB/glibc-2.31/string/../sysdeps/x8664/multiarch/memmove-vec-unaligned-erms.S:383 ==376531==ABORTING

Impact A heap buffer overflow was found in Exiv2 versions v0.28.0 to v0.28.4. Versions prior to v0.28.0, such as v0.27.7, are not affected. Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. The heap overflow is triggered when Exiv2 is used to write metadata into a crafted image file. An attacker could potentially exploit the vulnerability to gain code execution, if they can trick the victim into running Exiv2 on a crafted image file.

Note that this bug is only triggered when writing the metadata, which is a less frequently used Exiv2 operation than reading the metadata. For example, to trigger the bug in the Exiv2 command-line application, you need to add an extra command-line argument such as fixiso.

Patches The bug is fixed in version v0.28.5.

References Issue: https://github.com/Exiv2/exiv2/issues/3168 Fix: https://github.com/Exiv2/exiv2/pull/3174

For more information Please see our security policy for information about Exiv2 security.

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. An out-of-bounds read was found in Exiv2 version v0.28.2. The vulnerability is in the parser for the ASF video format, which was a new feature in v0.28.0. The out-of-bounds read is triggered when Exiv2 is used to read the metadata of a crafted video file. The bug is fixed in version v0.28.3.

Impact An out-of-bounds read was found in Exiv2 version v0.28.1. The vulnerable function, QuickTimeVideo::NikonTagsDecoder, was new in v0.28.0 (see https://github.com/Exiv2/exiv2/pull/2337), so Exiv2 versions before v0.28 are not affected. Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. The out-of-bounds read is triggered when Exiv2 is used to read the metadata of a crafted video file.

Patches The bug is fixed in version v0.28.2.

For more information Please see our security policy for information about Exiv2 security.

Credit This bug was found by OSS-Fuzz.

Impact A denial-of-service was found in Exiv2 version v0.28.1: an unbounded recursion can cause Exiv2 to crash by exhausting the stack. The vulnerable function, QuickTimeVideo::multipleEntriesDecoder, was new in v0.28.0 (see https://github.com/Exiv2/exiv2/pull/2337), so Exiv2 versions before v0.28 are not affected. Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. The denial-of-service is triggered when Exiv2 is used to read the metadata of a crafted video file.

Patches The bug is fixed in version v0.28.2.

For more information Please see our security policy for information about Exiv2 security.

Credit This bug was found by OSS-Fuzz.

Exiv2 is a C++ library and a command-line utility to read, write, delete and modify Exif, IPTC, XMP and ICC image metadata. An out-of-bounds write was found in Exiv2 version v0.28.0. The vulnerable function, BmffImage::brotliUncompress, is new in v0.28.0, so earlier versions of Exiv2 are not affected. The out-of-bounds write is triggered when Exiv2 is used to read the metadata of a crafted image file. An attacker could potentially exploit the vulnerability to gain code execution, if they can trick the victim into running Exiv2 on a crafted image file. This bug is fixed in version v0.28.1. Users are advised to upgrade. There are no known workarounds for this vulnerability.

Buffer Overflow vulnerability in tEXtToDataBuf function in pngimage.cpp in Exiv2 0.27.1 allows remote attackers to cause a denial of service and other unspecified impacts via use of crafted file.

A float point exception in the printLong function in tagsint.cpp of Exiv2 0.27.99.0 allows attackers to cause a denial of service (DOS) via a crafted tif file.

An invalid memory access in the decode function in iptc.cpp of Exiv2 0.27.99.0 allows attackers to cause a denial of service (DOS) via a crafted tif file.

Exiv2 0.27.99.0 has a global buffer over-read in Exiv2::Internal::Nikon1MakerNote::print0x0088 in nikonmnint.cpp which can result in an information leak.

A stack exhaustion issue in the printIFDStructure function of Exiv2 0.27 allows remote attackers to cause a denial of service (DOS) via a crafted file.

An uncontrolled memory allocation in DataBufdata(subBox.length-sizeof(box)) function of Exiv2 0.27 allows attackers to cause a denial of service (DOS) via a crafted input.

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. An out-of-bounds read was found in Exiv2 versions v0.27.4 and earlier. The out-of-bounds read is triggered when Exiv2 is used to write metadata into a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service by crashing Exiv2, if they can trick the victim into running Exiv2 on a crafted image file. Note that this bug is only triggered when writing the metadata, which is a less frequently used Exiv2 operation than reading the metadata. For example, to trigger the bug in the Exiv2 command-line application, you need to add an extra command-line argument such as insert. The bug is fixed in version v0.27.5.

Reference: https://github.com/Exiv2/exiv2/security/advisories/GHSA-mxw9-qx4c-6m8v

Upstream patch: https://github.com/Exiv2/exiv2/pull/1752

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. An out-of-bounds read was found in Exiv2 versions v0.27.4 and earlier. The out-of-bounds read is triggered when Exiv2 is used to print the metadata of a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service, if they can trick the victim into running Exiv2 on a crafted image file. Note that this bug is only triggered when printing the image ICC profile, which is a less frequently used Exiv2 operation that requires an extra command line option (-p C). The bug is fixed in version v0.27.5.

Reference: https://github.com/Exiv2/exiv2/security/advisories/GHSA-583f-w9pm-99r2

Upstream patch: https://github.com/Exiv2/exiv2/pull/1759

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. An infinite loop was found in Exiv2 versions v0.27.4 and earlier. The infinite loop is triggered when Exiv2 is used to modify the metadata of a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service, if they can trick the victim into running Exiv2 on a crafted image file. Note that this bug is only triggered when deleting the IPTC data, which is a less frequently used Exiv2 operation that requires an extra command line option (-d I rm). The bug is fixed in version v0.27.5.

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. An infinite loop was found in Exiv2 versions v0.27.4 and earlier. The infinite loop is triggered when Exiv2 is used to print the metadata of a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service, if they can trick the victim into running Exiv2 on a crafted image file. Note that this bug is only triggered when printing the image ICC profile, which is a less frequently used Exiv2 operation that requires an extra command line option (-p C). The bug is fixed in version v0.27.5.

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. An infinite loop is triggered when Exiv2 is used to read the metadata of a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service, if they can trick the victim into running Exiv2 on a crafted image file. The bug is fixed in version v0.27.5.

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. A floating point exception (FPE) due to an integer divide by zero was found in Exiv2 versions v0.27.4 and earlier. The FPE is triggered when Exiv2 is used to print the metadata of a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service, if they can trick the victim into running Exiv2 on a crafted image file. Note that this bug is only triggered when printing the interpreted (translated) data, which is a less frequently used Exiv2 operation that requires an extra command line option (-p t or -P t). The bug is fixed in version v0.27.5.

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. An out-of-bounds read was found in Exiv2 versions v0.27.4 and earlier. The out-of-bounds read is triggered when Exiv2 is used to write metadata into a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service by crashing Exiv2, if they can trick the victim into running Exiv2 on a crafted image file. Note that this bug is only triggered when writing the metadata, which is a less frequently used Exiv2 operation than reading the metadata. For example, to trigger the bug in the Exiv2 command-line application, you need to add an extra command-line argument such as insert. The bug is fixed in version v0.27.5.

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. The assertion failure is triggered when Exiv2 is used to modify the metadata of a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service, if they can trick the victim into running Exiv2 on a crafted image file. Note that this bug is only triggered when modifying the metadata, which is a less frequently used Exiv2 operation than reading the metadata. For example, to trigger the bug in the Exiv2 command-line application, you need to add an extra command-line argument such as fi. ### Patches The bug is fixed in version v0.27.5. ### References Regression test and bug fix: #1739 ### For more information Please see our security policy for information about Exiv2 security.

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. An out-of-bounds read was found in Exiv2 versions v0.27.4 and earlier. The out-of-bounds read is triggered when Exiv2 is used to print the metadata of a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service, if they can trick the victim into running Exiv2 on a crafted image file. Note that this bug is only triggered when printing the image ICC profile, which is a less frequently used Exiv2 operation that requires an extra command line option (-p C). The bug is fixed in version v0.27.5.

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. An out-of-bounds read was found in Exiv2 versions v0.27.4 and earlier. The out-of-bounds read is triggered when Exiv2 is used to read the metadata of a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service, if they can trick the victim into running Exiv2 on a crafted image file. The bug is fixed in version v0.27.5.

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. An infinite loop was found in Exiv2 versions v0.27.4 and earlier. The infinite loop is triggered when Exiv2 is used to modify the metadata of a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service, if they can trick the victim into running Exiv2 on a crafted image file. Note that this bug is only triggered when deleting the IPTC data, which is a less frequently used Exiv2 operation that requires an extra command line option (-d I rm). The bug is fixed in version v0.27.5.

Exiv2 is a command-line utility and C++ library for reading, writing, deleting, and modifying the metadata of image files. A null pointer dereference was found in Exiv2 versions v0.27.4 and earlier. The null pointer dereference is triggered when Exiv2 is used to print the metadata of a crafted image file. An attacker could potentially exploit the vulnerability to cause a denial of service, if they can trick the victim into running Exiv2 on a crafted image file. Note that this bug is only triggered when printing the interpreted (translated) data, which is a less frequently used Exiv2 operation that requires an extra command line option (-p t or -P t). The bug is fixed in version v0.27.5.