Prototype Pollution in compromise NLP Library

Executive Summary

CVE-2026-15699 is a prototype pollution vulnerability in the spencermountain compromise library up to version 14.15.1. The vulnerability exists in the `nlp.extend` function within the file `src/API/extend.js`.

Prototype pollution occurs when an attacker manipulates the properties of `Object.prototype` by injecting malicious properties. In this case, the vulnerability allows an attacker to pass a crafted plugin object containing unsafe keys like `__proto__`, `constructor`, or `prototype` to the `nlp.extend()` API. The library's merge logic does not filter these keys, leading to their unintended assignment to `Object.prototype`.

This can result in unexpected behavior, such as logic bypasses, denial of service, or other security issues, especially if user-controlled input is used to construct plugins. The vulnerability is remotely exploitable, and a proof-of-concept exploit is publicly available.

• The root cause is the unsafe recursive merge process, which iterates over attacker-controlled keys and descends into prototype chains without proper validation.
• The recommended fix involves filtering out unsafe keys during the merge process and using safer property enumeration methods like `Object.keys()` or `Object.entries()`.

Useful 0 Not Useful 0

Detection Guidance

Detecting this vulnerability involves checking if your system is using a vulnerable version of the compromise library (up to 14.15.1) and verifying if the prototype pollution issue exists. Below are some steps and commands to help detect the vulnerability.

• Check the installed version of the compromise library in your project. You can do this by inspecting the package.json file or running: npm list compromise
• If the version is 14.15.1 or earlier, the system is vulnerable. Verify the version with: node -e "console.log(require('./node_modules/compromise/package.json').version)"
• Test for prototype pollution by attempting to inject a property into Object.prototype using the nlp.extend API. For example, run a script that includes: const nlp = require('compromise'); nlp.extend({ model: { __proto__: { polluted: true } } }); if (({}).polluted) { console.log('Vulnerable to prototype pollution'); }
• Monitor network traffic or logs for unexpected plugin extensions or suspicious input passed to the nlp.extend function, particularly those containing keys like __proto__, constructor, or prototype.

Useful 0 Not Useful 0

Impact Analysis

If you are using the spencermountain compromise library (version 14.15.1 or earlier) in your application, this vulnerability could have several impacts:

• Prototype pollution: An attacker could inject malicious properties into `Object.prototype`, which may affect all objects in your application. This can lead to unexpected behavior, such as breaking assumptions in your code or causing logic errors.
• Security bypasses: If your application relies on object properties for security checks (e.g., authentication or authorization), an attacker could manipulate these properties to bypass security controls.
• Denial of Service (DoS): The pollution of `Object.prototype` could cause your application to crash or become unresponsive, leading to a denial of service.
• Remote exploitation: Since the vulnerability is remotely exploitable, an attacker could trigger it by sending crafted input to your application, even without direct access to your system.

If your application processes user-controlled input to construct plugins or extensions for the compromise library, the risk is higher, as an attacker could exploit this vulnerability to manipulate the behavior of your application.

Useful 0 Not Useful 0

Compliance Impact

This vulnerability could impact compliance with common standards and regulations in the following ways:

• GDPR (General Data Protection Regulation): If the vulnerability leads to unauthorized access or manipulation of personal data, it could result in a data breach. Under GDPR, organizations must implement appropriate security measures to protect personal data. Failure to address this vulnerability could lead to non-compliance, resulting in fines or legal action.
• HIPAA (Health Insurance Portability and Accountability Act): For organizations handling protected health information (PHI), this vulnerability could compromise the integrity or confidentiality of PHI. HIPAA requires safeguards to protect PHI, and a breach caused by this vulnerability could lead to violations and penalties.
• Other standards (e.g., ISO 27001, NIST): Many security standards require organizations to maintain secure coding practices and address vulnerabilities promptly. Failure to patch or mitigate this vulnerability could result in non-compliance with these standards, potentially affecting certifications or audits.

To maintain compliance, it is critical to apply the recommended patch or upgrade to a fixed version of the library. Additionally, organizations should review their applications for signs of exploitation and ensure that user-controlled input is properly sanitized and validated.

Useful 0 Not Useful 0

Mitigation Strategies

To mitigate this vulnerability, follow these immediate steps:

• Apply the patch provided by the vendor. The fix is available in the commit b4644ab7179700df0607521f61c1ee9b5f78d89d. Update the compromise library to the latest version that includes this patch.
• If updating is not immediately possible, implement input validation to prevent the use of unsafe keys like __proto__, constructor, or prototype in any plugin passed to nlp.extend.
• Use Object.create(null) to create objects that do not inherit from Object.prototype, reducing the risk of prototype pollution during merges.
• Avoid using user-controlled input to construct plugins or models passed to nlp.extend. Sanitize all inputs to ensure they do not contain prototype-pollution primitives.
• Monitor for any unusual behavior or unexpected properties appearing in Object.prototype, which may indicate an ongoing exploitation attempt.

Useful 0 Not Useful 0