GIMP vulnerabilities

A flaw was found in GIMP. The XCF loader processes image-simulation-intent and image-simulation-bpc parasites without ensuring the parasite data is present before dereferencing it. Opening a specially crafted XCF file with a zero-size simulation parasite can cause a NULL pointer dereference and crash the GIMP application.

In GIMP 2.8.22, there is a heap-based buffer overflow in read_channel_data in plug-ins/common/file-psp.c.

In GIMP 2.8.22, there is a heap-based buffer over-read in the read_creator_block handler in plug-ins/common/file-psp.c.

In GIMP 2.8.22, there is a heap-based buffer over-read in ReadImage in plug-ins/common/file-tga.c, related to an unexpected bits-per-pixel value for an RGBA image.

In GIMP 2.8.22, there is a heap-based buffer overflow in the fli_read_brun function in plug-ins/file-fli/fli.c.

In GIMP 2.8.22, there is a heap-based buffer over-read in load_image in plug-ins/common/file-gbr.c, related to mishandling of UTF-8 data.

A use-after-free vulnerability in the xcf_load_image function in xcf-load.c in GIMP allows remote attackers to cause a denial of service (program crash) or possibly execute arbitrary code via a crafted XCF file.

A heap-based buffer overflow was found in GIMP’s Hot color filter plug-in. For very large images, a pixel buffer is allocated using overflowing 32-bit width * height (and related) arithmetic while the filter’s pixel access path uses the true image size, after integer overflow in the allocation size.

GIMP's raw data export plug-in contains a heap-based buffer overflow. When exporting very large images, sizing based on overflowing width * height * bytes-per-pixel can allocate far less memory than GEGL reads or writes during export, leading to a buffer overflow.

A heap-based buffer overflow was found in GIMP's PCX export plug-in. For images with extremely large width and height, buffer allocation uses overflowing 32-bit width * height arithmetic while subsequent GEGL operations use the full extent, after integer overflow in size calculation.

A heap-based buffer overflow exists in GIMP's GIF export plug-in. Exporting an image with very large width and height can cause a 32-bit overflow when computing the pixel buffer size, leading to an integer overflow and a mismatch between allocation and actual write by GEGL.

A flaw was found in GIMP's X cursor (XMC) thumbnail loader. When generating a thumbnail for a crafted XMC file, a pixel buffer is allocated using a width * height size computed in 32-bit signed arithmetic, which can overflow and lead to an out-of-bounds read on the heap.

A heap-based buffer overflow exists in GIMP's DirectDraw Surface (DDS) loader. When loading a crafted DDS image, buffer sizes derived from width, height, and pitch can overflow 32-bit arithmetic, causing the allocated buffer to be too small for the pixel data written through GEGL. This may lead to heap corruption and, in the worst case, arbitrary code execution in the context of the GIMP process.

A heap-based buffer overflow was found in GIMP's DICOM export plug-in. When exporting an image with extremely large width and height, the export path allocates a buffer using a 32-bit width * height (and bytes-per-pixel) product that can overflow. GEGL then writes the full uncompressed extent into the undersized buffer, after integer overflow in the allocation size.

In GIMP, when processing a specially crafted GIMPressionist preset file, the plug-in does not properly validate vector indices before writing into fixed-size arrays. This can lead to an out-of-bounds write, corrupting memory. An attacker could exploit this by convincing a user to load a malicious preset file, potentially causing a crash or enabling arbitrary code execution.

GIMP's uncompressed DDS image loader has a one-byte out-of-bounds heap read flaw. After processing the final pixel, the file-dds plug-in performs an unconditional one-byte look-ahead, which may cause a crash if the byte is inaccessible.

An out-of-bounds heap read flaw exists in GIMP's TIM image loader. When a user opens a crafted 4bpp TIM image that causes promotion to an RGBA layer, the file-tim plug-in allocates an undersized row buffer but processes it using the larger RGBA row size. This can copy adjacent heap contents into the decoded image and may crash the plug-in.

A heap-based buffer overflow vulnerability exists in the file-psd plugin in GIMP. When generating a thumbnail preview for a specially crafted PSD file, an integer overflow occurs during multiplication of values from an embedded JPEG header, leading to an undersized heap allocation and a heap-based buffer overflow during image decoding.

GIMP when processing a specially crafted lighting preset file does not properly validate the number of light sources in the Lighting Effects filter. This can lead to an out-of-bounds write, potentially causing a crash or enabling arbitrary code execution.

A flaw was found in GIMP's PSP (Paint Shop Pro) file loader. When processing a compressed selection channel, a heap-based buffer overflow can occur due to a mismatch between the allocated buffer size and the amount of data decompressed. A remote attacker could exploit this vulnerability by crafting a malicious PSP file. Opening this file in GIMP could lead to a crash or arbitrary code execution.

