{"id":8357,"date":"2023-01-09T12:00:00","date_gmt":"2023-01-09T10:00:00","guid":{"rendered":"https:\/\/blog.eset.ee\/et\/2023\/01\/09\/cracked-it-highlights-from-kringlecon-5-golden-rings\/"},"modified":"2023-01-09T12:00:00","modified_gmt":"2023-01-09T10:00:00","slug":"cracked-it-highlights-from-kringlecon-5-golden-rings","status":"publish","type":"post","link":"https:\/\/blog.eset.ee\/et\/en\/2023\/01\/09\/cracked-it-highlights-from-kringlecon-5-golden-rings\/","title":{"rendered":"Cracked it! Highlights from KringleCon 5: Golden Rings"},"content":{"rendered":"

<\/p>\n

UPDATE: At the closing ceremonies<\/a> held on January 25th<\/sup>, 2023, the team behind the SANS Holiday Hack Challenge announced the winners and the enrollment of this report in the Honorable Mentions list<\/a>. Much glory to all the winners and hope to see some of you at KringleCon 6 on six geese a laying!<\/em><\/p>\n

<\/span><\/p>\n

This is my first year participating in the SANS Holiday Hack Challenge<\/a> and it was a blast. Through a series of 16 challenges ranging from easy to difficult, I practiced analyzing suspicious network traffic and PowerShell logs, writing Suricata rules<\/a>, breaking out of a Docker container<\/a>, finding leaked keys to exploit a GitLab CI\/CD pipeline<\/a> and an AWS user<\/a>, conducting XML External Entity attacks<\/a>, and hacking a smart contract to buy a non-fungible token<\/a>.<\/p>\n

The best part of this experience was that it introduced me to new tools and technologies, thus stretching my cybersecurity knowledge that much further. Here, I share a few highlights from solving the challenges.<\/p>\n

Orientation<\/strong><\/h2>\n

Every participant receives an avatar to navigate an in-browser video game environment set at the North Pole:<\/p>\n

\"\"<\/a><\/p>\n

During orientation, you receive a cryptocurrency wallet that the game uses to award KringleCoins for completing challenges and that you use in the last challenge to hack a smart contract. Interestingly, the game keeps track of all KringleCoin transactions in an Ethereum blockchain, meaning a complete record of your progress is stored in this blockchain too.<\/p>\n

On to the first ring of the game.<\/p>\n

1. Tolkien Ring<\/strong><\/h2>\n

\"\"<\/a><\/p>\n

Finding the Tolkien Ring required flexing my logs analysis muscles.<\/p>\n

Wireshark phishing<\/strong><\/h3>\n

First, I used Wireshark to analyze the provided .pcap<\/span> file that revealed a server at adv.epostoday[.]uk<\/span> downloading the file Ref_Sept24-2020.zip<\/span> to a computer:<\/p>\n

\"\"<\/a><\/p>\n

Peeking inside the ZIP file, I found an executable called Ref_Sept24-2020.scr<\/a>
\n<\/span>that triggered two detections in ESET Endpoint Security: BAT\/Runner.ES<\/span> and Generik.TAGTBG<\/span>. This malware eventually lead to a malicious executable running in memory called config.dll<\/span> and detected by ESET\u2019s Advanced Memory Scanner<\/a> as Win32\/Dridex.DD<\/span>.<\/p>\n

Windows event logs<\/strong><\/h3>\n

Next, I analyzed the provided .evtx<\/span> file containing PowerShell logs with Event Viewer. While there are other tools to analyze PowerShell logs, if attackers know how to use living-off-the-land binaries to stay under the radar, defenders should also be well-versed in the native tools an operating system provides.<\/p>\n

Since the logs contained 10,434 events, I grouped the events by date and then ran the Find action to look for any events containing the $<\/span> character. In PowerShell, $<\/span> is used to create and reference variables<\/a>. I found an attack happening on December 24, 2022, when the attacker ran the following script:<\/p>\n

\"\"<\/a><\/p>\n

It looks like the attacker found a secret recipe, switched out the secret ingredient of honey<\/span> for fish oil<\/span>, and then created a new recipe file. This triggered an event with an ID of 4104, which stands for the execution of remote PowerShell commands. So, I filtered the events by this ID, helping me to find additional malicious events more quickly.<\/p>\n

Suricata Regatta<\/strong><\/h3>\n

The last exercise for the Tolkien Ring was writing four Suricata rules to monitor network traffic for a Dridex infestation:<\/p>\n

alert dns $HOME_NET any -> any any (msg:”Known bad DNS lookup, possible Dridex infection”; dns.query; content:”adv.epostoday.uk”; nocase; sid:1; rev:1;)<\/span><\/p>\n

alert http 192.185.57.242 any <> any any (msg:”Investigate suspicious connections, possible Dridex infection”; sid:2; rev:1;)<\/span><\/p>\n

alert tls any any -> any any (msg:”Investigate bad certificates, possible Dridex infection”; tls.cert_subject; content:”CN=heardbellith.Icanwepeh.nagoya”; sid:3; rev:1;)<\/span><\/p>\n

alert http any any -> any any (msg:”Suspicious JavaScript function, possible Dridex infection”; file_data; content:”let byteCharacters = atob”; sid:4; rev:1;)<\/span><\/p>\n

In order, these rules catch DNS lookups for adv.epostoday[.]uk<\/span>, connections to the IP address 192.185.57[.]242<\/span>, the use of the malicious server heardbellith.Icanwepeh[.]nagoya<\/span> identified via the common name (CN<\/span>) in a TLS certificate, and the use of the JavaScript atob()<\/span><\/a> function to decode a binary string containing base64-encoded data on the client.<\/p>\n

Completing these three challenges earned me the Tolkien Ring:<\/p>\n

\"\"<\/a><\/p>\n

On to the second ring.<\/p>\n

2. Elfen Ring<\/strong><\/h2>\n

\"\"<\/a><\/p>\n

The most prominent challenges for the Elfen Ring were Prison Escape and Jolly CI\/CD.<\/p>\n

Prison Escape<\/strong><\/h3>\n

Prison Escape was a stern reminder that granting root privileges to a user in a Docker container is just as good as granting root privileges on the host system. The challenge was to break out of the container. Well, easily done when you are root:<\/p>\n

\"\"<\/a><\/p>\n

As the root user, I listed the partition tables for the device and then mounted the host filesystem, granting me full access to the host. Now I could search for the key, which should be located in the home directory as revealed by the in-game hints:<\/p>\n

\"\"<\/a><\/p>\n

Jolly CI\/CD<\/strong><\/h3>\n

While that was quick, Jolly CI\/CD took me the longest of any challenge to figure out. First, we were given a Git repository to clone over HTTP:<\/p>\n

\"\"<\/a><\/p>\n

From the URL, I could see that the name of the repository was wordpress.flag.net.internal<\/span>, so I moved to the repository and found a WordPress website. I checked if the website was live:<\/p>\n

\"\"<\/a><\/p>\n

Yup, the website was functional. I was curious if there were any leaked keys in the source code history. If yes, I should be able to push edits to the source code. So I ran git log<\/span>:<\/p>\n

\"\"<\/a><\/p>\n

From the commit messages, it looks like a commit<\/a> was made after adding assets to fix a whoops. Time to check out the pre-whoops commit:<\/p>\n

\"\"<\/a><\/p>\n

Excellent, I found a .ssh<\/span> directory with keys. Let\u2019s copy those keys over and configure an SSH agent and a Git user to see if I can impersonate the owner of those keys:<\/p>\n

\"\"<\/a><\/p>\n

Now let\u2019s return to the main branch and test if we can push a trivial change to the source code (using nano, I simply added a space to one of the files):<\/p>\n

\"\"<\/a><\/p>\n

So, I achieved the first part of the challenge by impersonating one of the WordPress developers, but did the website still work after my push?<\/p>\n

\"\"<\/a><\/p>\n

My push changed something because now the website redirected to port 8080.<\/p>\n

Until now, I had ignored the CI\/CD portion of the challenge, which should be the key to completing it. The repository contains a .gitlab-ci.yml<\/a>
\n<\/span>file, which provides the configuration for a GitLab CI\/CD pipeline. Every time you push to the repository, the CI\/CD system kicks in, and a GitLab Runner<\/a> executes the scripts in this YML file. That\u2019s as good as achieving remote code execution on the server where GitLab Runner is installed, I thought.<\/p>\n

Looking closer, I saw an rsync<\/a>
\n<\/span>script copying all the files from the Git repository to the directory on the web server from which the website was being served. At first, I tried to use rsync<\/span> to reverse the data flow by copying all the files from the web server to the Git repository, but without success.<\/p>\n

After a lot of hypothesis testing, I eventually had my breakthrough insight: Instead of trying to \u201cfix\u201d the WordPress website or run malicious scripts via the build system, serve a website that leaks information from the web server. Inside index.php<\/span> (located at the top level of the repository), I can comment out the code that loads the WordPress website and run PHP commands that probe the web server.<\/p>\n

Indeed, I can even run shell commands with PHP. I found that passthru()<\/span><\/a> worked easily.<\/p>\n

In index.php<\/span>, I used \/\/<\/span> to comment out two lines and I added passthru(‘ls -la \/’);<\/span> on the last line. This creates a website that lists all the files in the root directory of the web server:<\/p>\n

\"\"<\/a><\/p>\n

Then I pushed this change to the Git repository and the GitLab CI\/CD system took care of updating the website for me:<\/p>\n

\"\"<\/a><\/p>\n

Ah, the Elfen Ring must be in flag.txt<\/span>! I repeated the previous steps, but this time using passthru(‘cat \/flag.txt’)<\/span>; revealing the Elfen Ring the next time I requested the website:<\/p>\n

\"\"<\/a><\/p>\n

On to the third ring.<\/p>\n

3. Web Ring<\/strong><\/h2>\n

\"\"<\/a><\/p>\n

The most fun challenge for me was Open Boria Mine Door, although Glamtariel\u2019s Fountain was interesting while also presenting riddles.<\/p>\n

Open Boria Mine Door<\/strong><\/h3>\n

In Open Boria Mine Door, we were presented with six pins or mini-challenges to bypass input validation or a Content Security Policy<\/a> to connect the entry and exit pipes between the pins, including matching the pipe colors. For most pins, I used HTML to write a list of connecting letter \u2018o\u2019s. Here is my final solution:<\/p>\n

\"\"<\/a><\/p>\n

Pin 1<\/strong><\/h4>\n

There was no validation for Pin 1, so it was a simple matter of HTML and inline CSS:<\/p>\n

<p style=\"letter-spacing: -4px; margin: 0; padding: 0;\">oooooooooooooo<\/p><\/code><\/pre>\n
Pin 2<\/strong><\/h4>\n
Pin 2 had a Content Security Policy that disallowed JavaScript but allowed inline CSS, so that was no problem for my method:<\/p>\n
<ul style=\"list-style: none; line-height:0.5; letter-spacing: -4px; margin: 0; padding: 0;\"> <li>o<\/li> <li>o<\/li> <li>o<\/li> <li>o<\/li> <li>o<\/li> <li>o<\/li> <li>o<\/li> <li>o<\/li> <li>o<\/li> <li>oooooooooooooo<\/li> <\/ul><\/code><\/pre>\n
Pin 3<\/strong><\/h4>\n
Pin 3 had a Content Security Policy that disallowed CSS but allowed inline JavaScript, so I used JavaScript to change the styles instead:<\/p>\n
<script> document.write(\"\" + \"<ul id='o'>\" + \"<li>o<\/li>\" + \"<li>oooooooooooooooooooooo<\/li>\" + \"<li>o<\/li><li>o<\/li><li>o<\/li><li>o<\/li>\" + \"<\/ul>\"); const o = document.getElementById('o'); o.style.color = \"blue\"; o.style.listStyle = \"none\"; o.style.lineHeight = \"0.5\"; o.style.letterSpacing = \"-4px\"; o.style.margin = \"0\"; o.style.padding = \"0\"; <\/script><\/code><\/pre>\n
Pin 4<\/strong><\/h4>\n
Pin 4 had no Content Security Policy, but it had a sanitizeInput function on the client side that would strip double quotes, single quotes, left angle brackets, and right angle brackets. The trick here was to realize that this function wasn\u2019t triggered by submitting the form, but by the onblur<\/a>
\n<\/span>event. In other words, moving the mouse away from the input field triggered the onblur<\/span> event, sanitizing any input. The solution was to submit the form by pressing the Enter<\/strong> key, while taking care not to move the mouse cursor outside the bounds of the input field:<\/p>\n
<ul style=\"list-style: none; line-height:0.5; letter-spacing: -4px; margin: 0; padding: 0;\"> <li>o<\/li> <li>o<\/li> <li>oooooooooooooo<\/li> <li>o<\/li> <li>o<\/li> <li>o<\/li> <li>o<\/li> <li>o<\/li> <li style=\"color: blue;\">oooooooooooooo<\/li> <\/ul><\/code><\/pre>\n
Pin 5<\/strong><\/h4>\n
Pin 5 had the same sanitizeInput<\/span> function and bypass along with a Content Security Policy forbidding inline CSS, but allowing inline JavaScript:<\/p>\n
<script> document.write(\"\" + \"<ul id='o'>\" + \"<li>o<\/li>\" + \"<li>o<\/li>\" + \"<li class='red'>oooooooooooooo<\/li>\" + \"<li><span class='red'>o<\/span><\/li>\" + \"<li><span class='red'>o<\/span><\/li>\" + \"<li><span class='red'>o<\/span>\" + \"<span class='blue'> ooooooooooo<\/span><\/li>\" + \"<li><span class='red'>o<\/span>\" + \"<span class='blue'> oo<\/span><\/li>\" + \"<li><span class='red'>o<\/span>\" + \"<span class='blue'> oo<\/span><\/li>\" + \"<li><span class='red'>o<\/span>\" + \"<span class='blue'> oo<\/span><\/li>\" + \"<li>o<span class='blue'> oo<\/span><\/li>\" + \"<li>o<span class='blue'> B<\/span><\/li>\" + \"<\/ul>\"); const o = document.getElementById('o'); o.style.listStyle = \"none\"; o.style.lineHeight = \"0.5\"; o.style.letterSpacing = \"-4px\"; o.style.margin = \"0\"; o.style.padding = \"0\"; o.style.fontSize = \"xx-large\"; const reds = document.getElementsByClassName(\"red\"); for (let red of reds) { red.style.color = \"red\"; } const blues = document.getElementsByClassName(\"blue\"); for (let blue of blues) { blue.style.color = \"blue\"; } <\/script><\/code><\/pre>\n
Pin 6<\/strong><\/h4>\n
Finally, Pin 6 didn\u2019t sanitize the input, but it used a stricter Content Security Policy forbidding both inline CSS and JavaScript. My solution was to use deprecated HTML to get the styles I needed and use a table instead of a list:<\/p>\n
<table border=\"0\" frame=\"void\" rules=\"none\" cellpadding=\"0\" cellspacing=\"0\" width=\"100%\"> <tr bgcolor=\"#00FF00\"> <td><font color=\"#00FF00\" size=\"7\">o<\/font><\/td> <td><font color=\"#00FF00\" size=\"7\">o<\/font><\/td> <td><font color=\"#00FF00\" size=\"7\">o<\/font><\/td> <td><font color=\"#00FF00\" size=\"7\">o<\/font><\/td> <\/tr> <tr bgcolor=\"red\"> <td><font color=\"red\" size=\"5\">o<\/font><\/td> <td><font color=\"red\" size=\"5\">o<\/font><\/td> <td><font color=\"red\" size=\"5\">o<\/font><\/td> <td><font color=\"red\" size=\"5\">o<\/font><\/td> <\/tr> <tr bgcolor=\"blue\"> <td><font color=\"blue\" size=\"9\">o<\/font><\/td> <td><font color=\"blue\" size=\"9\">o<\/font><\/td> <td><font color=\"blue\" size=\"9\">o<\/font><\/td> <td bgcolor=\"red\"><font color=\"red\" size=\"9\">o<\/font><\/td> <\/tr> <tr bgcolor=\"blue\"> <td><font color=\"blue\" size=\"9\">o<\/font><\/td> <td><font color=\"blue\" size=\"9\">o<\/font><\/td> <td><font color=\"blue\" size=\"9\">o<\/font><\/td> <td><font color=\"blue\" size=\"9\">o<\/font><\/td> <\/tr> <\/table><\/code><\/pre>\n
Glamtariel\u2019s Fountain<\/span><\/strong><\/h3>\n
Glamtariel\u2019s Fountain<\/a> was an opportunity to practice XML External Entity (XXE) attacks<\/a>. Figuring out how to define a custom XML entity, defining an entity that requests a file from the server, and adding that entity as a payload to an HTTP request was not hard. The hardest part was figuring out the in-game riddles to divine the path to the files that the server would leak. Here is the breakthrough request revealing the location of the gold ring:<\/p>\n
\"\"<\/a><\/p>\n
\"\"<\/a><\/p>\n
\"\"<\/a><\/p>\n
I would offer two lessons learned from this challenge. First, use the Content Type Converter<\/a> extension in Burp<\/a> to convert JSON payloads to XML. Second, try placing the XXE payload in different tags \u2013 it took me a long time to figure out that all I had to do was place the &xxe;<\/span> payload in the reqType<\/span> tag instead of the imgDrop<\/span> tag.<\/p>\n
On to the fourth ring.<\/p>\n
4. Cloud Ring<\/strong><\/h2>\n<\/p>\n
\"\"<\/a><\/p>\n
Playing for the Cloud Ring was a beginner\u2019s foray into the Amazon Web Services (AWS) Command Line Interface (CLI).<\/p>\n
The highlight of this set of challenges was using trufflehog<\/a> to find AWS credentials in a Git repository and then exploiting them to authenticate as an AWS user. An attacker that gets to this position can use aws iam<\/a> commands to query the policies that apply to the user, and thus which cloud assets can be accessed and abused.<\/p>\n
On to the fifth ring.<\/p>\n
5. Burning Ring of Fire<\/strong><\/h2>\n
\"\"<\/a><\/p>\n
The most instructive part of this set of challenges was learning about Merkle Trees<\/a> to exploit a smart contract and get on the presale list for purchasing a non-fungible token (NFT)<\/a>. Here the challenge was to discover the proof values that, along with my wallet address and the root value of a Merkle Tree, proved my inclusion on the presale list.<\/p>\n
After a few unsuccessful attempts to provide proof values, I realized that I would never be able to figure out the proof values for the provided root value because there was no way to know all the leaf values used to calculate it. I needed to change the root value so that I could provide a valid Merkle Tree.<\/p>\n
Using Professor QPetabyte\u2019s tool<\/a>, I created a Merkle Tree from two leaves consisting of my wallet address and the address for the BSRS_nft<\/span> smart contract, which I found using the in-game Blockchain Explorer in block two of the game\u2019s Ethereum blockchain. The tool generated the root value of this tree and the proof value for my wallet address. Then I used Burp to intercept the request to the server and changed the default root value so that I could submit a valid Merkle Tree. Here is my NFT sporc<\/a> bought at a fixed price of 100 KringleCoins:<\/p>\n<\/p>\n
\"\"<\/a><\/p>\n
An ugly specimen indeed.<\/p>\n
Finale<\/strong><\/h2>\n
\"\"<\/a><\/p>\n
A big thank you to the organizers of the SANS Holiday Hack Challenge for stretching my mind in new ways and helping to deepen my cybersecurity knowledge. Not only am I looking forward to next year\u2019s challenge, but I will even be trying out the 2020 and 2021 editions of this challenge. And if you haven\u2019t participated in this challenge before, I hope these highlights have piqued your interest.<\/p>\n
Read the full analysis on WeLiveSecurity \u2192<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Learning meets fun at the 2022 SANS Holiday Hack Challenge \u2013 strap yourself in for a crackerjack ride at the North Pole as I foil Grinchum’s foul plan and recover the five golden rings<\/p>\n","protected":false},"author":5,"featured_media":8358,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[2880],"tags":[],"class_list":["post-8357","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-digital-security"],"acf":[],"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/blog.eset.ee\/et\/en\/wp-json\/wp\/v2\/posts\/8357","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.eset.ee\/et\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.eset.ee\/et\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.eset.ee\/et\/en\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.eset.ee\/et\/en\/wp-json\/wp\/v2\/comments?post=8357"}],"version-history":[{"count":0,"href":"https:\/\/blog.eset.ee\/et\/en\/wp-json\/wp\/v2\/posts\/8357\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.eset.ee\/et\/en\/wp-json\/wp\/v2\/media\/8358"}],"wp:attachment":[{"href":"https:\/\/blog.eset.ee\/et\/en\/wp-json\/wp\/v2\/media?parent=8357"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.eset.ee\/et\/en\/wp-json\/wp\/v2\/categories?post=8357"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.eset.ee\/et\/en\/wp-json\/wp\/v2\/tags?post=8357"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}