# OBJECT TRONG JAVASCRIPT?
Có một sự thật là hầu như mọi thứ trong javascript đều là object
Trong JavaScript, một object là một thực thể có các properties (thuộc tính) và methods (phương thức). Nó là một cấu trúc dữ liệu linh hoạt và mạnh mẽ, cho phép bạn lưu trữ và truy cập dữ liệu theo cặp **key:value** . Ví dụ với một đối tượng user có thể khai báo như sau:
```javascript
const user = {
username: "nightcore",
userId: 0127,
isAdmin: false
}
```
Bạn cũng có thể truy cập tới các thuộc tính của đối tượng bằng cách sử dụng dấu . hoặc là cặp dấu []
```javascript
user.username
user['userId']
// "nightcore"
// 0127
```
Tương tự với data, các thuộc tính cũng có thể là một hàm thực thi, các hàm này được gọi là các method (phương thức)
```javascript
const user = {
username: "nightcore",
userId: 0127,
exampleMethod: function(){
// do something
}
}
```
Để khởi tạo một object ta có nhiều cách khác nhau ví dụ:
**1. Sử dụng Object Literal:**
```javascript
const person = {
firstName: "John",
lastName: "Doe",
age: 50,
eyeColor: "blue"
};
```
hoặc
```javascript
const person = {};
person.firstName = "John";
person.lastName = "Doe";
person.age = 50;
person.eyeColor = "blue";
```
**2. Sử dụng Keyword new**
```javascript
const person = new Object();
person.firstName = "John";
person.lastName = "Doe";
person.age = 50;
person.eyeColor = "blue";
```
**3. Thông qua kế thừa từ một object khác bằng cách sử dụng Object.create()**
```javascript
var user = Object.create(person);
```
## PROTOTYPE TRONG JAVASCRIPT?
Một đối tượng a được liên kết với một đối tượng b thì đối tượng b được gọi là nguyên mẫu (prototype) của a.
Trong JS, mặc định một Object sẽ tự động được gán các nguyên mẫu tích hợp sẵn.
```javascript
let myObject = {};
Object.getPrototypeOf(myObject); // Object.prototype
let myString = "";
Object.getPrototypeOf(myString); // String.prototype
let myArray = [];
Object.getPrototypeOf(myArray); // Array.prototype
let myNumber = 1;
Object.getPrototypeOf(myNumber); // Number.prototype
```
Trong JS các Object tự động kế thừa các thuộc tính của nguyên mẫu (trừ khi chúng có một thuộc tính riêng cùng một key được xác định trước)
Dùng console của trình duyệt:
Ta có thể thấy Object này kế thừa rất nhiều thuộc tính và phương thức tích hợp sẵn của Object.prototype
>**Object tự động kế thừa các thuộc tính của nguyên mẫu.**
Ví dụ: Nguyên mẫu `String.prototype` có một method là `removeWhitespace` :
```javascript
String.prototype.removeWhitespace = function(){
// remove leading and trailing whitespace
}
```
Nó sẽ được kế thừa và sử dụng như sau :
```javascript
let searchTerm = " example ";
searchTerm.removeWhitespace(); // "example"
```
## TRUY CẬP PROTOTYPE CỦA MỘT ĐỐI TƯỢNG
Để truy cập tới prototype của một đối tượng thì ta có thể sử dụng nhiều cách như
```javascript
var person = new Person("nightcore");
person.__proto__;
person["__proto__"];
person.constructor.prototype;
Object.getPrototypeOf(person);
```
**Xét ví hình ảnh sau:**
Từ ảnh trên, ta có thể truy cập nguyên mẫu của Object bằng `__proto__` như sau :
```javascript
username.__proto__ // String.prototype
username.__proto__.__proto__ // Object.prototype
username.__proto__.__proto__.__proto__ // null
```
Ví dụ ta có thể sửa, thêm, các thuộc tính thông qua prototype object
# PROTOTYPE POLLUTION LÀ GÌ?
Giống như cái tên đã thể hiện ra Prototype Pollution là Ô nhiễm nguyên mẫu. Đây là một lỗ hổng bảo mật xảy ra khi tấn công vào việc thay đổi đối tượng prototype trong JavaScript một cách không an toàn. Điều này có thể xảy ra khi các đối tượng JavaScript cho phép việc mở rộng và chỉnh sửa prototype của chúng.
Cụ thể nguyên mẫu mà mình cần làm ô nhiễm đó chính là `Object.prototype` , bởi vì khi prototype của một đối tượng được sửa đổi một cách không an toàn, các thuộc tính hoặc phương thức có thể được thêm, thay đổi hoặc xóa một cách không mong muốn. Điều này có thể dẫn đến những hậu quả nghiêm trọng, bao gồm việc thay đổi hoạt động của các đối tượng đã tồn tại, gây ra lỗi trong mã nguồn và thậm chí tiềm ẩn các lỗ hổng bảo mật.
Ví dụ một ứng dụng web có phân quyền người dùng là user và admin , giả ứng dụng này có sử dụng một đoạn code để check admin:
```javascript
if (user.isAdmin == true) {
// Admin Dashboard
}
```
Nếu như mình có thể thao túng `Object.prototype` và gán thêm một thuộc tính `isAdmin = true` thì lúc này `user.isAdmin` sẽ luôn có giá trị là true → mọi user đều có thể access admin và thực hiện các thao tác không mong muốn
## PROTOTYPE POLLUTION XUẤT HIỆN KHI NÀO?
Lỗ hổng prototype pollution thường xảy ra khi một hàm JavaScript kết hợp một đối tượng chứa các thuộc tính có thể điều khiển bởi người dùng vào một đối tượng hiện có mà không trước tiên làm sạch các khóa(key). Điều này cho phép kẻ tấn công inject một thuộc tính với khóa như `__proto__` , cùng với các thuộc tính lồng nhau tùy ý.
Do ý nghĩa đặc biệt của `__proto__` trong ngữ cảnh JavaScript, quá trình kết hợp có thể gán các thuộc tính lồng nhau vào prototype của đối tượng thay vì đối tượng mục tiêu. Kết quả, kẻ tấn công có thể gây ra prototype pollution với các thuộc tính chứa giá trị nguy hiểm, sau đó có thể được ứng dụng sử dụng một cách nguy hiểm.
Có thể ô nhiễm bất kỳ nguyên mẫu nào, nhưng điều này thường xảy ra với đối tượng nguyên mẫu toàn cục được tích hợp sẵn `Object.prototype`
## PROTOTYPE POLLUTION SOURCES
Prototype pollution sources thường là các input mà người dùng có thể kiểm soát được như là:
**Prototype pollution via the URL**
Khi xử lý URL, các trình phân tích thường chuyển đổi chuỗi truy vấn thành các đối tượng JavaScript. Tuy nhiên, nếu không được xử lý cẩn thận, điều này có thể dẫn đến prototype pollution và thay đổi hành vi của ứng dụng. Ví dụ, kẻ tấn công có thể chèn các thuộc tính độc hại vào URL như sau
```javascript
https://vulnerable-website.com/?__proto__[evilProperty]=payload
```
Trong ví dụ này, chuỗi truy vấn `__proto__[evilProperty]=payload` được truyền vào ứng dụng thông qua URL. Khi ứng dụng xử lý URL và chuyển đổi chuỗi truy vấn thành đối tượng JavaScript, thuộc tính `__proto__` sẽ được coi là một thuộc tính của `prototype` của đối tượng, và thuộc tính `evilProperty` sẽ được thêm vào prototype đó
```javascript
{
existingProperty1: 'foo',
existingProperty2: 'bar',
__proto__: {
evilProperty: 'payload'
}
}
```
**Prototype pollution via JSON input**:
Thông thường, để chuyển đổi chuỗi JSON thành đối tượng JavaScript, chúng ta sử dụng phương thức `JSON.parse()` . Tuy nhiên, phương thức này xử lý các khóa trong đối tượng JSON như là các chuỗi tùy ý, bao gồm cả những khóa như `__proto__` .
Điều này cung cấp một cơ chế tiềm năng khác để thực hiện prototype pollution. Giả sử kẻ tấn công tiêm vào một chuỗi JSON độc hại như sau, ví dụ như thông qua một tin nhắn web:
```javascript
{
"__proto__": {
"evilProperty": "payload"
}
}
```
Nếu chuỗi JSON này được chuyển đổi thành một đối tượng JavaScript bằng phương thức `JSON.parse()`, đối tượng kết quả sẽ thực sự có một thuộc tính với khóa là `__proto__` :
Khi gọi `__proto__` ở trong JSON thì nó giống như trỏ đến một property bình thường. Còn khi khi gọi `__proto__` ở trong Object literal thì nó sẽ trỏ đến `Object.prototype
Nếu đối tượng được tạo ra thông qua `JSON.parse()` được kết hợp vào một đối tượng hiện có mà không có việc làm sạch khóa đúng cách, điều này sẽ dẫn đến prototype pollution trong quá trình gán, giống như ví dụ dựa trên URL đã được đề cập trước đó.
## PROTOTYPE POLLUTION SINKS
Prototype pollution sink thực chất chỉ là một hàm JavaScript hoặc phần tử DOM mà bạn có thể truy cập thông qua prototype pollution, cho phép bạn thực thi mã JavaScript hoặc các lệnh hệ thống tùy ý.
## PROTOTYPE POLLUTION XẢY RA KHI NÀO ?
Prototype pollution xảy ra khi lập trình viên không biết về mối nguy hiểm khi vô tình cho phép attacker thêm/sửa/xóa `Object.prototype`.
Ta sẽ phân tích một số case tiêu biểu:
### CASE 1: HÀM MERGE()
Giả sử ta muốn hợp nhất 2 object a và b như sau:
```javascript
let a = { a: 1, b: 2}
let b = { b: 3, c: 4}
```
Điều ta mong muốn là tạo ra 1 object c có dạng:
```javascript
c = { a: 1, b: 3, c: 4}
```
Để giải quyết việc này, trong 1 vài thư viện thì các developer đã xây dựng ra hàm `mere()`
```javascript
let c = merge(a,b); //Lúc này c sẽ có dạng { a: 1, b: 3, c: 4} như ta mong muốn
```
Hàm merge() này có cách hoạt động như sau:
```javascript
function merge(a, b) {
for (var att in b) {
if (typeof a[att] === "object" && typeof b[att] === "object") {
merge(a[att], b[att]);
}
else {
a[att] = b[att];
}
}
return a;
}
```
Hàm `merge()` sẽ duyệt qua các thuộc tính của b, nếu như thuộc tính này ở cả object a và b đều là `object` thì `merge()` sẽ đệ quy tiếp, nếu không thỏa mãn điều kiện này thì `merge()` sẽ gán thuộc tính của b vào a. Lý do tại sao thuộc tính b = 3 chứ không phải b = 2 thì chính là do khối code ở else thực hiện.
Vậy nếu như b không phải một object đơn thuần như trên thì sao.
```javascript
let b = JSON.parse('{"__proto__":{"polluted": 1}}');
```
Khi gọi `__proto__` ở trong JSON thì nó giống như trỏ đến một property bình thường.
Nếu như bạn gán cho một object được khai báo bằng Object literal như này
```javascript
var b = { __proto__: { " polluted": 1 } };
```
Lúc này thì `__proto__` sẽ trỏ đến `Object.prototype` và sửa đổi `Object.prototype` thành `{ " polluted": 1 }` . Hàm merge() sẽ không chạy như ta mong muốn.
Để hiểu rõ tại sao thì ta cùng di phân tích đoạn code dưới đây:
```javascript
function merge(a, b) {
for (var att in b) {
if (typeof a[att] === "object" && typeof b[att] === "object") {
merge(a[att], b[att]);
}
else {
a[att] = b[att];
}
}
return a;
}
var a = { a: 1, b: 1 };
var b = JSON.parse('{"__proto__":{"polluted": 1}}');
var c = merge(a, b); //hàm merge được gọi
var d = {};
console.log(d.polluted); //trả về 1
```
**Bước 1:** Vòng for sẽ duyệt qua tất cả thuộc tính của b , b chính là object được tạo bởi JSON.parse và có thuộc tính `__proto__`.
>Vì sao khi dùng var `b = { __proto__: { " polluted": 1 } };` thì không được ? Vì vòng for này sẽ không thấy được thuộc tính `__proto__` , bởi `for (var att in b)` không cho phép tìm các `magic property`.
**Bước 2:** Đi đến khối if , lúc này khối if sẽ kiểm tra `a["__proto__"]` và `b["__proto__"]` có phải là dạng object không?
`a[__proto__]` chính là `Object.prototype` và `Object.prototype` như mình đã phân tích thì nó là một object, còn `b[__proto__]` là `{"polluted": 1 }` thì đương nhiên `{ "polluted": 1 }` cũng là `object`.
**Bước 3:** Sau khi thấy cả `a[__proto__]` và `b[__proto__]` cùng là `object` thì sẽ tiến hành đệ quy.
>Nhớ rằng ở đây `a[__proto__] === Object.prototype` , `b[__proto__] === {"polluted": 1}`
**Bước 4:** Hàm `merge()` nhận 2 tham số là `Object.prototype` và `{"polluted": 1}` (đại diện cho lần lượt a và b) . Ở đây mình quy ước `a2 === Object.prototype` và `b2 === {"polluted": 1}`
**Bước 5:** Vòng for sẽ duyệt qua thuộc tính của b2 , và b2 có thuộc tính `polluted` .
Tiếp đến khối if sẽ kiểm tra `a2["polluted"]` tương ứng với `Object.prototype.polluted` và `b2["polluted"]` có phải là dạng `object` không?
Ở đây `a2["polluted"] = undefined` , còn `b2["polluted"] = 1` . Vậy ở đây cả 2 điều kiện đều không thỏa mãn, dừng đệ quy và đi đến khối else.
**Bước 6:** Khối else sẽ thực hiện `a2["polluted"] = b2["polluted"]` . Viết trực quan ra thì nó sẽ là `Object.prototype.polluted = 1` .
Vậy ta đã có thể làm cho `Object.prototype` có thêm thuộc tính là `polluted` . Khi đó toàn bộ các object nào kế thừa từ `Object.prototype` sẽ đều có thuộc tính `polluted` với giá trị `1` .
### CASE 2: HÀM CLONE()
Bản chất hàm này cũng được tạo nên từ hàm merge() .
Code triển khai của hàm clone()
```javascript
function clone(a) {
return merge({}, a);
}
```
### CASE 3: PATH ASSIGNMENT OPERATION
Code minh hoạ:
```javascript
var obj = { b : {"test":321}};
setValue(obj, "b.test", 123);
obj.b.test //trả về 123
```
Các thư viện sử dụng đoạn code trên cho phép gán giá trị theo đường `b.test` và đặt giá trị là `123` . Ở đây ta có thể khai thác bằng cách sử dụng giống như việc thay đổi `Object.prototype` bằng magic property `__proto__` .
Đoạn code với exploit payload:
```javascript
var obj = {};
setValue(obj, "__proto__.polluted", 1);
var d = {};
d.polluted; //trả về 1
```
## KẾT LUẬN
Bản chất cách khai thác của lỗi này đến từ việc cho phép `access` vào `Object.prototype` . Vậy nên các `pattern` cho phép `access` vào `Object.prototype` đều có thể dẫn đến lỗi.
Nếu như dùng Object Literal thì chỉ cần thông qua một lần trỏ đến `__proto__` là có thể `access` vào `Object.prototype` .
Nếu thông qua một object được kế thừa qua `n` prototype khác thì tương ứng với `n` lần trỏ đến `__proto__` .
```javascript
username.__proto__ // String.prototype
username.__proto__.__proto__ // Object.prototype
username.__proto__.__proto__.__proto__ // null
```
## PHÒNG CHỐNG
Để phòng chống lỗ hổng prototype pollution, bạn có thể áp dụng các biện pháp sau:
1. Kiểm tra và làm sạch các khóa thuộc tính: Trước khi hợp nhất các đối tượng, hãy kiểm tra và làm sạch các khóa thuộc tính để ngăn chặn việc chèn khóa nguy hiểm như `__proto__` trỏ tới `prototype` của đối tượng. Sử dụng danh sách cho phép (whitelist) là phương pháp hiệu quả nhất. Nếu không thể sử dụng danh sách cho phép, bạn có thể sử dụng danh sách cấm (blacklist) để loại bỏ các chuỗi tiềm năng gây nguy hiểm từ đầu vào người dùng.
2. Ngăn chặn thay đổi các đối tượng `prototype`: Sử dụng phương pháp `Object.freeze()` để đảm bảo rằng các thuộc tính và giá trị của đối tượng không thể bị thay đổi và không thể thêm thuộc tính mới. Áp dụng `Object.freeze()` cho `Object.prototype` để ngăn chặn thay đổi các đối tượng `prototype` :
```javascript
Object.freeze(Object.prototype);
```
3. Ngăn chặn việc kế thừa các thuộc tính: Sử dụng phương pháp `Object.create(null)` để tạo đối tượng với `prototype` là `null`. Điều này đảm bảo đối tượng không kế thừa bất kỳ thuộc tính nào từ `Object.prototype` .
```javascript
let myObject = Object.create(null);
Object.getPrototypeOf(myObject); // null
```
4. Sử dụng các đối tượng có bảo vệ tích hợp: Sử dụng các đối tượng có sẵn trong JavaScript như Map và Set có thể cung cấp bảo vệ tích hợp chống lại lỗ hổng prototype pollution. Ví dụ, khi định nghĩa một đối tượng options, bạn có thể sử dụng Map thay vì object thông thường. Map có phương thức `get()` tích hợp sẵn chỉ trả về các thuộc tính được định nghĩa trực tiếp trên Map.
```javascript
let options = new Map();
options.set('transport_url', 'https://normal-website.com');
options.transport_url; // undefined
options.get('transport_url'); // 'https://normal-website.com'
```
Tương tự, Set cũng là một lựa chọn nếu bạn chỉ lưu trữ các giá trị mà không cần cặp `key:value` . Set cung cấp phương thức `has()` tích hợp sẵn để kiểm tra xem một giá trị có tồn tại trong Set hay không.
```javascript
let options = new Set();
options.add('safe');
options.safe; // undefined
options.has('safe'); // true
```
>Lưu ý rằng việc áp dụng các biện pháp trên chỉ là một phần trong việc bảo vệ chống lại lỗ hổng prototype pollution. Để đảm bảo an toàn tối đa, hãy luôn theo dõi và cập nhật mã nguồn, bao gồm cả các thư viện bên thứ ba, để đảm bảo rằng không có lỗ hổng mới được tạo ra và khai thác được
# LABS
## COWSAY AS A SERVICE - ACSC CTF 2021
Mục tiêu là lấy được giá trị tron biến môi trường `$FLAG`
Chall cho ta trang web như sau
<details>
<summary>index.js</summary>
```javascript
import Koa from 'koa';
import Router from '@koa/router';
import auth from 'koa-basic-auth';
import bodyParser from 'koa-bodyparser';
import child_process from 'child_process';
const settings = {};
const style = `<style>
body { padding: 2rem; }
.form input[type=text] { padding: .5rem 1rem; font-size: 1rem; display: block; margin-bottom: 1rem; }
.form input[type=submit] { display: block; margin-bottom: 1rem; color: #fff; background-color: #000; padding: .5rem 1rem; font-size: 1rem; border: none; }
.color-setting { margin-bottom: 1rem; }
.cowsay { font-size: 2rem; background: #beead6; padding: 0.5rem 1rem; }
</style>`;
const app = new Koa();
const router = new Router();
// basic auth
if (process.env.CS_USERNAME && process.env.CS_PASSWORD) {
app.use(auth({
name: process.env.CS_USERNAME,
pass: process.env.CS_PASSWORD
}))
}
app.use(async (ctx, next) => {
ctx.state.user = ctx.cookies.get('username');
await next();
});
router.get('/', (ctx, next) => {
ctx.body = `
${style}
<h1>Welcome to Cowsay as a Service</h1>
<p>Before start the service, please enter your name.</p>
<form action="/cowsay" method="GET" class="form">
<input type="text" name="user" placeholder="Username">
<input type="submit" value="Login">
</form>
<script>
document.querySelector('form').addEventListener('submit', () => {
const username = document.querySelector('input[name="user"]').value;
document.cookie = 'username=' + username;
});
</script>
`;
next();
});
router.get('/cowsay', (ctx, next) => {
const setting = settings[ctx.state.user];
const color = setting?.color || '#000000';
let cowsay = '';
if (ctx.request.query.say) {
const result = child_process.spawnSync('/usr/games/cowsay', [ctx.request.query.say], { timeout: 500 });
cowsay = result.stdout.toString();
}
ctx.body = `
${style}
<h1>Cowsay as a Service</h1>
<details class="color-setting">
<summary>Color Preferences</summary>
<form action="/setting/color" method="POST">
<input type="color" name="value" value="${color}">
<input type="submit" value="Change Color">
</form>
</details>
<form action="/cowsay" method="GET" class="form">
<input type="text" name="say" placeholder="hello">
<input type="submit" value="Say">
</form>
<pre style="color: ${color}" class="cowsay">
${cowsay}
</pre>
`;
});
router.post('/setting/:name', (ctx, next) => {
if (!settings[ctx.state.user]) {
settings[ctx.state.user] = {};
}
const setting = settings[ctx.state.user];
setting[ctx.params.name] = ctx.request.body.value;
ctx.redirect('/cowsay');
});
app.use(bodyParser());
app.use(router.routes());
app.use(router.allowedMethods());
app.listen(3000);
```
</details>
Đọc source thì ta thấy rằng trang web cho ta 2 API
- GET /cowsay?say=
- POST /setting/:name
Với mục tiêu là đọc được biến $FLAG thì endpoint chắc chắn là ở `GET /cowsay?say=` rồi
Tất nhiên nếu ta thử như vầy sẽ không được rồi, không thể dễ như thế được
Mò vào [docs](https://nodejs.org/api/child_process.html#child_processspawnsynccommand-args-options) của `child_process.spawnSync()` thì ta biết được lí do tại sao payload trên lại không được
Cụ thể thì tại options `shell` có ghi rằng
```
shell <boolean> | <string> If true, runs command inside of a shell.
Uses '/bin/sh' on Unix, and process.env.ComSpec on Windows.
A different shell can be specified as a string.
See Shell requirements and Default Windows shell.
Default: false (no shell).
```
Có nghĩa là theo mặc định thì chúng ta không thể thực hiện lệnh shell trong hàm này được.
-> Giả thuyết chúng ta sẽ Protype Pollution để thiết lập lại options shell này thành true
Xét API còn lại thử xem có gì khai thác được không
```javascript
router.post('/setting/:name', (ctx, next) => {
if (!settings[ctx.state.user]) {
settings[ctx.state.user] = {};
}
const setting = settings[ctx.state.user];
setting[ctx.params.name] = ctx.request.body.value;
ctx.redirect('/cowsay');
});
```
Biết rằng biến `settings` đã được khởi tạo là một object với giá trị rỗng
Với `ctx.state.user` được lấy từ cookie
Ở đây không có filter gì nên chúng ta có thể thực hiện được Prototype Pollution như sau:
Ta sẽ truyền `__proto__` vào cookie, lúc này:
- `const setting = settings[ctx.state.user];`
Sẽ trở thành:
- `const setting = settings[__proto__]`
Có nghĩa là `setting = Object.prototype`
Lúc này ta chỉ cần truyền `:name` với giá trị là `shell` và `ctx.request.body.value` với giá trị true
Câu lệnh `setting[ctx.params.name] = ctx.request.body.value;`
Sẽ trở thành :
`Object.prototype[shell] = true`
Đã thực hiện ô nhiễm nguyên mẫu thành công, lúc này ta chỉ cần lụm flag thôi
Thực hành
Lưu ý do ta phải truyền value là một giá trị boolean (true) nên ta phải đổi Content-Type thành `Content-Type: application/json`.
Còn nếu mà ta truyền `Content-Type: application/x-www-form-urlencoded` thì "true" nó chỉ là ở dạng chuỗi (string) thôi
Kết quả:
`Flag: ACSC{(oo)<Moooooooo_B09DRWWCSX!}`
## no sandbox - ISITDTU CTF 2022
Update...
## social page - ISITDTU CTF 2023
Update...
## KCSC_train_prototype_labs
Update...
## animals - TetCTF 2021
Update...
# References
https://clbuezzz.wordpress.com/2021/11/01/prototype-pollution-attack/
https://viblo.asia/p/tan-cong-prototype-pollution-tren-cac-ung-dung-nodejs-oOVlYwLvK8W
https://sheon.hashnode.dev/web-hacking-prototype-pollution-attack
https://nhattruong.blog/2023/10/01/lo-hong-prototype-pollution-o-nhiem-nguyen-mau-toan-tap/
https://book.hacktricks.xyz/pentesting-web/deserialization/nodejs-proto-prototype-pollution
https://portswigger.net/web-security/prototype-pollution
Sign in with Wallet
Connect another wallet