A flaw was found in GIMP's ICO file loader. When processing an ICO file containing an embedded PNG image, an integer overflow can occur during the calculation of the required buffer size. This leads to an undersized buffer being allocated, causing a heap-based buffer overflow when the decoded pixel data is written. A remote attacker could exploit this by crafting a malicious ICO file, which, when opened, could lead to arbitrary code execution or a crash.

The file-psd plugin in GIMP contains a flaw where the channel-count parameter is not properly validated when processing specially crafted PSD files. This leads to improper memory bounds checking, resulting in a heap out-of-bounds read and a stack out-of-bounds access. This can cause an application crash, leading to denial of service or limited information disclosure of memory contents.

A flaw was found in the file-pvr plugin in GIMP. When processing a specially crafted PVR image file, the VQ (compressed) decoder does not properly perform memory bounds checking. This missing validation results in a heap out-of-bounds read. This issue can result in an application crash, leading to a denial of service or a limited information disclosure of heap memory contents.

A flaw was found in the file-ico plugin in GIMP. When processing a specially crafted ICO image file, the plugin does not properly validate the used_clrs (palette count) parameter. This incorrect validation leads to improper memory bounds checking, resulting in a heap out-of-bounds read. This issue can result in an application crash, leading to a denial of service or a limited information disclosure of heap memory contents.

A flaw was found in the file-iff (IFF/ILBM) plugin in GIMP. When processing a specially crafted IFF/ILBM image file, the plugin does not properly validate the HAM row size and improperly handles cases where the number of color planes (nPlanes) is zero. This causes a row size mismatch that bypasses memory bounds checking, resulting in heap out-of-bounds reads. This issue can result in an application crash, leading to a denial of service or a limited information disclosure of heap memory contents.

The Seattle FilmWorks plugin in GIMP has a vulnerability involving unbounded stack allocation of a variable-length array when processing a specially crafted SFW file. This leads to an application crash and denial of service.

The file-xwd plugin in GIMP has a flaw due to incorrect validation of image width and bytes-per-line parameters when processing specially crafted XWD files. This leads to a heap out-of-bounds read.

The file-pix (ESM) plugin in GIMP contains a flaw where it allocates a Variable-Length Array (VLA) on the stack without proper bounds checking when processing a specially crafted PIX image file, causing an unbounded stack allocation followed by a 21-byte stack over-read. This can result in a denial of service due to stack exhaustion and a limited information disclosure of stack memory contents into an intermediate file.

A flaw was found in the file-pcx plugin in GIMP, affecting 32-bit builds only. When processing a PCX image file, the plugin calculates memory allocation sizes based on image dimensions and number of color planes. If a crafted file sets the number of planes to 4 alongside sufficiently large dimensions, the calculation exceeds the 32-bit integer limit and overflows, resulting in an undersized heap-based buffer allocation. This integer overflow issue results in a heap-based buffer overflow when the plugin subsequently writes image data into the undersized buffer, causing memory corruption, potentially leading to arbitrary code execution or a denial of service.

This vulnerability allows a remote attacker to execute arbitrary code in GIMP when parsing APNG files. The issue is due to lack of proper validation of user-supplied data, leading to an integer overflow before buffer allocation. User interaction is required, such as opening a malicious file.

This vulnerability allows a remote attacker to execute arbitrary code in GIMP when parsing TIF files. The issue is due to lack of proper validation of user-supplied data, leading to an integer overflow before buffer allocation. User interaction is required, such as opening a malicious file.

This vulnerability allows a remote attacker to execute arbitrary code in GIMP when parsing TIF files. The issue is due to lack of proper validation of the length of user-supplied data before copying it to a heap-based buffer, leading to a heap-based buffer overflow. User interaction is required, such as opening a malicious file.

This vulnerability allows a remote attacker to execute arbitrary code in GIMP when parsing SGI files. The issue is due to lack of proper validation of user-supplied data, leading to an integer overflow before writing to memory. User interaction is required, such as opening a malicious file.

This vulnerability allows a remote attacker to execute arbitrary code in GIMP when parsing TIF files. The issue is due to lack of proper validation of user-supplied data, leading to an integer overflow before buffer allocation. User interaction is required, such as opening a malicious file.

This vulnerability allows a remote attacker to execute arbitrary code in GIMP when parsing TIF files. The issue is due to lack of proper validation of user-supplied data, leading to an integer overflow before buffer allocation. User interaction is required, such as opening a malicious file.

