Speex (libspeex) versions through 1.2.1 have an out-of-bounds write vulnerability in the speex_bits_read_whole_bytes() function. This flaw occurs due to improper handling of length truncation for non-owned SpeexBits buffers, allowing attackers to stream crafted data that can corrupt heap or stack memory and cause application crashes.
A double free vulnerability exists in libyal libmsiecf through version 20260525 in the function libmsiecf_url_values_read_data(). This flaw allows attackers to corrupt heap memory by supplying a crafted MSIE cache index.dat file with an oversized unknown_offset in a partial URL record. The vulnerability can cause forensic tools processing such files to crash.
A medium-severity information disclosure vulnerability exists in TOTOLINK A950RG version 4.1.2cu.5268_B20221104. The flaw is in the getLanguageCfg function of the global.so file and can be exploited remotely without authentication. Public exploit code is available for this vulnerability.
VMime versions through 0.9.2 have an information disclosure vulnerability in the uuEncoder::decode function. This flaw causes uninitialized stack memory to be written into decoded output when processing over-long lines in uuencode or x-uuencode MIME parts. An attacker can exploit this by sending crafted MIME parts with large line length bytes, potentially leaking up to 15 bytes of stack memory per line in decoded attachments.
libcss versions through 0.9.2 have a NULL pointer dereference vulnerability in the mq_parse_media_query() function. This flaw allows remote attackers to cause a denial of service by supplying media lists that end with a trailing comma, which can crash parsers like NetSurf when processing @media or @import rules in stylesheets.
A heap out-of-bounds read vulnerability exists in libphdi through version 20260902 in the function libphdi_data_files_get_extent_data_file_path. The flaw arises because the function uses the directory prefix length instead of the basename length when processing Parallels disk image descriptors. An attacker can craft a descriptor with a long directory prefix and short basename to cause a process crash or potentially expose adjacent heap memory.
Furnace versions up to 0.6.8.3 have an out-of-bounds write vulnerability in the DivEngine::loadFTM() function. This flaw allows attackers to corrupt heap memory by using an unchecked subsong index in the GROOVES block of a crafted FamiTracker module. Specifically, a subsong count of 2 or more can cause a groove pattern to be written past the subsong vector, leading to a crash when Furnace opens the module.
libpff versions through 20260926 have an off-by-one bounds check vulnerability in the function libpff_table_read_6c_record_entries. This flaw allows attackers to trigger a heap out-of-bounds read by supplying crafted 6c table record entries in PST, OST, or PAB files. Exploitation can lead to reading adjacent heap memory or application crashes in tools like pffexport or pypff.
VMime versions through 0.9.2 have an integer underflow vulnerability in the uuEncoder::decode function. This flaw allows remote attackers to craft uuencoded MIME parts in emails that trigger a stack-based buffer overflow. Specifically, sending a uuencoded line with a length character 'b' that is not a 'begin' line can corrupt stack memory, potentially crashing the application or enabling code execution.
Libpff through 20260926 has a heap out-of-bounds read vulnerability in the function libpff_table_read_values_array. This occurs because the values_array_size of a 7c column definition is not validated against the remaining buffer bytes. An attacker can exploit this by supplying a crafted PST, OST, or PAB file, potentially causing applications to read adjacent heap memory or crash.
flatcc versions up to 0.6.4 have an out-of-bounds read vulnerability in the __flatcc_json_parser_number function. This flaw allows attackers to read beyond the input buffer when parsing JSON numbers that end with a decimal point. Supplying crafted JSON input ending immediately after a decimal point can cause the parser to access unmapped memory, leading to application crashes.
libdwarf versions through 2.3.3 have a heap out-of-bounds read vulnerability in the dwarf_debug_addr_table() function. This flaw occurs because the function omits the table starting offset when validating the .debug_addr unit length. An attacker can exploit this by supplying a crafted object file with a non-zero offset table, causing dwarf_debug_addr_by_index() to read beyond the allocated heap buffer. This can lead to disclosure of adjacent heap memory or cause a crash in the consuming application.
gbsplay version 0.0.103 contains an out-of-bounds read vulnerability in the mapper_map() function within mapper.c. This flaw occurs because the function does not properly reject ROM bank indexes that exceed the ROM size, leading to an underflowed bank length. Crafted .gbr, .gbs, or .gb files with malicious bank indexes can cause the bank_get() function to read beyond the allocated heap ROM buffer, resulting in a crash of the player application.
FLTK versions through 1.4.5 have an integer overflow vulnerability in the Fl_BMP_Image::load_bmp_() function. This flaw causes an undersized pixel buffer allocation based on file-supplied width and height values. An attacker can craft a BMP or ICO file with large dimensions that triggers a heap buffer overflow during row decoding, leading to heap corruption.
gbsplay version 0.0.103 has a heap out-of-bounds read vulnerability in the vgm_open() function within gbs.c. This flaw occurs because the function processes the VGM command stream without proper bounds checking. An attacker can exploit this by providing a specially crafted VGM file containing wait opcodes but lacking the required 0x66 terminator, causing the player to read beyond the allocated heap buffer and potentially crash.
Gbsplay versions up to 0.0.103 have a heap out-of-bounds read vulnerability in the gbr_open() function within gbs.c. This flaw occurs because the function does not verify the file length before scanning the GBR ROM title field, allowing crafted GBR files between 0x21 and 0x162 bytes to cause out-of-bounds reads. Exploitation can lead to application crashes or memory leakage.
A heap out-of-bounds read vulnerability exists in libfvde versions through 20260923. The flaw occurs in the function libfvde_encrypted_metadata_read_type_0x0024() due to missing bounds checking on xml_plist_data_size against the source metadata block. This can lead to a crash when processing a specially crafted FileVault 2 Core Storage volume.
Furnace versions up to 0.6.8.3 have an out-of-bounds heap read vulnerability in the DivEngine::loadFTM() function. This flaw occurs when importing FamiTracker modules with a crafted instrument note count exceeding 120, causing the application to read beyond the noteMap array and crash. The vulnerability affects .ftm, .dnm, and 0CC/E-FamiTracker module files.
FLTK versions through 1.4.5 have a stack-based buffer overflow vulnerability in the Fl_BMP_Image::load_bmp_() function. This flaw occurs when an attacker supplies a BMP or ICO file with a colors_used field value exceeding 256, overflowing a 768-byte colormap array. The vulnerability can lead to application crashes or potentially allow code execution.
A cross-site scripting (XSS) vulnerability exists in itsourcecode Airline Reservation System 1.0 in the /book_flight.php file. The flaw arises from improper handling of the 'max' argument, allowing remote attackers to execute script code. Public exploit code is available. The vulnerability has a medium severity rating with a CVSS score of 4.3.