Raw vector
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:HCVSS and EPSS are reproduced from their sources (NVD, FIRST EPSS). Risk Priority is our own derived reading, not an NVD score.
Summary
CVE-2024-10395 is a high-severity Buffer Under-read (CWE-127) vulnerability in Zephyrproject Zephyr. Its CVSS base score is 8.6 (High).
Operationally, exploitation aligns with the MITRE ATT&CK technique Junk Data (T1001.001); ranked at the 22th percentile by exploit likelihood (below the median); it is not currently listed in the CISA KEV catalog.
The strongest mitigations our analysis identified map to RA-5 (Vulnerability Monitoring and Scanning) and SA-11 (Developer Testing and Evaluation) — see the control section below for these in your framework.
Deeper analysis AI-assisted summary
Synthesised by an AI model from the NVD description and linked references — a reading aid, not an authoritative source.
CVE-2024-10395 affects the Zephyr RTOS, specifically in the http_server_get_content_type_from_extension function, which lacks proper validation of the length of user input. This flaw, mapped to CWE-127, carries a CVSS v3.1 base score of 8.6 (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:H), indicating high severity due to its potential for significant availability disruption alongside limited confidentiality and integrity impacts.
Remote attackers require no privileges, can exploit it over the network with low complexity and no user interaction, and achieve low-level confidentiality and integrity effects while causing high availability impact, such as denial of service through improper handling of oversized input.
The Zephyr Project security advisory at https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-hfww-j92m-x8fv provides details on the vulnerability and mitigation guidance.
EU & UK References
- 🇪🇺 ENISA EUVD: EUVD-2024-33600
Vulnerability Data
No proper validation of the length of user input in http_server_get_content_type_from_extension.
- CWE(s)
Related Threats
MITRE ATT&CK Enterprise Techniques
CVEs Like This One
Affected Assets
Mitigating Controls
Mitigating Controls (NIST 800-53 r5) AI
Vulnerability scanning can locate known buffer-under-read instances in deployed code.
Developer testing and evaluation (static analysis, fuzzing, bounds checkers) directly finds buffer under-read flaws before deployment.
Security engineering principles require bounds-checked memory accesses and safe pointer arithmetic that structurally stop buffer under-reads from being introduced.
Mitigating Controls (NIST CSF 2.0) AI
Derived directly from the weakness types (CWEs) cited in the NVD entry via our AI-authored CWE→CSF cross-walk (authority under review) — links open the control.
Vulnerability scanning can discover buffer under-read flaws so they can be recorded and fixed.
Patching or replacing vulnerable software removes known instances of buffer under-read.
Secure-development practices such as bounds checking and static analysis directly prevent introduction of buffer under-reads.
Mitigating Controls (ISO/IEC 27001:2022 Annex A) AI
Derived directly from the weakness types (CWEs) cited in the NVD entry via our AI-authored CWE→ISO cross-walk (authority under review) — links open the control.
A.8.25 mandates secure SDLC practices including secure coding guidelines, security requirements, checkpoints, testing (scans/penetration), and developer training that reach buffer under-reads in custom code, but leaves a bounded remainder (e.g. third-party libraries, legacy code, or outsourced development without full assurance per the clause's own limits).
Application security requirements can specify safe buffer handling and bounds checking.
A.8.27 mandates applying security engineering principles (including secure-by-design, least privilege, distrust external input, hardening, and security-oriented design reviews) that reach buffer under-reads in custom code via input sanitization, bounds checking and attack-pattern review, but leaves a bounded remainder (e.g. unsafe library calls, unsafe third-party components, unsafe compiled binaries, and legacy code not re-engineered).
Secure coding standards directly require bounds checking and safe pointer arithmetic.
Security testing can detect buffer under-reads before release.