This vulnerability allows a remote attacker to execute arbitrary code in GIMP when parsing TIF files. The issue is due to lack of proper validation of the length of user-supplied data before copying it to a stack-based buffer, leading to a stack-based buffer overflow. User interaction is required, such as opening a malicious file.

This vulnerability allows a remote attacker to execute arbitrary code in GIMP when parsing TIF files. The issue is due to lack of proper validation of the length of user-supplied data before copying it to a heap-based buffer, leading to a heap-based buffer overflow. User interaction is required, such as opening a malicious file.

This vulnerability allows a remote attacker to execute arbitrary code in GIMP when parsing PSD files. The issue is due to lack of proper validation of user-supplied data, leading to an integer overflow before buffer allocation. User interaction is required, such as opening a malicious file.

This vulnerability allows a remote attacker to execute arbitrary code in GIMP when parsing HDR files. The issue is due to lack of proper validation of user-supplied data, leading to an integer overflow before buffer allocation. User interaction is required, such as opening a malicious file.

GIMP's file format plugins, including those for PSD and PAA files, contain a vulnerability that a remote attacker can exploit by tricking a user into opening a specially crafted image file. This could lead to unexpected application behavior or other potential security impacts.

A flaw was found in GIMP's PSD file format plugin. This vulnerability, an unsigned integer underflow in the `block_rem` variable, occurs when a user opens a specially crafted `.psd` image file. The underflow leads to parser confusion, enabling an attacker to inject arbitrary data as layer resource blocks. This can ultimately result in arbitrary code execution.

GIMP has a signed integer overflow vulnerability in the file-fli plugin when processing FLI files, which can lead to application crashes.

A flaw was found in the GIMP image manipulation program, specifically within its Seattle Filmworks file loader. A remote attacker could exploit this vulnerability by tricking a user into opening a specially crafted Seattle Filmworks file. This could lead to a heap overflow, allowing the attacker to write several kilobytes of controlled data beyond the intended memory buffer. Such an overflow can result in memory corruption, potentially leading to arbitrary code execution or a denial of service.

A heap-based buffer overflow vulnerability exists in the GIMP DDS (DirectDraw Surface) file parser. When a crafted DDS file declares a D3D9 pixel format but sets a lower bits-per-pixel (bpp) value in the header, the loader allocates an undersized heap buffer. Subsequent pixel data consumption at the real format's stride causes a write past the heap buffer boundary, leading to heap metadata corruption and potential code execution.

A heap-buffer-overflow vulnerability exists in the APNG (Animated PNG) file loader of GIMP. This flaw occurs when the fcTL width exceeds the IHDR width, leading to pixel data being written past the end of a heap allocation. Additionally, a heap-based buffer overflow exists in the DDS plug-in due to a BPP mismatch in the load_layer() function. Both vulnerabilities can be triggered by opening a specially crafted image file, potentially leading to code execution.

A flaw was found in GIMP. A remote attacker could exploit this by tricking a user into opening a specially crafted PAA (Paint Shop Pro Array) image file. This vulnerability, a heap-based out-of-bounds write in the decode_lssz() function of the PAA file format plugin, allows data to be written beyond the intended memory buffer. This could lead to heap metadata corruption and potentially enable the attacker to execute arbitrary code on the affected system.

A flaw was found in GIMP's file-png plugin. A remote attacker can exploit this by crafting a malicious Animated Portable Network Graphics (APNG) image containing an oversized tRNS chunk. This can lead to a stack-based buffer overflow (CWE-121), causing the file-png plugin to crash and resulting in a Denial of Service (DoS) for the user.

A flaw was found in the file-icns plugin in GIMP. When applying a decompressed mask during ICNS image processing, the plugin reads from the mask data buffer without verifying if the cursor exceeds the allocated resource size. This out-of-bounds read vulnerability results in information disclosure of heap contents or a crash leading to a denial of service.

A flaw was found in the file-fits plugin in GIMP. When processing a FITS image file, the plugin calculates memory allocation sizes using signed 32-bit integers for width and height. If a crafted file sets both values to large values, their product exceeds 2^31 and overflows, resulting in an undersized heap-based buffer allocation. This integer overflow issue results in a heap-based buffer overflow, potentially leading to arbitrary code execution or a denial of service.

A flaw was found in the file-sgi plugin in GIMP. When processing an RLE-compressed SGI image, the plugin allocates memory for a row table. The image header dimensions (ysize and zsize) are read as 16-bit unsigned integers. If a crafted file sets both dimensions to their maximum value (65535), the multiplication ysize * zsize overflows the standard 32-bit int boundary before being passed to calloc. This integer overflow issue results in undefined behavior, aborting the plugin and causing a denial of service.