<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Drew Arpino on Medium]]></title>
        <description><![CDATA[Stories by Drew Arpino on Medium]]></description>
        <link>https://medium.com/@stumblesec?source=rss-b1b82253e27c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ETROKcdQG3dTK3yEkXkYBw.png</url>
            <title>Stories by Drew Arpino on Medium</title>
            <link>https://medium.com/@stumblesec?source=rss-b1b82253e27c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 08:00:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@stumblesec/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[CyberDefenders: Silent Breach Challenge Walkthrough]]></title>
            <link>https://stumblesec.medium.com/cyberdefenders-silent-breach-challenge-walkthrough-6dd3e7a415d5?source=rss-b1b82253e27c------2</link>
            <guid isPermaLink="false">https://medium.com/p/6dd3e7a415d5</guid>
            <category><![CDATA[cyberdefender]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[cyberdefenders-writeup]]></category>
            <dc:creator><![CDATA[Drew Arpino]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 15:00:36 GMT</pubDate>
            <atom:updated>2026-10-18T23:01:02.750Z</atom:updated>
            <content:encoded><![CDATA[<h4>Investigating a Malicious File Download with FTK Imager: Browser History Analysis, UserAssist Artifacts, Windows Mail Forensics, and PowerShell Deobfuscation</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*hqKsFQU544ooAYtK3BPoBA.webp" /><figcaption>Image Credit: <a href="https://cyberdefenders.org/blueteam-ctf-challenges/silent-breach/">https://cyberdefenders.org/blueteam-ctf-challenges/silent-breach/</a></figcaption></figure><h3>Introduction:</h3><p>Welcome to my weekly walkthrough! If you’ve stumbled across this blog while looking for a detailed guide to the <a href="https://cyberdefenders.org/blueteam-ctf-challenges/silent-breach/"><strong>Silent Breach Lab</strong></a> blue team challenge from <a href="https://cyberdefenders.org/"><strong>CyberDefenders</strong></a>, you’re in the right place.</p><p>For this challenge, we’re stepping into the DFIR world and helping the Impossible Mission Force (IMF) recover intelligence from a compromised system. After downloading a suspicious file from a compromised server, Ethan discovers that the intelligence has become unreadable. Our job is to examine the forensic image of his workstation, track down the origin of the malicious file, analyze its behavior, recover key artifacts from the system, and ultimately decrypt the affected files.</p><p>Throughout the investigation, we’ll spend time in <strong>FTK Imager</strong>, <strong>Registry Explorer</strong>, <strong>DB Browser for SQLite</strong>, and <strong>CyberChef</strong>. We’ll examine browser history databases, UserAssist registry artifacts, Windows Mail data, and an obfuscated PowerShell script to piece together what happened. Along the trail, we’ll identify download sources, recover email-based intelligence, analyze malware behavior, and extract the information needed to restore the encrypted files.</p><p>I’ll walk through each step of the investigation, explain the reasoning behind the analysis, and show how different forensic artifacts can be correlated to build a complete picture of the attack. By the end, you’ll have a better understanding of browser forensics, registry analysis, Windows Mail artifacts, PowerShell deobfuscation, and basic malware analysis techniques.</p><p>Sounds like fun, right? Let’s go!</p><p>And hey, if you find this walkthrough helpful, whether it helps you level up your digital forensics skills, gets you over a stumbling block, or just serves as a handy reference, consider following me for more weekly deep dives.</p><p>Thanks for reading and going on this investigation with me!</p><p><em>This write-up is for educational purposes only. All intellectual property related to the challenge belongs to the respective owners </em><strong><em>CyberDefenders</em></strong><em>.</em></p><h3>Challenge Scenario:</h3><blockquote>The IMF is hit by a cyber attack compromising sensitive data. Luther sends Ethan to retrieve crucial information from a compromised server. Despite warnings, Ethan downloads the intel, which later becomes unreadable. To recover it, he creates a forensic image and asks Benji for help in decoding the files.</blockquote><h3>Setup the Analysis Environment &amp; Extract the Challenge File:</h3><p>Safety first! It’s always important when working with lab/challenge files from <strong>CyberDefenders</strong> (or any educational lab/challenge/range), to keep yourself protected by performing these tasks in a dedicated, isolated virtual machine environment. I’m using <a href="https://github.com/mandiant/flare-vm"><strong>FLARE-VM</strong></a> for this challenge which is “ <em>a collection of software installations scripts for Windows systems that allows you to easily setup and maintain a reverse engineering environment on a virtual machine (VM).</em> “</p><p>To keep this write-up focused I’m going to skip the step-by-step setup of <em>FLARE-VM</em> but if you’d like to set up your own environment, please follow the directions provided directly by FLARE-VM on <em>GitHub</em>.</p><p><a href="https://github.com/mandiant/flare-vm">https://github.com/mandiant/flare-vm</a></p><p>Once you have a safe virtual environment created, updated, isolated, and snapshotted, we can extract the challenge file and start the investigation!</p><h3>Question 1: What is the MD5 hash of the potentially malicious EXE file the user downloaded?</h3><p>Let’s get right to work and start collecting information about the intelligence Ethan downloaded from the compromised server.</p><p>We’ll begin by extracting the challenge file: Silent_Breach.zip &gt; temp_extract_dir &gt; ethanPC.ad1</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*x5AnsgSK1bCGA5tq.png" /><figcaption><em>Overview of the challenge artifacts</em></figcaption></figure><p>The challenge artifact, ethanPC.ad1, is a forensic image of Ethan&#39;s PC where the unreadable intelligence was saved. The .ad1 extension is a file format created by AccessData (now Exterro) and is commonly opened using <a href="https://www.exterro.com/digital-forensics-software/ftk-imager"><strong>FTK Imager</strong></a>.</p><p>Launch <strong>FTK Imager</strong> and, once it’s loaded, select <strong>Add Data Source</strong> &gt; <strong>Image File</strong> &gt; ethanPC.ad1.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*u9ijW0QL_8ZGd10o.png" /><figcaption><em>FTK Imager: Challenge artifact Loaded</em></figcaption></figure><p>To answer <strong>Question 1</strong>, we need to locate the suspicious executable file Ethan downloaded. A good starting point is the user’s Downloads directory, which we can navigate to from the left-hand pane in <em>FTK Imager</em>.</p><p>Once there, we’ll immediately find a file using the classic double-extension trick to masquerade as a PDF: IMF-Info.pdf.exe.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fUkbkxvv5l5zLkTi.png" /><figcaption><em>FTK Imager: Identifying the suspicious file</em></figcaption></figure><p>Now that we’ve identified the file, we need to obtain its MD5 hash. A simple way to do this is to right-click the file and select <strong>Export File Hash List</strong>. We can then open the output in a text editor and locate the MD5 hash.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*87IeqhvQGoM-8cta.png" /><figcaption><em>Notepad: Examining the output of the file hash list</em></figcaption></figure><pre>336a7cf476ebc7548c93507339196abb</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/933/0*YKERzfQ8gDaiHr6l.png" /></figure><h3>Question 2: What is the URL from which the file was downloaded?</h3><p>To identify the URL from which the file was downloaded, jump back into <strong>FTK Imager</strong> and double-click IMF-Info.pdf.exe to examine the Zone.Identifier, a piece of metadata that can help determine where a file originated.</p><p>The Zone.Identifier alternate data stream (ADS) is generated by Windows when files are downloaded from the internet. It can contain useful artifacts such as the source URL, referrer URL, and security zone information, helping us collect more information about a downloaded file&#39;s origin. For example, review the HostUrl field to identify the URL from which the suspicious file was downloaded.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*M5D_hP7ARp1HxFZo.png" /><figcaption><em>FTK Imager: Identifying the HostURL in the Zone.Identifer</em></figcaption></figure><p>Based on the HostUrl field, we can identify the location from which the file was downloaded. Since the challenge scenario states that the file originated from a compromised server, this suggests that the IP address shown might belong to that server.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/0*ROATi520uxYbDhIW.png" /></figure><h3>Question 3: What application did the user use to download this file?</h3><p>To determine which application downloaded this file, we need to examine the web browser caches to identify which browser was used. Since the file appears to have been downloaded from a URL, the browser is the most likely entry point.</p><p>Let’s start with <strong>Google Chrome</strong>. In <em>FTK</em>, expand the evidence tree to: AppData\Local\Google\Chrome\User Data\Default</p><p>Download history is typically stored within the History database file. Right-click the file and export it for analysis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hfby8mwIKoiDJacm.png" /><figcaption><em>FTK Imager: Exporting the Chrome History DB</em></figcaption></figure><p>Open the database in <a href="https://stumblesec.com/posts/cyberdefenders-silent-breach-challenge-walkthrough/%28https://sqlitebrowser.org/%29"><strong>DB Browser for SQLite</strong></a> and review the downloads and downloads_url_chains tables. In this case, we don&#39;t find any evidence that the file was downloaded using <em>Chrome</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vxdR-NJVZCRIBLZJ.png" /><figcaption><em>DB Browser for SQLite: Checking Chrome History Database</em></figcaption></figure><p>Next, let’s check the <strong>Microsoft Edge</strong> history database located at: AppData\Local\Microsoft\Edge\User Data\Default</p><p>Export the History database and open it in <em>DB Browser for SQLite</em>. Since <em>Edge</em> is Chromium-based, the database structure is similar to <em>Chrome</em>.</p><p>There we go! This time, reviewing the downloads table reveals the evidence we need. The record confirms that Ethan downloaded the suspicious file using <em>Microsoft Edge</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EXpZjLurV8Z8f9jP.png" /><figcaption><em>DB Browser for SQLite: Checking Edge History Database</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/0*WYr51AzZ7zz4hI9-.png" /></figure><h3>Question 4: By examining Windows Mail artifacts, we found an email address mentioning three IP addresses of servers that are at risk or compromised. What are the IP addresses?</h3><p>To examine the Windows Mail artifacts, the first thing we need to do is determine exactly which mail application Ethan used. To do this, we’ll examine the NTUSER.DAT registry hive and review the recently accessed items.</p><p>For this, we can extract the NTUSER.DAT file with <strong>FTK Imager</strong> from the root of the image:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*C4SeD4QhE-xmd_cW.png" /><figcaption><em>FTK Imager: Locating the NTUSER.DAT hive in the image</em></figcaption></figure><p>To parse this file, we’ll need another tool, such as <a href="https://ericzimmerman.github.io/#forensic-tools"><strong>Eric Zimmerman’s Registry Explorer</strong></a>, which can load registry hives and explore them using convenient bookmarks.</p><p>Open <em>Registry Explorer</em> and load the extracted NTUSER.DAT file. Ignore the dirty hive warnings until the hive has been loaded.</p><p>Once loaded, select <strong>Bookmarks</strong> &gt; <strong>Common</strong> &gt; <strong>UserAssist (Recently Accessed Items)</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KwuHpmCzBOuHMaSQ.png" /><figcaption><em>Registry Explorer: Using the UserAssist (Recently Accessed Items) bookmark</em></figcaption></figure><p>To speed things up even more, we can search the UserAssist entries for “mail”. This reveals that the victim executed the built-in Windows Mail application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GW80rzMYTsGc66KB.png" /><figcaption><em>Registry Explorer: Identifying the Windows Live Mail app</em></figcaption></figure><p>Great! Now it’s research time. CyberDefenders conveniently links an article covering the email artifacts needed for this challenge:</p><p><a href="https://boncaldoforensics.wordpress.com/2018/12/09/microsoft-hxstore-hxd-email-research/">Microsoft HxStore.hxd (email) Research</a></p><p>The article points us to the following directory:</p><p>\AppData\Local\Packages\microsoft.windowscommunicationsapps_8wekyb3d8bbwe\LocalState\HxStore.hxd</p><p>This file can contain data related to email content and metadata. Let’s extract it and see what we can find.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*E8KlBmNcMsHuqepr.png" /><figcaption><em>FTK Imager: Identifying the HxStore.hxd file</em></figcaption></figure><p>One approach to examining this file is to perform a strings search and look for plaintext artifacts that might reveal IP addresses. While there are plenty of utilities that can accomplish this task, we’ll use <a href="https://gchq.github.io/CyberChef/"><strong>CyberChef</strong></a> for illustrative purposes in this write-up.</p><p>Load HxStore.hxd into <em>CyberChef</em>. Then add the <em>Strings</em> operation to the recipe, followed by <em>Extract IP Addresses</em>. This reveals a list of IP addresses contained within the file. Since duplicate entries are present, we can add the <em>Unique</em> operation to produce a condensed list and identify the three IP addresses needed to answer the question.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*D2Br_qePacE9_4fh.png" /><figcaption><em>CyberChef: Extracting IP addresses from the HxStore.hxd file</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/952/0*7dKnCIY8m519iPc5.png" /></figure><h3>Question 5: By examining the malicious executable, we found that it uses an obfuscated PowerShell script to decrypt specific files. What predefined password does the script use for encryption?</h3><p>Now it’s time to extract the malicious IMF-Info.pdf.exe file to determine the hard-coded password used by the PowerShell script.</p><p>here are a few ways we could approach this, including both dynamic and static analysis techniques.</p><p>Let’s start simple and perform another strings search with <strong>CyberChef</strong>. Since we’re looking for evidence of PowerShell activity, let’s search for .ps1. This quickly reveals a reference to a script called Gz3m6mG3j2TyAqF2Zx4v.ps1.</p><p>This also surfaces some very interesting encoding and obfuscation techniques. The variable $wy7qIGPnm36HpvjrL2TMUaRbz contains a large Base64-encoded blob. Immediately below it, the script applies two operations: <strong>Reverse</strong> and <strong>FromBase64</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*j4WIiwdlomwGdEA1.png" /><figcaption><em>CyberChef: Identifying PowerShell Content</em></figcaption></figure><p>By copying that blob into <em>CyberChef</em> and applying <strong>Reverse</strong> followed by <strong>FromBase64</strong>, we can decode the hidden content. The decoded output reveals the next stage of the script, including the hard-coded $password value.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xRKdgVv7JAC4Ii1I.png" /><figcaption><em>CyberChef: Uncovering the decoded Password variable</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/932/0*jFHD6LkmyCB4V6H_.png" /></figure><h3>Question 6: After identifying how the script works, decrypt the files and submit the secret string.</h3><p>Our final task is to decrypt the two files referenced within the script:</p><ol><li>C:\\Users\\ethan\\Desktop\\IMF-Secret.pdf</li><li>C:\\Users\\ethan\\Desktop\\IMF-Mission.pdf</li></ol><p>Let’s head back to <em>FTK Imager</em> and extract them. Once exported, both files are present as .enc files.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-EjA0xWeeHQeDUog.png" /><figcaption><em>FTK Imager: Extracting the encrypted files</em></figcaption></figure><p>Fortunately, decoding the script in <strong>Question 5</strong> revealed everything needed to decrypt the files with a few modifications. Since cryptography and PowerShell reverse engineering are a bit outside my normal wheelhouse, and in the spirit of full disclosure, I leveraged <strong>Copilot</strong> for assistance identifying the changes required to convert the script from an encryptor into a decryptor.</p><p>The modifications suggested were:</p><ul><li><strong>Direction flipped</strong></li><li>Original: <strong>Encrypts</strong> .pdf → .enc</li><li>New: <strong>Decrypts</strong> .enc → .pdf</li><li><strong>Extension replacement reversed</strong></li><li>Original: -replace &#39;\.pdf$&#39;, &#39;.enc&#39;</li><li>New: -replace &#39;\.enc$&#39;, &#39;.pdf&#39;</li><li><strong>Crypto transform changed</strong></li><li>Original: CreateEncryptor()</li><li>New: CreateDecryptor()</li><li><strong>Input/output file list changed</strong></li><li>Original: processed .pdf files</li><li>New: processes .enc files</li></ul><p>With these changes in place, we can paste the modified script into PowerShell ISE and execute it against the extracted files.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*m71N_-GMqgsKmucg.png" /><figcaption><em>PowerShell ISE: Modifying the decoded encryptor into a decryptor for the extracted .enc files</em></figcaption></figure><p>After execution, we’re left with two decrypted PDF files. The flag is contained within IMF-Mission.pdf.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/778/0*yGwaGj-BPXxhw_sC.png" /><figcaption><em>Reviewing the decrypted files</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/941/0*njI4ejnA4xRTrlt8.png" /></figure><h3>Conclusion:</h3><p>Mission Accomplished! How fun was that? A big thank you to <a href="https://cyberdefenders.org/"><strong>CyberDefenders</strong></a> for another awesome blue team lab!</p><p>In this investigation, we started with a forensic image of Ethan’s workstation and a suspicious executable masquerading as a PDF. From there, we worked through a variety of forensic artifacts to uncover what happened. Along the way, we identified the malicious file, tracked its download source through browser artifacts, determined which application was used to retrieve it, recovered intelligence from Windows Mail artifacts, analyzed an obfuscated PowerShell script, and ultimately decrypted the affected files to recover the final secret. Not bad for an investigation that started with a single forensic image!</p><p>I chose this challenge because it gave me an opportunity to spend some time working through an interesting investigation and get some reps in with the DFIR process. One of the things I enjoy most about forensics is discovering just how many artifacts can be available to wade through. Browser history, registry keys, email databases, alternate data streams, and application-specific files can all contain useful evidence. Just like in cybersecurity generally, we can’t protect or analyze what we don’t know exists. Challenges like this are a great reminder of the importance of understanding what artifacts are available, where they’re located, and how to correlate them together to tell the full story. They’re also a great excuse to get hands-on with different tools and keep those skills warm.</p><p>The coolest part for me was deobfuscating the PowerShell script and working through the process of reversing the encryptor into a decryptor. While I did leverage AI for some assistance, it was a great example of how powerful these tools can be when used in the right context. AI didn’t solve the challenge for me, but it helped accelerate the process by assisting with code analysis and modification while I focused on understanding the underlying logic. Used in blue team operations, it can be a tremendous force multiplier. More importantly, this challenge reinforced that investigations are often less about a single breakthrough and more about careful analysis of artifacts, correlating evidence, and piecing together the puzzle one piece at a time. Awesome stuff!</p><p>Thanks for your support and partnering on this investigation. Remember, cybersecurity is a team sport, and we’re in this together!</p><p>Until next week’s challenge, stay curious and be safe out there!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/0*LOcyb5CDhpZk9prT.png" /></figure><h3>Tools &amp; References:</h3><p><strong>Challenge Link:</strong> <a href="https://cyberdefenders.org/blueteam-ctf-challenges/silent-breach/">https://cyberdefenders.org/blueteam-ctf-challenges/silent-breach/</a></p><p><strong>Flare-VM:</strong> <a href="https://github.com/mandiant/flare-vm">https://github.com/mandiant/flare-vm</a></p><p><strong>Exterro FTK Imager</strong>: <a href="https://www.exterro.com/digital-forensics-software/ftk-imager">https://www.exterro.com/digital-forensics-software/ftk-imager</a></p><p><strong>Foxton Forensics: “Location of Google Chrome history”:</strong> <a href="https://www.foxtonforensics.com/browser-history-examiner/chrome-history-location">https://www.foxtonforensics.com/browser-history-examiner/chrome-history-location</a></p><p><strong>DB Browser for SQLite</strong>: <a href="https://sqlitebrowser.org/">https://sqlitebrowser.org/</a></p><p><strong>Eric Zimmerman’s Tools: Registry Explorer:</strong> <a href="https://ericzimmerman.github.io/#forensic-tools">https://ericzimmerman.github.io/#forensic-tools</a></p><p><strong>Boncaldo’s Forensics Blog: “Microsoft HxStore.hxd (email) Research”:</strong> <a href="https://boncaldoforensics.wordpress.com/2018/12/09/microsoft-hxstore-hxd-email-research/">https://boncaldoforensics.wordpress.com/2018/12/09/microsoft-hxstore-hxd-email-research/</a></p><p><strong>CyberChef:</strong> <a href="https://gchq.github.io/CyberChef/">https://gchq.github.io/CyberChef/</a></p><p><em>Originally published at </em><a href="https://stumblesec.com/posts/cyberdefenders-silent-breach-challenge-walkthrough/"><em>https://stumblesec.com</em></a><em> on October 14, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6dd3e7a415d5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LetsDefend: Shellshock Challenge Walkthrough]]></title>
            <link>https://stumblesec.medium.com/letsdefend-shellshock-challenge-walkthrough-25eb42df0c15?source=rss-b1b82253e27c------2</link>
            <guid isPermaLink="false">https://medium.com/p/25eb42df0c15</guid>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[letsdefendio]]></category>
            <category><![CDATA[lets-defend]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[wireshark]]></category>
            <dc:creator><![CDATA[Drew Arpino]]></dc:creator>
            <pubDate>Wed, 23 Sep 2026 21:00:19 GMT</pubDate>
            <atom:updated>2026-09-27T23:01:02.094Z</atom:updated>
            <content:encoded><![CDATA[<h4>Investigating a Shellshock Attack from a PCAP File with Wireshark</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/0*-A0G6H8aQhYJfsdZ.png" /><figcaption>Image Credit: <a href="https://app.letsdefend.io/challenge/shellshock-attack">https://app.letsdefend.io/challenge/shellshock-attack</a></figcaption></figure><h3>Introduction:</h3><p>Welcome to my weekly walkthrough! If you’ve stumbled across this blog while looking for a detailed guide to the <a href="https://app.letsdefend.io/challenge/shellshock-attack"><strong>ShellShock Attack</strong></a> blue team challenge from <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a>, you’re in the right place.</p><p>For this challenge, we’re putting on our incident response hats and investigating a potential attack against a vulnerable web server. We’re given a single network packet capture (.pcap) file and tasked with uncovering what happened. Through a combination of packet analysis, HTTP stream inspection, and a little background research, we&#39;ll identify the target operating system, enumerate the web server software, and uncover the exact command an attacker attempted to execute through a Shellshock exploit.</p><p>This brief challenge serves as a great introduction to both <strong>Wireshark</strong> and the infamous <strong>Shellshock</strong> vulnerability. During our time together, we’ll learn how to filter network traffic, inspect HTTP requests and responses, analyze HTTP headers, and recognize some of the telltale indicators of a Shellshock attack. While the investigation itself is straightforward, it provides a practical example of how network packet captures can help us identify malicious activity and reconstruct an attacker’s actions. Sounds like fun, right? Let’s go!</p><p>Thanks for reading and going on this investigation with me!</p><p><em>This write-up is for educational purposes only. All intellectual property related to the challenge belongs to the respective owners </em><a href="https://app.letsdefend.io/"><strong><em>LetsDefend</em></strong></a>.</p><h3>Challenge Scenario:</h3><blockquote>You must to find details of shellshock attacks</blockquote><h3>Question 1: What is the server operating system?</h3><p>Let’s jump right into this investigation and check out the challenge file, shellshock.pcap.</p><p>This is a network packet capture file that contains packet-level data, allowing us to “ <em>go deep</em> “ into the network protocols and learn more about the attack.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0-E6_qOkVGZXoUee.png" /><figcaption><em>Overview of the challenge artifact</em></figcaption></figure><p>Double-click the PCAP, which will open in <strong>Wireshark</strong>, already installed in the LetsDefend VM. Before we start digging through <em>Wireshark</em>, let’s orient ourselves by doing a bit of background research on what <strong>Shellshock</strong> is.</p><p>According to an excellent blog post by <a href="https://blog.cloudflare.com/inside-shellshock/"><strong>Cloudflare</strong></a>, <strong>Shellshock</strong> is an arbitrary code execution vulnerability in the Bash shell that was publicly disclosed waaaaay back in 2014. The vulnerability allows attackers to execute Bash commands through specially crafted HTTP requests on vulnerable web servers by prepending the payload with the string () { :; }; and appending commands that execute on the underlying operating system. You can use your imagination, but this is real bad.</p><p>This research gives us some important details for our investigation. Specifically, that commands may be delivered through HTTP requests and that the malicious string () { :; }; is a strong indicator of an attempted Shellshock exploit.</p><p>Let’s put this knowledge into practice and see if we can identify the operating system of the attacked server. To do this, we’ll use <em>Wireshark’s</em> display filters:</p><ol><li>Filter on http</li><li>Two packets should match. Right-click Packet 11 and select <em>Follow &gt; HTTP Stream</em></li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sSruBXhCqX7ZtKc-.png" /><figcaption><em>Wireshark: Following the first HTTP stream</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZLM3xyqnM63txuUZ.png" /><figcaption><em>Wireshark: Identifying the server OS from the HTML in the response</em></figcaption></figure><p>Nice! The server appears to be running the Linux distribution Ubuntu. Since <em>Shellshock</em> targets the Bash shell, identifying that the web server runs Linux makes it more plausible that it could be vulnerable to this attack.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*w-gG9lvt83fyGT8t.png" /></figure><h3>Question 2: What is the application server and version running on the target system?</h3><p>Next, we need to extract the other important detail from the HTML &lt;address&gt; tag: the web server software and version.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zFi-9JpbusQwWmzo.png" /><figcaption><em>Wireshark: Identifying the web server and version</em></figcaption></figure><p>From our analysis of the HTTP stream, we can see that the server is running Apache/2.2.22.</p><p>This is another useful piece of data. Knowing the web server version helps establish the age of the target environment and can provide additional context during an investigation like additional unpatched vulnerabilities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oV33cUIJeyTpRy-P.png" /></figure><h3>Question 3: What is the exact command that the attacker wants to run on the target server?</h3><p>To answer the third and final question, we need to identify the exact command the attacker attempted to run on the target server. Remember from our research that specially crafted HTTP requests can be used to pass commands to a vulnerable web server? This packet capture provides a great example of how that works.</p><p>The Cloudflare post describes one method of delivering a Shellshock payload by modifying the User-Agent header with the <em>magic string</em>, which is then passed into Bash by a vulnerable application. Let&#39;s turn our attention to the User-Agent header in the HTTP request stream we&#39;ve been analyzing in <em>Wireshark</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SVbRr6ogs9xbn2FS.png" /><figcaption><em>Wireshark: Identifying the command sent by the attacker on the target server</em></figcaption></figure><p>Here, we can clearly see the hallmarks of a <strong>Shellshock</strong> attack: the magic string () { :; }; followed by a command that the attacker wants the server to execute: /bin/ping -c1 10.246.50.2</p><p>This command instructs the system to send a single ICMP echo request to 10.246.50.2. Attackers commonly use commands like this to check if remote code execution is working and that the target server can reach another system under their control.</p><p>Now that we’ve learned about the Shellshock attack and examined what it looks like on the packet level, let’s wrap up this brief investigation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jDIobxPbTXkLy5RW.png" /></figure><h3>Conclusion:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ePmgdUdR9Ks9b_Bb.png" /></figure><p>How fun was that! A big thank you to <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a> for another awesome challenge.</p><p>Even though this investigation was relatively short, it packed in several fun lessons. Starting with nothing more than a packet capture file, we were able to reconstruct a potential attack against a web server by following the evidence in the network traffic. Along the way, we identified the target operating system, enumerated the web server software and version, and uncovered the exact command an attacker attempted to execute through a Shellshock exploit. Most importantly, we saw how a vulnerability can leave recognizable artifacts in HTTP traffic and how packet analysis can help us piece together what happened.</p><p>I chose this challenge for a couple of reasons. First, I needed something a little quicker this week. Second, I’ve been spending more time with <strong>Wireshark</strong> lately and wanted another opportunity to sharpen my packet analysis skills. This ended up being a perfect fit because it was concise, practical, and focused on core investigative techniques that translate directly to real-world network analysis.</p><p>What I enjoyed most about this challenge was learning more about <strong>Shellshock</strong> itself. Despite being one of those massive, headline-making vulnerabilities a decade ago, it wasn’t one I was particularly familiar with beyond its name and reputation. Digging into how the exploit worked, understanding how attackers delivered commands through HTTP headers, and then seeing those indicators appear directly in a packet capture was a really cool experience. Awesome stuff!</p><p>Thanks for your support and partnering on this investigation. If you found this walkthrough helpful — please give it a clap and consider following me! Your feedback is invaluable, and it pumps me up to support your security journey. Remember, cybersecurity is a team sport, and we’re in this together!</p><p>Until next week’s challenge — stay curious and be safe out there!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/0*zBfhcgoZpU9SAT7e.png" /></figure><h3>Tools &amp; References:</h3><p><strong>Challenge Link:</strong> <a href="https://app.letsdefend.io/challenge/shellshock-attack">https://app.letsdefend.io/challenge/shellshock-attack</a></p><p><strong>Cloudflare — “<em>Inside Shellshock: How hackers are using it to exploit systems</em>”:</strong> <a href="https://blog.cloudflare.com/inside-shellshock/">https://blog.cloudflare.com/inside-shellshock/</a></p><p><strong>Wireshark:</strong> <a href="https://www.wireshark.org/">https://www.wireshark.org/</a></p><p><em>Originally published at </em><a href="https://stumblesec.com/posts/letsdefend-shellshock-challenge-walkthrough/"><em>https://stumblesec.com</em></a><em> on September 23, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=25eb42df0c15" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LetsDefend: HTTP Basic Auth. Challenge Walkthrough]]></title>
            <link>https://stumblesec.medium.com/letsdefend-http-basic-auth-challenge-walkthrough-9092ae60496d?source=rss-b1b82253e27c------2</link>
            <guid isPermaLink="false">https://medium.com/p/9092ae60496d</guid>
            <category><![CDATA[wireshark]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[lets-defend]]></category>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[letsdefendio]]></category>
            <dc:creator><![CDATA[Drew Arpino]]></dc:creator>
            <pubDate>Fri, 18 Sep 2026 14:00:09 GMT</pubDate>
            <atom:updated>2026-09-20T23:01:02.296Z</atom:updated>
            <content:encoded><![CDATA[<h4>Analyzing HTTP Basic Authentication from a PCAP File with Wireshark and CyberChef</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/0*pxH34uZOU0X1QYgE.png" /><figcaption>Image Credit: <a href="https://app.letsdefend.io/challenge/http-basic-auth">https://app.letsdefend.io/challenge/http-basic-auth</a></figcaption></figure><h3>Introduction:</h3><p>Welcome to my weekly walkthrough! If you’ve stumbled across this blog while looking for a detailed guide to the <a href="https://app.letsdefend.io/challenge/http-basic-auth"><strong>HTTP Basic Auth</strong></a> blue team challenge from <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a>, you’re in the right place.</p><p>For this challenge, we’re putting on our incident response hats and investigating a potential attack against a web server. We’re handed a single network packet capture (.pcap) file, and it&#39;s up to us to figure out what&#39;s going on. With a little targeted filtering and analysis, we&#39;ll identify HTTP Basic Authentication traffic, enumerate details about the web server and client, and ultimately recover the credentials used during the authentication process.</p><p>This challenge is a fun introduction to <a href="https://www.wireshark.org/"><strong>Wireshark</strong></a> and packet analysis. During this investigation, we’ll learn how to efficiently filter network traffic, inspect HTTP streams, extract useful information from request and response headers, and follow the evidence wherever it leads. While the investigation itself is straightforward, it introduces several concepts that blue teamers encounter regularly when analyzing web traffic and investigating suspicious activity.</p><p>I’ll walk through each step clearly, explain the thought process behind the investigation, and show how each piece of information contributes to the final answer. By the end, you’ll have a solid understanding of how to approach similar packet capture investigations in the real world!</p><p>Sounds like fun, right? Let’s go!</p><p>Thanks for reading and coming along on this investigation with me!</p><p><em>This write-up is for educational purposes only. All intellectual property related to the challenge belongs to the respective owners </em><a href="https://app.letsdefend.io/"><strong><em>LetsDefend</em></strong></a></p><h3>Challenge Scenario:</h3><blockquote>We receive a log indicating a possible attack, can you gather information from the .pcap file?</blockquote><h3>Question 1: How many HTTP GET requests are in pcap?</h3><p>Let’s waste no time and jump right in. Our first order of business is to examine the challenge file, webserver.em0.pcap.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ng8Fdk721rGeBEOD.png" /><figcaption><em>Overview of the challenge artifact</em></figcaption></figure><p>This is a network packet capture file that can be opened with <strong>Wireshark</strong>, which is already installed and ready to go in the LetsDefend VM.</p><p>Once the pcap is opened in <strong>Wireshark</strong>, our objective is to determine how many HTTP GET requests are contained within the packet data. We can apply a straightforward display filter to identify the number of HTTP GET requests:</p><p>http.request.method == &quot;GET&quot;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*O10Pm2mpKYEu-POI.png" /><figcaption><em>Wireshark: Identifying the number of HTTP GET requests</em></figcaption></figure><p>With the filter applied, we can see that there are a total of five packets matching the filter. This gives us a good starting point as we begin identifying HTTP traffic between the client and the web server.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pyIfl9HGa18MWasu.png" /></figure><h3>Question 2: What is the server operating system?</h3><p>Now that we’ve identified the GET requests, let’s dive into the HTTP stream to see what other information we can uncover.</p><p>First, select the first packet in the list (packet 12), right-click, and select Follow &gt; HTTP Stream.</p><p>This allows us to view the request and response headers exchanged during the session. To identify the server operating system, we can examine the Server header. In this case, we’re interested in the underlying operating system rather than the web server application itself, which is Apache.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*J48VNKU4boDKJiEc.png" /><figcaption><em>Wireshark: Identifying the server operating system in the HTTP stream</em></figcaption></figure><p>This can help us determine what operating system is running beneath the web server and may provide useful context if we need to identify vulnerabilities that could affect the host.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QiXuEIx0yoasMNkZ.png" /></figure><h3>Question 3: What is the name and version of the web server software?</h3><p>Speaking of Apache, to answer Question 3, we’ll use the web server information reported in the Server header that we examined in the previous question.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WmBE9R0NxxVUNDpK.png" /><figcaption><em>Wireshark: Identifying the web server version in the HTTP stream</em></figcaption></figure><p>The Server header provides the name and version of the web server software and version running on the host.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*I46bxogJlwjqBPaH.png" /></figure><h3>Questions 4 &amp; 5:</h3><h4>What is the version of OpenSSL running on the server?</h4><h4>What is the client’s user-agent information?</h4><p>To answer Questions 4 and 5, we’ll continue gathering information from the HTTP stream.</p><p>We can find the reported OpenSSL version on the same Server header line that we examined in the previous questions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*U46KdtHOONUTqJsH.png" /><figcaption><em>Wireshark: Identifying the OpenSSL version reported in the header</em></figcaption></figure><p>For the requesting client’s user-agent information, we can turn to the User-Agent header.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cNLoXXfSUTA6j__z.png" /><figcaption><em>Wireshark: Identifying the User-Agent</em></figcaption></figure><p>User agents can help identify the browser or application that originated a request. While a user-agent string can be spoofed, it can still provide a useful clue when piecing together an attack.</p><p>Several online tools can help decode a complex user-agent string and identify the associated client software. For an example, in this case the user-agent string indicates the <strong>Lynx</strong> browser running on Linux.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Nm9PZnrlgv0_fJYa.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lRksL31xs7bNcSqG.png" /></figure><h3>Questions 6 &amp; 7:</h3><h4>What is the username used for Basic Authentication?</h4><h4>What is the user password used for Basic Authentication?</h4><p>Now we can see in the current HTTP stream that the authentication attempt was unsuccessful. The requesting client received a 401 Authorization Required response.</p><p>Let’s turn our focus to the WWW-Authenticate header. It contains the value:</p><p>Basic realm=&quot;Restricted&quot;</p><p>This tells us that HTTP Basic Authentication is being used. The 401 response indicates that the request either lacked valid authentication credentials or that the supplied credentials were rejected.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PhWHgE7W4D5MGapC.png" /><figcaption><em>Wireshark: Identifying basic authentication usage</em></figcaption></figure><p>This means the client must provide valid credentials to access the protected resource. With HTTP Basic Authentication, credentials are transmitted as a username:password pair encoded using Base64.</p><p>The client then sends another request to the server containing the Base64-encoded credentials in the Authorization header.</p><p>For us, this means we’ll need to find the next request containing the Authorization header with the encoded credentials.</p><p>Let’s return to our filter:</p><p>http.request.method == &quot;GET&quot;</p><p>This time, let’s follow the HTTP stream for the next packet in the filtered sequence, packet 21.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*btuo6rHBMKnBYuiB.png" /><figcaption><em>Wireshark: Focusing on the next request in the sequence</em></figcaption></figure><p>Now check it out. We have the Base64-encoded credentials right in front of us and all we need to do is decode them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dayCC2NzQN3awrDR.png" /><figcaption><em>Wireshark: Uncovering the authentication material</em></figcaption></figure><p>Now that we’ve got the string, we simply need to decode it. We can use <a href="https://gchq.github.io/CyberChef/"><strong>CyberChef</strong></a> to make quick work of this. Drop the captured string into <em>CyberChef’s</em> input window and add the <em>From Base64</em> operation to the recipe.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*P1f1Bp7Nu9Er6n8u.png" /><figcaption><em>CyberChef: Decoding the Base64 authentication material</em></figcaption></figure><p>In the output window, we’ll see the decoded credentials in the username:password format. Now we have everything we need to answer both questions and close out this investigation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aivGBgwKAwxMSa1x.png" /></figure><h3>Conclusion:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DGB8L8fa2MB0cOAl.png" /></figure><p>How fun was that! A big thank you to <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a> for another awesome challenge.</p><p>This week’s challenge gives us an opportunity to work through packet analysis using <strong>Wireshark</strong>. Starting with a single packet capture file, we identified HTTP GET requests, examined HTTP streams, enumerated information about the server and client, and ultimately recovered the credentials used during HTTP Basic Authentication. While the challenge was straightforward, it provided a great example of how much information can be gathered from network traffic when you know where to look.</p><p>I chose this week’s challenge because it gave me a chance to continue sharpening my packet analysis skills while working through a targeted investigation scenario. What made this one interesting for me was that I’d never had the opportunity to investigate HTTP Basic Authentication at the packet level before. I’ve read about it, understood the theory behind it, and encountered it in documentation, but it was cool to see exactly how the authentication process plays out in network traffic and how the authentication material is transmitted between a client and server. Seeing the WWW-Authenticate challenge, the subsequent Authorization header, and the Base64-encoded credentials all come together in the packet capture helped connect the dots in a practical, hands-on way.</p><p>Thanks for your support and partnering on this investigation. If you found this walkthrough helpful — please give it a clap and consider following me! Your feedback is invaluable, and it pumps me up to support your security journey. Remember, cybersecurity is a team sport, and we’re in this together!</p><p>Until next week’s challenge — stay curious and be safe out there!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/0*gC442tudBWQyQ_Sk.png" /></figure><h3>Tools &amp; References:</h3><p><strong>Challenge Link:</strong> <a href="https://app.letsdefend.io/challenge/http-basic-auth">https://app.letsdefend.io/challenge/http-basic-auth</a></p><p><strong>Wireshark:</strong> <a href="https://www.wireshark.org/">https://www.wireshark.org/</a></p><p><strong>CyberChef:</strong> <a href="https://gchq.github.io/CyberChef/">https://gchq.github.io/CyberChef/</a></p><p><em>Originally published at </em><a href="https://stumblesec.com/posts/letsdefend-http-basic-auth-challenge-walkthrough/"><em>https://stumblesec.com</em></a><em> on September 18, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9092ae60496d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CyberDefenders: XLMRat Challenge Walkthrough]]></title>
            <link>https://stumblesec.medium.com/cyberdefenders-xlmrat-challenge-walkthrough-3f603caa8ee3?source=rss-b1b82253e27c------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f603caa8ee3</guid>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[cyberdefenders-writeup]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[cyberdefender]]></category>
            <dc:creator><![CDATA[Drew Arpino]]></dc:creator>
            <pubDate>Wed, 12 Aug 2026 19:00:16 GMT</pubDate>
            <atom:updated>2026-08-16T23:01:02.363Z</atom:updated>
            <content:encoded><![CDATA[<h4>Analyzing Malware Delivery from a PCAP File with Wireshark and VirusTotal: Payload Extraction, AsyncRAT Identification, and Living-off-the-Land Binary Abuse</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/401/1*7LxxBW9pCPqQHURybffxZA.png" /><figcaption>Image Credit: <a href="https://cyberdefenders.org/blueteam-ctf-challenges/xlmrat/">https://cyberdefenders.org/blueteam-ctf-challenges/xlmrat/</a></figcaption></figure><h3>Introduction:</h3><p>Welcome to my weekly walkthrough! If you’ve stumbled across this blog while looking for a detailed guide to the <a href="https://cyberdefenders.org/blueteam-ctf-challenges/xlmrat/"><strong>XLMRat</strong></a> blue team challenge from <a href="https://cyberdefenders.org/"><strong>CyberDefenders</strong></a>, you’re in the right place.</p><p>In this challenge, we’re provided with a packet capture from a compromised system that has been flagged for suspicious network activity. Our job is to analyze the capture, determine how the malware was delivered, identify the payloads involved, and piece together the attack chain.</p><p>The PCAP serves as our anchor throughout this lab. Rather than starting with a malware sample or endpoint evidence, we’ll rely on the network traffic itself to uncover the artifacts we need. As we work through the investigation, we’ll bust out tools like <strong>Wireshark</strong> and <strong>CyberChef</strong> to extract artifacts, decode embedded content, and identify the evidence hidden within the capture.</p><p>Once we’ve recovered those indicators, we’ll enrich them with external threat intelligence sources such as <strong>VirusTotal</strong> and <strong>IPinfo.io</strong> to learn more about the infrastructure, malware family, and attacker techniques associated with the activity.</p><p>Along the way, we’ll identify a staged malware payload, recover a second-stage executable, examine malware metadata, uncover LOLBin abuse, and build a timeline of events directly from the network evidence.</p><p>Sounds like fun, right? Let’s go!</p><p>Thanks for reading and going on this investigation with me!</p><p>This write-up is for educational purposes only. All intellectual property related to the challenge belongs to the respective owners <a href="https://cyberdefenders.org/"><strong>CyberDefenders</strong></a></p><h3>Challenge Scenario:</h3><blockquote>A compromised machine has been flagged due to suspicious network traffic. Your task is to analyze the PCAP file to determine the attack method, identify any malicious payloads, and trace the timeline of events. Focus on how the attacker gained access, what tools or techniques were used, and how the malware operated post-compromise.</blockquote><h3>Setup the Analysis Environment &amp; Extract the Challenge File:</h3><p>Safety first! It’s always important when working with lab/challenge files from <a href="https://cyberdefenders.org/"><strong>CyberDefenders</strong></a> (or any educational lab/challenge/range), to keep yourself protected by performing these tasks in a dedicated, isolated virtual machine environment. I’m using <a href="https://github.com/mandiant/flare-vm"><strong>FLARE-VM</strong></a> for this challenge which is “ <em>a collection of software installations scripts for Windows systems that allows you to easily setup and maintain a reverse engineering environment on a virtual machine (VM).</em> “</p><p>To keep this write-up focused I’m going to skip the step-by-step setup of <em>FLARE-VM</em> but if you’d like to set up your own environment, please follow the directions provided directly by <em>FLARE-VM</em> on <em>GitHub.</em></p><p><a href="https://github.com/mandiant/flare-vm">GitHub - mandiant/flare-vm: A collection of software installations scripts for Windows systems that allows you to easily setup and maintain a reverse engineering environment on a VM.</a></p><p>Once you have a safe virtual environment created, updated, isolated, and snapshotted, we can extract the challenge file and start the investigation!</p><h3>Question 1: The attacker successfully executed a command to download the first stage of the malware. What is the URL from which the first malware stage was installed?</h3><p>Let’s kick off our investigation by extracting the XLMRat.zip archive to reveal our challenge artifact, 236-XLMRat.pcap.</p><p>This is a network packet capture file, so we’ll start our analysis using <a href="https://www.wireshark.org/"><strong>Wireshark</strong></a>, which will allow us to dissect the network traffic and figure out what the attacker was up to.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*N1lEYK-cPpC-7hd0.png" /><figcaption><em>Overview of the challenge file</em></figcaption></figure><p>A smart starting point is to get an idea of all the endpoints contained within the traffic so we can identify any internal or external IP addresses involved.</p><p>To do this, navigate to <strong>Statistics &gt; Endpoints &gt; IPv4</strong>.</p><p>With this view in place, notice that there are two private IP addresses and one public IP address. Based on the packet counts, it appears that the victim host is 10.1.9.101, while the remote system is 45.126.209.4.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1an4a0xmuVpdwgAE.png" /><figcaption><em>Wireshark: Identifying the IPs in the PCAP</em></figcaption></figure><p>To answer <strong>Question 1</strong>, we’re looking for the first stage download activity and the URL from which it originated. A good next step is to filter for HTTP GET requests originating from the suspected victim host.</p><p>This display filter leaves us with just two packets, each associated with a downloaded file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*b93J4ftB4GC52Ymo.png" /><figcaption><em>Wireshark: Filtering HTTP GET requests</em></figcaption></figure><p>Focus on the second result, /mdm.jpg. Right-click the row and select <strong>Follow → HTTP Stream</strong>. Inside, we&#39;ll find a big &#39;ole block of hexadecimal data along with several functions near the bottom that resemble script content.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*n56wm3heM-ehScDl.png" /><figcaption><em>Wireshark: Reviewing the HTTP stream</em></figcaption></figure><p>This suggests we’re looking at the first-stage payload masquerading as an innocent image file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/797/0*YMTplaR4ATHsD-x7.png" /></figure><h3>Question 2: Which hosting provider owns the associated IP address?</h3><p>Let’s do a little reconnaissance to determine which hosting provider owns the IP address hosting the first-stage payload: 45.126.209.4.</p><p>While there are plenty of tools that can provide IP enrichment data, I prefer <a href="https://ipinfo.io/"><strong>IPinfo.io</strong></a> for quickly gathering context about an IP address.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xcq9IIKbQgShvqmg.png" /><figcaption><em>IPInfo.io: Identifying the hosting provider</em></figcaption></figure><p>After searching the IP address, we can see that the host is associated with ReliableSite.net.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/811/0*EfwJqExhpBAvU9aQ.png" /></figure><h3>Question 3: By analyzing the malicious scripts, two payloads were identified: a loader and a secondary executable. What is the SHA256 of the malware executable?</h3><p>Remember in <strong>Question 1</strong> that we noticed the HTTP stream contained a large block of hexadecimal data along with several script functions? To answer <strong>Question 3</strong>, let’s dig into that hex and see what we can find.</p><p>It appears that the hex data is assembled into a second-stage executable, which we need to recover so we can obtain its SHA256 hash. Before we can do that, we’ll need to reconstruct the file.</p><p>For this task, we’ll use <a href="https://gchq.github.io/CyberChef/"><strong>CyberChef</strong></a><strong> </strong>so we can copy the hex blob and extract the embedded file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8QRrE9iN5xVRYrse.png" /><figcaption><em>Wireshark: Analyzing the script contents through the HTTP stream</em></figcaption></figure><p>First, copy the hex code in the packet between $hexString_bbb = and $hexString_pe =.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OcecU6j9n-DJTraY.png" /><figcaption><em>Wireshark: Copying the Hex (1 of 2)</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rMvfwfrSWrSslFbM.png" /><figcaption><em>Wireshark: Copying the Hex (2 of 2)</em></figcaption></figure><p>Paste the data into CyberChef’s input window, then apply the <strong>From Hex</strong> and <strong>Extract Files</strong> operations to the recipe. This will reconstruct the embedded file so it can be downloaded for further analysis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vovce-8lzbwbuIJj.png" /><figcaption><em>CyberChef: Decoding, extracting, and downloading the second-stage executable</em></figcaption></figure><blockquote><strong><em>Important:</em></strong><em> In my analysis environment, </em><strong><em>Microsoft Defender Antivirus</em></strong><em> immediately detected the downloaded file as malware. This is a good reminder of why malware analysis should always be performed inside an isolated lab or sandbox environment. Running unknown files on a production system can result in an unintended compromise.</em></blockquote><p>Once the file has been downloaded from CyberChef, we can use <strong>PowerShell</strong> and the Get-FileHash cmdlet to calculate its SHA256 hash.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2jRHkmshiEHSuR3Y.png" /><figcaption><em>PowerShell: Obtaining the second stage file hash</em></figcaption></figure><p>Having the SHA256 hash of the second-stage payload is extremely handy because it allows us to pivot into threat intelligence and gather additional context about the malware to learn more about what we’re up against.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/805/0*56SwYuuHgZwYh91q.png" /></figure><h3>Question 4: What is the malware family label based on Alibaba?</h3><p>Next up, we’ll take the second-stage hash we collected in the last question and start gathering additional intelligence about the binary.</p><p>For this, we’ll use <a href="https://www.virustotal.com/"><strong>VirusTotal</strong></a>. Navigate to VirusTotal and paste the hash into the search box. If the sample has been previously analyzed by antivirus vendors and the security community, we’ll be able to review the results and gather additional context about the file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IuC6RWwkmmAuCDTE.png" /><figcaption><em>VirusTotal: Overview of the second-stage malware</em></figcaption></figure><p>Right away, we’ll discover that this sample has already been analyzed and that most of the vendors identify the binary as malicious.</p><p>To answer <strong>Question 4</strong>, we’re interested in the malware family classifications provided by the various detection engines. Reviewing the results, we can see that Alibaba classifies the sample as part of the AsyncRAT family.</p><p>Understanding the malware family can be useful to help understand more about how the malware behaves and what other techniques it might use.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/807/0*_wZqQZ_JVPviwdRH.png" /></figure><h3>Question 5: What is the PE header compile (Creation Time) timestamp of the malware?</h3><p>Let’s stick with <strong>VirusTotal</strong> and do a little more digging. To answer <strong>Question 5</strong>, we need to determine the PE header compile timestamp.</p><p>This value can help us build a timeline of the malware’s lifecycle by showing when the executable was compiled. Comparing this timestamp with known reports and in-the-wild activity can sometimes provide additional context about a malware campaign.</p><p>In VirusTotal, this value is presented as the <em>Creation Time</em> under the <strong>Details &gt; History</strong> section.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gnPe69YPSrS1R4aE.png" /><figcaption><em>VirusTotal: Identifying the sample’s creation time</em></figcaption></figure><p>From the metadata, we can retrieve the PE header creation timestamp and use it as our answer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/807/0*XrkD3pVOvcHpeIf3.png" /></figure><h3>Question 6: Which LOLBin is leveraged for stealthy process execution in this script? Provide the full path.</h3><p>To answer <strong>Question 6</strong>, we’ll need to return to the HTTP stream in Wireshark and analyze the script contents we discovered below the hex blob we decoded earlier.</p><p>Before we do that, it’s important to understand what we’re looking for. In this case, the challenge is asking us to identify a living-off-the-land binary, or LOLBin. LOLBins are legitimate tools, often built into an operating system, that attackers frequently abuse because they can perform malicious actions using trusted binaries rather than introducing their own tools.</p><p>Let’s take a look at the script contents back in Wireshark.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/784/0*LPI4Jvqugofka0NM.png" /><figcaption><em>Wireshark: Identifying the obfuscated script contents in the HTTP stream</em></figcaption></figure><p>This section stands out because some obfuscation has been applied, making it difficult to immediately understand what’s happening.</p><p>Copy the highlighted content and bring it into <strong>CyberChef</strong>. This time, add the <strong>Find / Replace</strong> operation to your recipe. Select <em>Find &gt; Simple String</em> and enter # in the Find field. Leave the Replace field blank. The goal is to remove the repeated # characters and make the script easier to read.</p><p>Once the recipe is applied, the script becomes much clearer. While we could continue deobfuscating it further, we can already see that the script is declaring several variables that will be used later during execution.</p><p>Focusing on the $NA and $AC variables and putting them together, we find a reference to RegSvcs.exe within the C:\Windows\Microsoft.NET\Framework\v4.0.30319\ directory. This is the LOLBin we&#39;re looking for.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ay2s9lpn_OuaRdJb.png" /><figcaption><em>CyberChef: Uncovering evidence of LOLBin abuse in the script</em></figcaption></figure><p>According to the <a href="https://lolbas-project.github.io/lolbas/Binaries/Regsvcs/"><strong>LOLBAS project GitHub</strong></a>, RegSvcs.exe is a legitimate Microsoft utility used to register .NET Component Object Model (COM) assemblies. Because it can execute code in trusted contexts, attackers have been known to abuse it for execution and application control bypass.</p><blockquote>Regsvcs and Regasm are Windows command-line utilities that are used to register .NET Component Object Model (COM) assemblies.Use case: Execute dll file and bypass Application Whitelisting</blockquote><p>This seems to fit the challenge’s description of a <em>“LOLBin leveraged for stealthy process execution.”</em> Nice!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/803/0*Jd4MMAYxJ2DIv9QA.png" /></figure><h3>Question 7: The script is designed to drop several files. List the names of the files dropped by the script.</h3><p>Okay, we’ve made it to the final question. Our last task is to identify the files dropped by the script.</p><p>Back in the Wireshark HTTP stream, let’s focus on the section below the script contents we deobfuscated in the previous question.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*O2Kbr-1uKzMSkv0u.png" /><figcaption><em>Wireshark: Identifying files dropped by the malicious script</em></figcaption></figure><p>Right away, we can identify three files associated with local file paths referenced by the script:</p><ul><li>Conted.ps1</li><li>Conted.bat</li><li>Conted.vbs</li></ul><p>These files appear throughout the script’s execution flow and represent the dropped artifacts referenced by the script.</p><p>With that, we’ve completed the challenge. Awesome job, let’s wrap this thing up!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/0*dYzBkSdZoL3oFpP3.png" /></figure><h3>Conclusion:</h3><p>How fun was that! A big thank you to <a href="https://cyberdefenders.org/"><strong>CyberDefenders</strong></a> for another awesome challenge.</p><p>That’s a wrap on the XLMRat! In this challenge, we used a packet capture to trace a malware infection from initial download through payload delivery and execution. Along the way, we identified the hosting infrastructure, reconstructed a second-stage malware sample, enriched our findings with threat intelligence, and uncovered LOLBin abuse used to support the attack. Not bad for starting with nothing more than a PCAP file!</p><p>I enjoyed this challenge because it reinforced a practical investigation workflow that started with the authoritative evidence source and expanded outward. Rather than relying on endpoint data or reverse engineering from the start, we used network traffic to uncover indicators and artifacts, then leveraged external intelligence sources to add context. The challenge flowed naturally from one question to the next and provided a nice balance of packet analysis, malware investigation, and threat intelligence.</p><p>My biggest takeaway was seeing how much can be recovered from network evidence alone. Reconstructing a malware sample from hexadecimal data embedded within a script was an incredibly cool reminder that valuable artifacts can often be hiding in plain sight. This challenge was also a fantastic showcase of how versatile <strong>CyberChef</strong> can be, from decoding and data manipulation to extracting files and cleaning up obfuscated content. Finally, it reinforced the value of understanding commonly abused LOLBins. The more familiar you are with tools like RegSvcs.exe, the faster you&#39;ll recognize suspicious activity and understand what an attacker may be trying to accomplish. Awesome stuff!</p><p>Thanks for your support and partnering on this investigation. If you found this walkthrough helpful — please give it a clap and consider following me! Your feedback is invaluable, and it pumps me up to support your security journey. Remember, cybersecurity is a team sport, and we’re in this together!</p><p>Until next week’s challenge — stay curious and be safe out there!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/0*Rb4b7Mt3DfJS2MgL.png" /></figure><h3>Tools &amp; References:</h3><p><strong>Challenge Link:</strong> <a href="https://cyberdefenders.org/blueteam-ctf-challenges/xlmrat/">https://cyberdefenders.org/blueteam-ctf-challenges/xlmrat/</a></p><p><strong>Flare-VM:</strong> <a href="https://github.com/mandiant/flare-vm">https://github.com/mandiant/flare-vm</a></p><p><strong>Wireshark:</strong> <a href="https://www.wireshark.org/">https://www.wireshark.org/</a></p><p><strong>IPInfo.io</strong>: <a href="https://ipinfo.io/">https://ipinfo.io/</a></p><p><strong>CyberChef:</strong> <a href="https://gchq.github.io/CyberChef/">https://gchq.github.io/CyberChef/</a></p><p><strong>VirusTotal:</strong> <a href="https://www.virustotal.com/">https://www.virustotal.com/</a></p><p><strong>VirusTotal — Second Stage Executable:</strong> <a href="https://www.virustotal.com/gui/file/1eb7b02e18f67420f42b1d94e74f3b6289d92672a0fb1786c30c03d68e81d798/detection">https://www.virustotal.com/gui/file/1eb7b02e18f67420f42b1d94e74f3b6289d92672a0fb1786c30c03d68e81d798/detection</a></p><p><strong>LOLBAS GitHub — Regsvcs.exe:</strong> <a href="https://lolbas-project.github.io/lolbas/Binaries/Regsvcs/">https://lolbas-project.github.io/</a></p><p><em>Originally published at </em><a href="https://stumblesec.com/posts/cyberdefenders-xlmrat-challenge-walkthrough/"><em>https://stumblesec.com</em></a><em> on August 12, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f603caa8ee3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LetsDefend: NTLM Relay Challenge Walkthrough]]></title>
            <link>https://stumblesec.medium.com/letsdefend-ntlm-relay-challenge-walkthrough-d28073203b6b?source=rss-b1b82253e27c------2</link>
            <guid isPermaLink="false">https://medium.com/p/d28073203b6b</guid>
            <category><![CDATA[lets-defend]]></category>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[letsdefendio]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Drew Arpino]]></dc:creator>
            <pubDate>Tue, 28 Jul 2026 12:00:43 GMT</pubDate>
            <atom:updated>2026-08-02T23:01:03.583Z</atom:updated>
            <content:encoded><![CDATA[<h4>Investigating an NTLM Relay Attack with Wireshark and Event Log Explorer: SMB Analysis, Remote Registry Access, and Lateral Movement</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/0*YrWUja60kFVfWxat.png" /><figcaption>Image Credit: <a href="https://app.letsdefend.io/challenge/ntlm-relay">https://app.letsdefend.io/challenge/ntlm-relay</a></figcaption></figure><h3>Introduction:</h3><p>Welcome to my weekly walkthrough! If you’ve stumbled across this blog while looking for a detailed guide to the <a href="https://app.letsdefend.io/challenge/ntlm-relay"><strong>NTLM Relay</strong></a> blue team challenge from <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a>, you’re in the right place.</p><p>For this challenge, we’re stepping into the role of a security analyst investigating suspicious activity within an Active Directory environment. What begins as unusual network traffic quickly develops into a potential NTLM relay attack involving SMB authentication, Remote Registry access, and lateral movement between systems.</p><p>We’re provided with two primary sources of evidence: a packet capture (traffic.pcapng) and several Windows Event Log artifacts. We&#39;ll bust out <strong>Wireshark</strong> and <strong>Event Log Explorer</strong> from the toolbox to examine both network and host-based artifacts.</p><p>Using these resources, we’ll identify a suspicious host, analyze NTLM authentication activity, correlate Windows logon events, investigate Remote Registry access, and follow the attacker’s actions as they attempt to access administrative resources on another workstation.</p><p>Since NTLM relay is a topic that can become fairly technical, I’ll keep the explanations focused on what matters for the investigation. The goal isn’t just to answer the challenge questions, but to understand why we’re looking for SMB activity, NTLM authentication events, logon records, and administrative share access in the first place.</p><p>Sounds like fun, right? Let’s go!</p><p>Thanks for reading and going on this investigation with me!</p><p><em>This write-up is for educational purposes only. All intellectual property related to the challenge belongs to the respective owners [</em><a href="https://app.letsdefend.io/"><strong><em>LetsDefend</em></strong></a><em>]</em></p><h3>Challenge Scenario:</h3><blockquote>During a routine network monitoring session, Sarah, a senior security analyst at Sopranos Enterprises, noticed unusual traffic patterns on their internal network. The traffic appeared to originate from a compromised machine probing multiple systems, suggesting an attempt at lateral movement. It seems the attacker was targeting machines within the Active Directory environment to escalate privileges and compromise additional systems. The security team quickly began investigating, but the full extent of the breach is still unknown. Further analysis of logs and network traffic is required to assess the impact.</blockquote><h3>NTLM Relay Primer:</h3><p>Alright, before we dive deeper into the investigation, let’s do a quick high-level recap of how an NTLM relay attack works.</p><p><strong>NTLM</strong> is a legacy Windows authentication protocol that uses a challenge-response process to verify a user’s identity. Rather than transmitting a password across the network, the client proves it possesses valid credentials by responding to a challenge from the server.</p><p>In an NTLM relay attack, an attacker coerces a victim machine into attempting to authenticate to an attacker-controlled resource, often an <strong>SMB</strong> share. The attacker positions themselves as an adversary-in-the-middle and relays the victim’s authentication messages to another system that accepts NTLM authentication. If successful, the target system treats the attacker as the legitimate user even though the attacker never knows the user’s password. Because the authentication is relayed in real time, there’s no password cracking involved. Instead, the attacker abuses a legitimate authentication attempt to gain access to remote systems, shares, or services.</p><p>For an excellent overview of NTLM and NTLM Relay attacks, I’d highly recommend checking out <a href="https://specterops.io/blog/2025/04/08/the-renaissance-of-ntlm-relay-attacks-everything-you-need-to-know/"><strong>“The Renaissance of NTLM Relay Attacks: Everything You Need to Know”</strong></a> from SPECTEROPS. Great read and it helped inform my own investigation and write-up.</p><p>While this challenge isn’t intended to be a perfect representation of every NTLM relay attack, understanding the basics of the attack will help explain the artifacts we’ll be looking for throughout the investigation.</p><p>As we analyze the packet capture and Windows event logs, we’ll focus on:</p><ul><li>SMB traffic on port 445</li><li>NTLMSSP authentication activity</li><li>Logon events associated with relayed authentication</li><li>Access to remote shares</li><li>Evidence of lateral movement between systems</li></ul><p>Keeping this workflow in mind makes it easier to understand why these seemingly separate network and log artifacts are all connected. Let’s go!</p><h3>Question 1: Which IP address in the network traffic lacks a hostname and is considered suspicious?</h3><p>Let’s kick off this investigation.</p><p>Extract NTLM-Relay.7z. Inside, you&#39;ll find a folder called Logs, which contains several Windows Event Logs, along with traffic.pcapng, a network packet capture file. This means we&#39;ll approach the challenge from two different perspectives: Windows logs and network traffic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1-8FuAF-NqavTnWA.png" /><figcaption><em>Overview of the challenge artifacts</em></figcaption></figure><p>To answer <strong>Question 1</strong>, we’ll start with the network traffic in traffic.pcapng. Double-click the file to open it in <strong>Wireshark</strong>.</p><p>To get a quick view of all hostnames contained in the capture, enable <em>Resolve Network Addresses</em> under <strong>View &gt; Name Resolution</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1021/0*CiMLWIu9SWwD05SY.png" /><figcaption><em>Wireshark: Setting network address resolution</em></figcaption></figure><p>Next, select <strong>Statistics &gt; Resolved Addresses</strong>. When the window opens, select <strong>Hosts</strong> from the dropdown menu. This provides a quick overview of the addresses and hostnames observed in the capture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BPBwFVljLa9KOo1e.png" /><figcaption><em>Wireshark: Viewing the observed Hosts addresses</em></figcaption></figure><p>Focusing on the non-routable LAN addresses, the most suspicious entry is SOPRANOS/192.168.110.135, which lacks the .local domain identifier visible on the other internal systems.</p><p>This stands out because, while the hostname resembles the organization’s naming convention (<em>username.local</em>), it’s a little strange. Given the challenge’s focus on lateral movement within an Active Directory environment, a system that differs from expected naming conventions deserves a little more scrutiny.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pLLtIy2kvUKtzvkl.png" /></figure><h3>Question 2: When did the attacker first initiate a network scan within the environment?</h3><p>Now that we’ve identified the attacker’s IP address, we can pivot and filter the packet capture to determine when the scanning activity began.</p><pre>ip.src==192.168.110.135</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2mWZ8GO1xsknBwOi.png" /><figcaption><em>Wireshark: Filtering for traffic with the attacker’s IP as the source</em></figcaption></figure><p>Right away, you’ll notice numerous connection attempts involving port 445. This is the SMB port commonly used for file sharing and other Windows networking functions, making it a critical detail in our investigation. Remember from our brief NTLM relay primer that attackers often attempt to coerce a victim into authenticating to an attacker-controlled SMB service as a relay point.</p><p>Let’s refine the filter further so we only view SMB-related traffic.</p><pre>ip.src==192.168.110.135 &amp;&amp; tcp.port==445</pre><p>This provides a clearer view of the attacker’s SMB-focused activity and helps us identify when the enumeration of SMB services began. Looking at the first matching entry in the packet capture, we can see the earliest observed scan activity occurred at: 2024-09-14 05:04:11</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4yrK_AWlfN39cPDH.png" /><figcaption><em>Wireshark: Filtering for traffic with the attacker’s IP as the source bound for port 445</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2csgUdOQ7Xz6F7r-.png" /></figure><h3>Question 3: What is the hostname associated with the IP address 192.168.110.148?</h3><p>To answer <strong>Question 3</strong>, we can return to the <strong>Wireshark</strong> <em>Resolved Addresses</em> view we used earlier.</p><p>From <strong>Statistics &gt; Resolved Addresses</strong>, select <strong>Hosts</strong> to view the mapping between observed IP addresses and hostnames in the packet capture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nLqroKLCPl8jtfx0.png" /><figcaption><em>Wireshark: Viewing the observed Hosts addresses</em></figcaption></figure><p>Reviewing the list, we can see that 192.168.110.148 is associated with the hostname Tony.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vC34FE3Zun0to6kz.png" /></figure><h3>Questions 4 &amp; 5:</h3><h4>Understanding the domain structure is crucial for tracking the attacker’s movement within the network. What is the domain name of the current network environment?</h4><h4>Which authentication protocol was used in the NTLM relay attack?</h4><p>Let’s recap what we know so far. We’ve identified the attacker’s IP address, the targeted network protocol, and another user/device within the environment. Now let’s continue digging into <strong>Wireshark</strong> to understand the victim’s domain and determine which authentication protocol was used during the NTLM relay attack.</p><p>As a quick refresher, attackers often attempt to coerce a victim into authenticating to an attacker-controlled SMB service during an NTLM relay attack.</p><p>I’m putting the cart before the horse a bit, but we can answer both <strong>Question 4</strong> and <strong>Question 5</strong> using the same filter. Apply the following display filter in <strong>Wireshark</strong>:</p><pre>ntlmssp</pre><p>This filter isolates NTLM Security Support Provider traffic observed in the packet capture and gives us the answer to Question 5: <a href="https://learn.microsoft.com/en-us/windows/win32/com/ntlmssp"><strong>NTLMSSP</strong></a></p><p>According to <em>Microsoft Learn</em>:</p><blockquote>NTLMSSP, whose authentication service identifier is RPC_C_AUTHN_WINNT, is a security support provider that is available on all versions of DCOM. It uses the NTLM protocol for authentication. NTLM never actually transmits the user’s password to the server during authentication.</blockquote><p>To answer <strong>Question 4</strong>, keep the ntlmssp filter applied and use Wireshark&#39;s search feature. Select the magnifying glass icon, choose <strong>String</strong>, and change the search area to <strong>Packet details</strong>. Then enter domain into the search field.</p><p>This allows us to quickly locate the domain information contained within the NTLM authentication messages and identify the domain name used in the environment, which is unsurprisingly Sopranos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sxhaeI6CrloP-jj7.png" /><figcaption><em>Wireshark: Searching for domain strings in ntlmssp traffic</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GpQJMyoC1cwbh8Sa.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gaHELOB7QNWqCj9b.png" /></figure><h3>Question 6: Part of the breach involved stealing hashes from user accounts. Which user account had its hash compromised by the attacker?</h3><p>Now that we’re homing in on the authentication protocol, let’s return to our filtered traffic.pcapng and focus on the NTLMSSP events. Specifically, we&#39;re looking for NTLMSSP_AUTH messages, which identify the account being used during the NTLM authentication process.</p><p>Reviewing the NTLMSSP_AUTH traffic reveals the account, Corrado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EWjHJWy1P4kw7EhB.png" /><figcaption><em>Wireshark: Identifying the compromised user account</em></figcaption></figure><p>One thing worth noting is that the wording of this question is a little tricky. Remember, in an NTLM relay attack, the attacker typically relays a victim’s authentication attempt to another share, server, or service. The phrasing here suggests that a hash was directly stolen, which made me initially think of techniques like password cracking or Pass-the-Hash.</p><p>While those are legitimate attack techniques that also abuse NTLM authentication, they’re different from a traditional NTLM relay attack. In this case, the packet capture shows that the Corrado account was involved in the NTLM authentication activity being leveraged by the attacker, so it works for this question.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UV4XqiaDHhh5Zren.png" /></figure><h3>Question 7: What source port was used to authenticate to the target workstation using the compromised account?</h3><p>Now that we’ve identified the compromised account, we’ll take this opportunity to pivot to the Security.evtx event log artifact in the Logs folder. This Windows event log contains, among other things, the successful logon events ( 4624) that we can use to correlate Corrado&#39;s authentication activity to the compromised workstation.</p><p>While we could simply double-click the artifact to open it in <strong>Windows Event Viewer</strong>, let’s take advantage of another excellent tool included in the <strong>LetsDefend</strong> VM: <a href="https://eventlogxp.com/"><strong>Event Log Explorer</strong></a>.</p><p><em>Event Log Explorer</em> is a third-party utility with awesome filtering capabilities that can make Windows event log analysis much simpler. To get started, open the application and drag Security.evtx into the window to load it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*y54vqfxYG9Muh50Y.png" /><figcaption><em>Event Log Explorer: Loading Security.evtx</em></figcaption></figure><p>With the log file loaded, click the filter button and enter 4624 in the <strong>Event ID(s)</strong> field to focus on successful logon events. Then add Corrado to the <strong>Text in description</strong> field.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HYsT5mhR2Z9xso-b.png" /><figcaption><em>Event Log Explorer: Filtering Security.evtx for 4624 events</em></figcaption></figure><p>This returns a single successful logon event that provides several key insights into the attack.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1011/0*sRPLfr43TeCELRnV.png" /><figcaption><em>Event Log Explorer: Identifying the source port and IP address of the suspicious login</em></figcaption></figure><p>To answer <strong>Question 7</strong>, we can review the <strong>Network Information</strong> section of the event and identify the source port as 54414.</p><p>More interestingly, notice that the <strong>Source Network Address</strong> is 192.168.110.135, the attacker&#39;s IP address, rather than 192.168.110.149, which we previously associated with Corrado&#39;s device in the packet capture.</p><p>I’m calling this detail out in the context of an NTLM relay attack. The authentication is recorded as Corrado’s account, but the network connection originates from the suspicious host. While this evidence alone isn’t a smoking gun proving NTLM relay activity, it’s a bit sus and aligns with the adversary-in-the-middle behavior discussed earlier, where a victim’s authentication is relayed through an attacker-controlled system to another target.</p><p>Let’s keep digging.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6vD9KoO2oDcUjUMG.png" /></figure><h3><strong>Question 8: What is the logon ID associated with the malicious session detected during the attack?</strong></h3><p>While reviewing the successful 4624 logon event from the previous question, we can also identify the associated <strong>Logon ID</strong>.</p><p>The <strong>Logon ID</strong> is located under the <strong>New Logon</strong> section of the event details and can be useful when correlating related authentication and activity events throughout an investigation. For example, you can use the Logon ID to tie together logon, process creation, privilege use, and logoff events that belong to the same session.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*H7qPbjqXPH5naDnP.png" /></figure><h3>Question 9: When did the malicious login occur? Please provide the timestamp in UTC.</h3><p>To answer <strong>Question 9</strong>, we’ll stick with <strong>Event Log Explorer</strong>. There’s a little trick to finding the login timestamp in UTC.</p><p>While the event listing already includes a time column, this typically displays the event using the local system time. Since the question specifically asks for the UTC timestamp, we’ll need to look a little deeper.</p><p>Double-click the 4624 logon event, switch to the <strong>XML</strong> tab, and scroll to the SystemTime field within the event data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YFze_eQMpEphs8_J.png" /><figcaption><em>Event Log Explorer: Identifying the UTC timestamp of the malicious login</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wK8nBADnx41orfNa.png" /></figure><h3>Question 10: How many failed login attempts were recorded before the attacker successfully logged in?</h3><p>Let’s pivot away from the successful logon events ( 4624) and focus on failed logon events ( 4625).</p><p>We’ll use the same process in <strong>Event Log Explorer</strong>, but this time we’ll update the filter to return only 4625 events and review the resulting logon failures.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ep0wJ1mtv04ba6ss.png" /><figcaption><em>Event Log Explorer: Identifying all logon failures</em></figcaption></figure><p>The results show a total of <strong>six failed logon attempts</strong>.</p><p>Looking more closely at the events, each failed logon originates from the same source network address, 192.168.110.135, and uses NtLmSsp for authentication. This is the same suspicious host we&#39;ve been tracking throughout the investigation. Context, context, context.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*J3Q19eDvezhVfNYq.png" /></figure><h3>Question 11: Which protocol did the attacker use to access the Windows registry remotely?</h3><p>Let’s jump back over to <strong>Wireshark</strong> and see if we can identify any remote registry activity. To do that, we’ll spend a minute researching how Windows Remote Registry operations are represented in packet captures.</p><p>According to the <em>Wireshark Wiki</em>, the <a href="https://wiki.wireshark.org/WINREG"><strong>Microsoft Windows Remote Registry Service (WINREG)</strong></a> protocol is used to access the Windows Registry remotely across the network.</p><p>Armed with that information, we can apply the following display filter in <strong>Wireshark</strong>:</p><pre>winreg</pre><p>If remote registry activity is present in the capture, this filter will isolate the relevant traffic and allow us to confirm the protocol in use.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*42YqQPwvG-nYFkDR.png" /><figcaption><em>Wireshark: Filtering WINREG protocol traffic</em></figcaption></figure><p>The filtered results show Windows Remote Registry traffic, confirming that the attacker used the <strong>WINREG</strong> protocol to access the registry remotely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*o8KJTRlCGWkAJH-e.png" /></figure><h3>Question 12: Which registry key was the attacker able to access that is responsible for credential storage?</h3><p>Next up, we’ll need to identify the specific registry key the attacker accessed through the Remote Registry service.</p><p>Back in <strong>Wireshark</strong>, keep the winreg display filter applied and review the captured Remote Registry activity. Looking through the packets, we&#39;ll eventually find an OpenKey request referencing the following registry path:</p><pre>SYSTEM\CurrentControlSet\Control\Lsa\JD</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qJ03nIBysyliOkpV.png" /><figcaption><em>Wireshark: Identifying the remote registry key accessed by the attacker</em></figcaption></figure><p>This one is really interesting because it gives us some insight into the attacker’s potential objectives.</p><p>The <strong>Local Security Authority (LSA)</strong> plays a central role in Windows authentication and the protection of credential-related information. When an attacker starts accessing LSA-related registry keys, it can be an indication that they’re attempting to gather authentication material that could be used to expand access or move laterally through the environment.</p><p>While the presence of this key alone doesn’t prove credential dumping occurred, it aligns with the playbook associated with tools such as secretsdump.py that are used to dump password hashes and other authentication secrets from Windows systems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8jq_vzA4J4CKKnzh.png" /></figure><h3>Question 13: Which network share was the attacker trying to access after gaining initial access?</h3><p>Okay, now we’re starting to see where this attack may have been headed.</p><p>Based on the evidence we’ve collected so far, the attacker appears to have leveraged NTLM authentication to gain access to Tony’s device, performed Remote Registry activity against LSA-related keys, and then attempted to access a network share. Let’s see what we can find.</p><p>Back in <strong>Wireshark</strong>, change the display filter to show SMB traffic originating from the suspected attacker host:</p><pre>(smb or smb2) and ip.src==192.168.110.135</pre><p>With the filter applied, look for a <em>Tree Connect Response</em> packet. In this capture, turn your attention to packet 3397 indicating access to a network share.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MfGTXCaY6f4WcuCb.png" /><figcaption><em>Wireshark: Identifying the network share targeted by the attacker</em></figcaption></figure><p>Reviewing the packet details reveals that the attacker connected to:</p><pre>\\192.168.110.148\ADMIN$</pre><p>Remember from <strong>Question 3</strong> this is Tony’s device. The ADMIN$ share is one of Windows&#39; classic built-in administrative shares. Users with administrative permissions can use it to remotely access the system&#39;s file structure and perform administrative/malicious tasks.</p><p>Taken together with the previous evidence, this suggests the attacker was attempting to leverage administrative access on Tony’s workstation following the authentication activity we observed earlier. Yikes!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IjAi0NcHkMXcueYK.png" /></figure><h3>Question 14: What is the name of the temporary file created by the malicious tool during the authentication process?</h3><p>Continuing our review of the SMB activity, we can look directly below the SMB2 Tree Connect request from the previous question.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CmQigUKGaEMrkaSX.png" /><figcaption><em>Wireshark: Identifying the temporary file created during the authentication process</em></figcaption></figure><p>A couple packets later, packet 3399 contains a Create Request operation for the following file:</p><pre>Temp\FBcANENg.tmp</pre><p>This indicates that a temporary file was created on the target system as part of the attacker’s activity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*v-a9eQE-EFULvdqz.png" /></figure><h3>Question 15: What is the MITRE ID that is associated with this attack?</h3><p>Okay, we’ve made it to the last question in our investigation!</p><p>Our final objective is to take everything we’ve uncovered and identify the MITRE ATT&amp;CK technique that most closely aligns with the attacker’s activity.</p><p>Throughout the investigation, we observed NTLM authentication activity, evidence suggesting a possible NTLM relay, Remote Registry access, and subsequent access to Tony’s administrative share. While we didn’t identify the exact coercion method used to trigger the authentication attempt, we have enough evidence to identify the closest MITRE ATT&amp;CK technique:</p><p><a href="https://attack.mitre.org/techniques/T1557/001/"><strong>MITRE ATT&amp;CK — Adversary-in-the-Middle: Name Resolution Poisoning and SMB Relay — (T1557.001):</strong></a></p><blockquote>By responding to LLMNR/NBT-NS/mDNS network traffic, adversaries may spoof an authoritative source for name resolution to force communication with an adversary controlled system.[1] This activity may be used to collect or relay authentication materials</blockquote><p>Based on the evidence available in the challenge, <strong>T1557.001</strong> is the closest ATT&amp;CK mapping because it specifically describes the interception and SMB relay of NTLM authentication to another system.</p><p>Awesome job, now let’s wrap up this investigation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*F6oFbSDXRh-e6IXk.png" /></figure><h3>Conclusion:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CH_T-Qaw99i-jyXB.png" /></figure><p>How fun was that! A big thank you to <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a> for another awesome challenge.</p><p>This challenge was a great introduction to investigating NTLM relay activity and highlighted how difficult these attacks can be to identify from a single artifact alone. Unlike some investigations where a single log entry immediately tells the story, this one required us to collect evidence from multiple sources and slowly piece together what happened.</p><p>Throughout the investigation, we used <strong>Wireshark</strong> and <strong>Event Log Explorer</strong> to analyze network traffic and Windows event logs. Along the way, we identified suspicious SMB activity, examined NTLMSSP authentication events, correlated successful and failed logons, investigated Remote Registry access, and followed the attacker&#39;s actions as they moved toward administrative resources on a target workstation.</p><p>Personally, that’s what I enjoyed most about this challenge. There wasn’t a clear smoking gun that immediately screamed “NTLM relay attack.” Instead, we had to combine multiple clues. A suspicious host scanning SMB services. Authentication activity associated with one user but originating from another system. Remote Registry access against LSA-related keys. Administrative share access. Individually, none of these artifacts conclusively prove NTLM relay. Together, however, they begin to tell a much more compelling story.</p><p>I chose this week’s challenge because NTLM relay attacks have seen renewed attention in recent years, and I wanted to spend some time better understanding both the attack workflow, and the evidence defenders can use to detect it. The challenge reinforced an important lesson that applies well beyond NTLM relay — investigations in Active Directory environments often need correlation and context. Attackers rarely leave behind a single event that fully explains their actions. Instead, defenders have to connect network traffic, authentication activity, endpoint artifacts, and security logs to understand what’s really happening.</p><p>Thanks for your support and partnering on this investigation. If you found this walkthrough helpful, please give it a clap and consider following me! Your feedback is invaluable, and it pumps me up to support your security journey. Remember, cybersecurity is a team sport, and we’re in this together!</p><p>Until next week’s challenge, stay curious and be safe out there!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/0*qea9A3AVirdAxA17.png" /></figure><h3>Tools &amp; References:</h3><p><strong>Challenge Link:</strong> <a href="https://app.letsdefend.io/challenge/ntlm-relay">https://app.letsdefend.io/challenge/ntlm-relay</a></p><p><strong>SPECTEROPS: “The Renaissance of NTLM Relay Attacks: Everything You Need to Know”:</strong> <a href="https://specterops.io/blog/2025/04/08/the-renaissance-of-ntlm-relay-attacks-everything-you-need-to-know/">https://specterops.io/blog/2025/04/08/the-renaissance-of-ntlm-relay-attacks-everything-you-need-to-know/</a></p><p><strong>Microsoft Learn — NTLMSSP:</strong> <a href="https://learn.microsoft.com/en-us/windows/win32/com/ntlmssp">https://learn.microsoft.com/en-us/windows/win32/com/ntlmssp</a></p><p><strong>Event Log Explorer:</strong> <a href="https://eventlogxp.com/">https://eventlogxp.com/</a></p><p><strong>Wireshark Wiki — WINREG:</strong> <a href="https://wiki.wireshark.org/WINREG">https://wiki.wireshark.org/WINREG</a></p><p><strong>MITRE ATT&amp;CK — Adversary-in-the-Middle: Name Resolution Poisoning and SMB Relay — (T1557.001):</strong> <a href="https://attack.mitre.org/techniques/T1557/001/">https://attack.mitre.org/techniques/T1557/001/</a></p><p><em>Originally published at </em><a href="https://stumblesec.com/posts/letsdefend-ntlm-relay-challenge-walkthrough/"><em>https://stumblesec.com</em></a><em> on July 28, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d28073203b6b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LetsDefend: Phishing Email Challenge Walkthrough]]></title>
            <link>https://stumblesec.medium.com/letsdefend-phishing-email-challenge-walkthrough-3e4174441f6f?source=rss-b1b82253e27c------2</link>
            <guid isPermaLink="false">https://medium.com/p/3e4174441f6f</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[phishing]]></category>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[lets-defend]]></category>
            <category><![CDATA[letsdefendio]]></category>
            <dc:creator><![CDATA[Drew Arpino]]></dc:creator>
            <pubDate>Sun, 12 Jul 2026 23:01:01 GMT</pubDate>
            <atom:updated>2026-07-12T23:01:01.338Z</atom:updated>
            <content:encoded><![CDATA[<h4>Phishing Email Analysis Using Thunderbird and VirusTotal: Header Investigation, URL Reputation, and Trusted-Platform Abuse</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/0*HwHJLCCd5L2hmeKo.png" /><figcaption>Image Credit: <a href="https://app.letsdefend.io/challenge/phishing-email">https://app.letsdefend.io/challenge/phishing-email</a></figcaption></figure><h3>Introduction:</h3><p>Welcome to my weekly walkthrough! If you’ve stumbled across this blog while looking for a detailed guide to the <a href="https://app.letsdefend.io/challenge/phishing-email"><strong>Phishing Email</strong></a><strong> </strong>blue team challenge from <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a>, you’re in the right place.</p><p>This challenge is rated as beginner-friendly by the authors, making it a great starting point if you’re interested in learning more about phishing analysis and email investigations.</p><p>For this challenge, we’re putting on the boots of a security analyst investigating a suspicious email that appears to be from PayPal. While the message looks convincing at first glance, our job is to determine whether it’s legit or part of a phishing campaign.</p><p>Fortunately, we’re provided with the original email in .eml format. Using artifacts contained within the message itself, we&#39;ll examine email headers, identify embedded URLs, investigate domain reputation, and leverage external threat intelligence sources to confidently answer if it&#39;s phishing or not.</p><p>What’s in the toolbox for this investigation? We’ll use <strong>Mozilla Thunderbird</strong>, <strong>VirusTotal</strong>, and <strong>Netify</strong> to analyze the message from both a user and analyst perspective. More importantly, we’ll practice one of the most valuable skills in cyber defense: collecting multiple indicators and correlating them to make an informed decision.</p><p>Since this challenge is intended for beginners, I’ll take a little extra time to explain what we’re looking at and why it’s important. Remember, the goal isn’t just to get the right answers, but to understand the thought process behind investigating suspicious emails in the real world.</p><p>Sounds like fun, right? Let’s go!</p><p>Thanks for reading and going on this investigation with me!</p><p><em>This write-up is for educational purposes only. All intellectual property related to the challenge belongs to the respective owners [</em><a href="https://app.letsdefend.io/"><em>LetsDefend</em></a><em>]</em></p><h3>Challenge Scenario:</h3><blockquote>Your email address has been leaked and you receive an email from Paypal in German. Try to analyze the suspicious email.</blockquote><h3>Question 1: What is the return path of the email?</h3><p>Let’s kick off this investigation. Extract PhishingChallenge.zip from the Files folder on the Desktop to reveal our challenge artifact, paypal.eml.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bQcvf99PbyqyGWwJMAJN5Q.png" /><figcaption><em>Overview of the Challenge Artifacts</em></figcaption></figure><p>We have a couple of ways to analyze this in the real world. Since this is a beginner-friendly challenge, we’re going to focus on manual, hands-on analysis. To start, we’ll open the email in a mail client and view it from the same perspective as an end user.</p><p>Once the file is extracted, double-click paypal.eml to open it in the <strong>Mozilla Thunderbird</strong> mail client provided in the LetsDefend VM. This displays the phishing email, but we&#39;re interested in the Return-Path value.</p><p>If you’re new to header analysis, I’ll point you to an excellent reference, the <a href="https://mailtrap.io/blog/email-headers/"><strong>Email Headers Guide</strong></a> from <strong>Mailtrap</strong>. This is a handy resource if you need more information about a particular header. For example, they describe the <em>Return-Path</em> as:</p><blockquote>Return-Path is added automatically by the recipient’s email server and records the initial sender during the SMTP session. Any bounces that occurred during the SMTP session return to the Return-Path address.</blockquote><p>Put another way, this can help give us a clue about the sender’s infrastructure and identify mismatches between what is displayed in the From field and the actual sending source or bounce address.</p><p>To access the header information, press View &gt; Message Source (or Ctrl+U) to display the full message headers:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6fKOr9ctSKbPtq2DfuzZwg.png" /><figcaption><em>Thunderbird: Accessing the Message Source</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*StBihLXBc-SKy4mfe8OONw.png" /><figcaption><em>Thunderbird: Identifying the Return-Path header in the Message Source</em></figcaption></figure><p>Notice that the Return-Path is <em>not</em> related to the visible sender domain, kodehexa.net. More importantly, it isn&#39;t associated with PayPal, despite the email presenting itself as a PayPal message. This mismatch is an early indicator that the message might not be legitimate and warrants closer investigation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BMuUWh2GUrNymRGtyRO1jg.png" /></figure><h3>Question 2: What is the domain name of the url in this mail?</h3><p>Our next task is to identify the domain name of the URL embedded in the email. We can approach this in two ways.</p><ol><li>Hover over the link in the rendered email within <strong>Mozilla Thunderbird</strong>. This is the same process we security folks often tell users to follow before clicking a link.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ygJuKFuQCJP2X9NqT_9Wnw.png" /><figcaption><em>Thunderbird: Examining the link URL in the email body</em></figcaption></figure><p>2. We can also locate the URL in the email’s message source. Since the source displays the HTML content of the message, we can find the href attribute associated with the button.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V0ghXQk2s2TnsIU66PprTw.png" /><figcaption><em>Identifying the URL in the message source</em></figcaption></figure><p>Both methods reveal the same destination URL. For <strong>Question 2</strong>, we don’t need the full URL, only the hosting domain. In this case, the domain is storage.googleapis.com.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JnS_H06eFuXNAQWrkwF2hA.png" /></figure><h3>Question 3: Is the domain mentioned in the previous question suspicious?</h3><p>This is a tricky question and a good demonstration of attackers abusing legitimate services to host phishing content.</p><p>Let’s do some external research to learn more about the domain. One useful resource is <a href="https://www.netify.ai/resources/hostnames/storage.googleapis.com"><strong>Netify</strong></a>, which provides information about domains, hostnames, and the services associated with them. Looking up storage.googleapis.com, we find the following description:</p><blockquote>storage.googleapis.com is associated with the <a href="https://www.netify.ai/resources/applications/google-storage">Google Cloud Storage</a> application. The hostname points to approximately 560 IP addresses on Google Cloud Platform. The hostname is part of the <a href="https://www.netify.ai/resources/domains/googleapis.com">googleapis.com</a> domain.</blockquote><p>This tells us that storage.googleapis.com is a legitimate Google-owned domain used by <strong>Google Cloud Storage</strong>.</p><p>However, legitimacy does not automatically mean it’s not suspicious. Attackers can and do abuse trusted cloud platforms to host phishing pages, malware, and other malicious content. Doing so may help bypass basic domain reputation checks and can make links appear more trustworthy at first glance. This technique is often referred to as trusted-platform phishing.</p><p>Let’s take this a step further and examine the full URL in <a href="https://www.virustotal.com/"><strong>VirusTotal</strong></a> to see whether it has been reported by the broader security community. Copy the complete URL from the message source and search for it in <em>VirusTotal</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AymV1_HiZUHLKQ2ofwKGhQ.png" /><figcaption><em>VirusTotal: Checking the full URL against known threat intelligence</em></figcaption></figure><p>Reviewing the results, we can see detections from security vendors, a negative community score, and comments from other researchers. These indicators give us additional context about the URL and help us determine that this is suspicious.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PfrPgdyIudPW0g2tyx-Mow.png" /></figure><h3>Question 4: What is the body SHA-256 of the domain?</h3><p>For <strong>Question 4</strong>, we’re only concerned with the domain, not the full URL. Fortunately, we’re already a step ahead from our earlier <strong>VirusTotal</strong> investigation.</p><p>Modify your search so that it only includes <a href="https://storage.googleapis.com/">https://storage.googleapis.com/</a>. We&#39;ll see that there are no explicit detections associated with the domain itself. However, the community score and comments provide additional context, with several users noting that the service is frequently abused to host phishing pages and other criminal content.</p><p>To answer <strong>Question 4</strong>, we’re interested in the Body SHA-256 value associated with the domain. In <em>VirusTotal</em>, this can be found under the <strong>Details</strong> tab by expanding <strong>HTTP Response</strong> and locating <strong>Body SHA-256</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ew_K5Wze_s55sK8j8mpQiQ.png" /><figcaption><em>VirusTotal: Identifying the body SHA-256</em></figcaption></figure><p>As we can see, the Body SHA-256 value is:</p><p>13945ecc33afee74ac7f72e1d5bb73050894356c4bf63d02a1a53e76830567f5</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XVc9AUi9rC6t0HLCgr_65Q.png" /></figure><h3>Question 5: Is this email a phishing email?</h3><p>We’ve made it to the final question. Let’s put everything together and determine whether this is a phishing email.</p><p>We don’t need to see the final payload to identify several significant red flags. The email claims to be from PayPal, yet the sender infrastructure we’ve examined doesn’t align with PayPal. The Return-Path is unrelated to PayPal, and the sender information does not match the organization the email claims to represent.</p><p>We also identified a URL hosted on storage.googleapis.com. While the domain itself is legitimate, our investigation showed that threat actors can abuse trusted cloud platforms to host phishing content. Looking at the full URL in <strong>VirusTotal</strong>, we found detections from security vendors, a negative community score, and comments indicating that the URL has previously been associated with malicious activity.</p><p>When we combine the suspicious sender infrastructure, the impersonation of PayPal, and the threat intelligence associated with the URL, the evidence strongly suggests that, YES, this is a phishing email.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vfp-MhqcftXEsJa6QU_Bsg.png" /></figure><h3>Conclusion:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rOeIcs9AqgyqHOd6yIfx9Q.png" /></figure><p>How fun was that! A big thank you to <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a><strong> </strong>for another awesome challenge.</p><p>This challenge was a nice introduction to manual email and header analysis and did a great job of demonstrating how analysts can identify phishing emails using freely available tools and resources. While the investigation was straightforward, it introduced several concepts that form the foundation of real-world email triage and phishing analysis.</p><p>Working through the challenge, we examined key email headers, investigated sender infrastructure, extracted URLs from the message body, and enriched our findings with external threat intelligence. Resources like <em>Mailtrap’s Email Headers Guide</em> helped us better understand what we were looking at, while <em>VirusTotal</em> provided additional context that helped validate our assessment.</p><p>Personally, my favorite part about this challenge was that it mirrored a condensed version of a real-world investigative workflow. We started with a suspicious email, performed additional research, added context with threat intelligence, and then used the combined findings to reach a solid conclusion. Whether you’re investigating phishing emails, suspicious domains, malicious files, or security alerts, this process remains largely the same.</p><p>I chose this week’s challenge because phishing analysis remains one of the most valuable skills for defenders at any experience level. While AI, ML, dynamic detonation, and the like are increasingly common in defensive tooling, phishing triage is still a core foundational skill. The challenge was short, approachable, and logical, with each question naturally building on the previous one. It’s an excellent starting point for anyone interested in learning how to analyze suspicious emails without immediately relying on automated tools to provide the answer.</p><p>Thanks for your support and partnering on this investigation. If you found this walkthrough helpful, please give it a clap and consider following me! Your feedback is invaluable, and it pumps me up to support your security journey. Remember, cybersecurity is a team sport, and we’re in this together!</p><p>Until next week’s challenge, stay curious and be safe out there!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/1*lAzW-XArQrYfSbfHFTC0Ww.png" /><figcaption><em>This image was created using an AI image creation program.</em></figcaption></figure><h3>Tools &amp; References:</h3><p><strong>Challenge Link: </strong><a href="https://app.letsdefend.io/challenge/phishing-email">https://app.letsdefend.io/challenge/phishing-email</a></p><p><strong>Mailtrap — Email Headers Guide:</strong> <a href="https://mailtrap.io/blog/email-headers/">https://mailtrap.io/blog/email-headers/</a></p><p><strong>Netify — Hostname Info:</strong> <a href="https://www.netify.ai/resources/hostnames/storage.googleapis.com">https://www.netify.ai/resources/hostnames/storage.googleapis.com</a></p><p><strong>VirusTotal:</strong> <a href="https://www.virustotal.com/">https://www.virustotal.com/</a></p><p><strong>VirusTotal — Phishing Link:</strong> <a href="https://www.virustotal.com/gui/url/368c807550a0b3938b38f126a35cd732b211bb0f174638234670b84a5299af96">https://www.virustotal.com/gui/url/368c807550a0b3938b38f126a35cd732b211bb0f174638234670b84a5299af96</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3e4174441f6f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LetsDefend: Hidden Backdoor Challenge Walkthrough]]></title>
            <link>https://stumblesec.medium.com/letsdefend-hidden-backdoor-challenge-walkthrough-3fd4338ddc47?source=rss-b1b82253e27c------2</link>
            <guid isPermaLink="false">https://medium.com/p/3fd4338ddc47</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[lets-defend]]></category>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[letsdefendio]]></category>
            <dc:creator><![CDATA[Drew Arpino]]></dc:creator>
            <pubDate>Sun, 05 Jul 2026 23:01:01 GMT</pubDate>
            <atom:updated>2026-07-05T23:01:01.454Z</atom:updated>
            <content:encoded><![CDATA[<h4>Investigating a Drive-By Compromise: Browser Forensics, MFT Analysis, BITS Abuse, and Malware Attribution</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/0*ILZ5oZq-4HaBWIFP.png" /><figcaption>Image Credit: <a href="https://app.letsdefend.io/challenge/hidden-backdoor">https://app.letsdefend.io/challenge/hidden-backdoor</a></figcaption></figure><h3>Introduction:</h3><p>Welcome to my weekly walkthrough! If you’ve stumbled across this blog while looking for a detailed guide to the <a href="https://app.letsdefend.io/challenge/hidden-backdoor"><strong>Hidden Backdoor</strong></a> blue team challenge from <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a>, you’re in the right place.</p><p>This challenge is <strong>rated HARD</strong> by the authors, but don’t let that scare you off. Whether you’re building your digital forensics skills or already have some investigations under your belt, this challenge does a great job of walking us through the process of reconstructing an attack from a collection of host-based artifacts.</p><p>For this challenge, we’re investigating a suspicious file named NotionSetup.exe discovered on a senior developer&#39;s workstation. Our job is to determine how the file got on the system, what happened after it was executed, and whether it was part of a larger attack chain.</p><p>Fortunately, we’re provided with a triage image from the affected system. Using artifacts such as the <strong>Master File Table (MFT)</strong>, <strong>Chrome History</strong>, <strong>Windows Prefetch</strong>, <strong>BITS Client Event Logs</strong>, and the <strong>USN Journal</strong>, we’ll piece together a timeline of events and follow the evidence wherever it takes us.</p><p>Throughout the investigation we’ll lean heavily on <strong>Eric Zimmerman’s</strong> forensic tools, along with <strong>Event Log Explorer</strong>, <strong>VirusTotal</strong>, and a few native Windows utilities. More importantly, we’ll practice one of the most valuable skills in DFIR: correlating multiple artifacts to confidently build our timeline and frame our conclusions.</p><p>Since this challenge is a higher difficulty level, I won’t stop to explain every tool in depth since you’ll already be familiar with them. Instead, I’ll focus on the investigative process, the artifacts that matter, and the reasoning behind each pivot. The goal isn’t just to get the right answers but to build the mindset needed to tackle similar investigations in the real world.</p><p>Sounds like fun, right? Let’s go!</p><p>Thanks for reading and going on this investigation with me!</p><p><em>This write-up is for educational purposes only. All intellectual property related to the challenge belongs to the respective owners [</em><a href="https://app.letsdefend.io/"><strong><em>LetsDefend</em></strong></a><em>]</em></p><h3>Challenge Scenario:</h3><blockquote>A senior developer at AINokhba Enterprises discovered an unfamiliar file named “NotionSetup.exe” on their workstation. Curious and concerned, they executed the file, but nothing appeared to happen. Fearing that something might be wrong, they immediately reported the incident to the company’s security team.</blockquote><blockquote>Your task is to analyze a triage image from the senior developer’s machine to determine how the file ended up on their system and what actions, if any, were triggered by executing it.</blockquote><h3>Question 1: Can you determine the exact domain from which “notion-setup.exe” was downloaded? (site.com)</h3><p>Let’s jump right into our investigation! From the ChallengeFile folder on the desktop, extract hiddenbackdoor.7z which leaves us with the folder C. This archive contains the Windows artifacts we’ll use throughout the investigation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TV2ndTDp5xS-jG91sgBVTA.png" /><figcaption><em>Overview of the challenge file artifacts</em></figcaption></figure><p>The first step is identifying the exact domain from where notion-setup.exe was downloaded. A natural starting point is the <strong>Master File Table (MFT)</strong>. While the <em>Mark of the Web (MotW)</em> itself is stored as an alternate data stream (Zone.Identifier) attached to the file, tools like <a href="https://ericzimmerman.github.io/"><strong>Eric Zimmerman’s MFTExplorer</strong></a> can surface that metadata through the file’s MFT record.</p><p>To access the MFT, we’ll need a specialized tool such as <em>MFTExplorer</em> (GUI) or <em>MFTECmd</em> (command line). For illustrative purposes, I’ll use <em>MFTExplorer</em>, which is already loaded on the <strong>LetsDefend</strong> VM at:</p><p>C:\Users\LetsDefend\Desktop\Tools\Eric Zimmerman Tools\MFTExplorer\MFTExplorer.exe</p><p>Once the tool is open, navigate to <em>File &gt; Load MFT</em> and select the $MFT file from the challenge artifacts. This will take awhile to load, so sit back and relax.</p><p>After loading, navigate to the download directory of the user a1l4m and locate notion-setup.exe. In the record overview, look for the [ZoneTransfer] metadata, specifically the ReferrerURL.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bSORLeMu8HP3unma7MKBwA.png" /><figcaption><em>MFT Explorer: Identifying the notion-setup.exe download</em></figcaption></figure><p>There’s a small problem here. The value retrieved is an IP address rather than a domain, which doesn’t fully answer the question. This might indicate a direct IP-based download, a redirect, or CDN usage, or so we’ll need to pivot to another artifact to enrich the data and turn up the domain.</p><p>A logical next step is to review the browser history and correlate the timestamp from the MFT with browser activity. For this, we can use <a href="https://sqlitebrowser.org/"><strong>DB Browser for SQLite</strong></a> to check out the local browser cache database artifacts. This tool is also available in the tools directory:</p><p>C:\Users\LetsDefend\Desktop\Tools\DB.Browser.for.SQLite-v3.13.0-win64\DB Browser for SQLite.exe</p><p>Open it up and select <em>Open Database</em>, and navigate to the <em>Google Chrome</em> history file:<br> C:\Users\LetsDefend\Desktop\ChallengeFile\C\Users\a1l4m\AppData\Local\Google\Chrome\User Data\Default\History</p><p>Make sure to change the file type filter to <em>All Files</em> so the database appears.</p><p><strong>NOTE:</strong> If you’re ever unsure where Chrome stores specific artifacts, the <em>Chrome Browser History Examiner — User Guide</em> from <a href="https://www.foxtonforensics.com/browser-history-examiner/chrome-history-location"><strong>Foxton Forensics</strong></a> is an excellent resource to bookmark.</p><p>With the History database open, select the downloads table, and right-click the row to select <em>&quot;Browse Table&quot;</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P4aRPsRYoCRE5VZXOGjcGw.png" /><figcaption><em>DB Browser: Locating the downloads table in the History database</em></figcaption></figure><p>Bingo! There’s only a single entry, and it corresponds to notion-setup.exe. Reviewing the referrer column reveals the domain used to download the file: <a href="https://globalnewshub.com/">https://globalnewshub.com</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nhVTlYek_tMAuqJdhJsdLg.png" /><figcaption><em>DB Browser: Identifying the referrer URL of the suspicious binary</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A4HDgtfzv_nthPJhepwC2g.png" /></figure><h3>Question 2: It appears that the site the developer visited was compromised by attackers who embedded a silent downloader in the code. Which MITRE technique ID describes this method of attack? (Answer Format: TXXXX)</h3><p>To answer <strong>Question 2</strong>, we can reference the <a href="https://attack.mitre.org/"><strong>MITRE ATT&amp;CK</strong></a> knowledge base and map what we’ve observed to a known initial access technique.</p><p>In this case, we learn that the developer appears to have visited a legitimate website that had been compromised. During normal browsing activity, malicious code on the site silently triggered the download of notion-setup.exe without user interaction.</p><p>After reviewing the available initial access techniques, the best fit is, <a href="https://attack.mitre.org/techniques/T1189/"><strong>Drive-by Compromise (T1189)</strong></a>. <em>MITRE</em> describes this technique as:</p><blockquote>Adversaries may gain access to a system through a user visiting a website over the normal course of browsing. Multiple ways of delivering exploit code to a browser exist (i.e., <a href="https://attack.mitre.org/techniques/T1608/004">Drive-by Target</a>), including:</blockquote><blockquote>A legitimate website is compromised, allowing adversaries to inject malicious code</blockquote><blockquote>Script files served to a legitimate website from a publicly writeable cloud storage bucket are modified by an adversary</blockquote><blockquote>Malicious ads are paid for and served through legitimate ad providers (i.e., <a href="https://attack.mitre.org/techniques/T1583/008">Malvertising</a>)</blockquote><blockquote>Built-in web application interfaces that allow user-controllable content are leveraged for the insertion of malicious scripts or iFrames (e.g., cross-site scripting)</blockquote><p>In our scenario, the evidence suggests the developer simply visited the site, and the downloader was triggered silently. That pattern strongly matches <em>Drive-by Compromise</em>, where exploitation or payload delivery occurs as part of routine browsing activity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aU5coc1QbM7GhjRijgwRuA.png" /></figure><h3>Question 3: The injected script managed to download a file without the developer’s knowledge. What is the full URL of the file that was downloaded during the browsing session?</h3><p>Now that we’ve identified the domain notion-setup.exe came from and the MITRE technique used to deliver it, we can move on to identifying the <strong>full</strong> URL of the file.</p><p>Remember when we used <strong>Eric Zimmerman’s MFTExplorer</strong> before pivoting to browser artifacts in <strong>Question 1</strong>? This is where that little stumble comes in handy.</p><p>To answer <strong>Question 3</strong>, let’s revisit the metadata we identified earlier in <em>MFTExplorer</em>. Specifically, the [ZoneTransfer] information includes the HostURL, which provides the full URL path of the downloaded file: <a href="http://18.199.176.247:1337/notion-setup.exe">http://18.199.176.247:1337/notion-setup.exe</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bSORLeMu8HP3unma7MKBwA.png" /><figcaption><em>MFT Explorer: Identifying the notion-setup.exe download URL</em></figcaption></figure><p>This gives us a much more robust indicator than the domain alone. Having the full URL is especially useful when building out indicators of compromise (IOCs), as it allows for more targeted blocking, enrichment, and threat intelligence lookups.</p><p>It also reinforces the earlier finding. While the browser history pointed us to the referring domain, the <em>MFTExplorer</em> artifact helps confirm the exact resource that was retrieved during the session.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UAW7_94by6oSQ45xZKpgfQ.png" /></figure><h3>Question 4: When was the file downloaded to the developer’s system? (Answer format: YYYY-MM-DD HH:MM: SS)</h3><p>Fortunately, we already have this information from analyzing the <strong>MFT</strong> entry for the file.</p><p>Using <strong>MFTExplorer</strong>, we can review the timestamp columns associated with notion-setup.exe. In this case, the SI_Modified timestamp provides a reliable indicator of when the file was written to disk, which often aligns with the download event.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XmWk80Qdud-U5kMmJAuNuQ.png" /><figcaption><em>MFT Explorer: Identifying the notion-setup.exe download URL</em></figcaption></figure><p>By locating the file’s entry and reviewing the SI_Modified column, we&#39;ve identified the download time: 2024-08-17 06:13:25</p><p>This timestamp gives us a precise point in time for when the file landed on the system, which is handy for timeline reconstruction and correlating related artifacts like the browser history, or file execution events.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xjTKgbIE44gx-M4tl9TxHw.png" /></figure><h3>Question 5: What is the hash value of “notion-setup.exe”? (SHA256)</h3><p>While we’ve already gathered a ton of useful information about the file from <strong>MFTExplorer</strong>, we can’t retrieve the file’s SHA256 hash from that output alone. To calculate the hash, we can take a straightforward approach and use <strong>PowerShell</strong> in the LetsDefend VM, since the binary exists within the challenge artifacts.</p><p>Open PowerShell and run the following command: Get-FileHash C:\Users\LetsDefend\Desktop\ChallengeFile\C\Users\a1l4m\Downloads\notion-setup.exe</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mi9NuZA2HyE3pGJkFxzagQ.png" /><figcaption><em>PowerShell: Collecting the file hash of the suspicious notion-setup.exe</em></figcaption></figure><p>This cmdlet produces the SHA256 hash by default and the resulting hash is:</p><pre>DFB76BCF5A3E29225559EBBDAE8BDD24F69262492ECA2F99F7A9525628006D88</pre><p>Keep this handy as the hash is a unique fingerprint of the exact file. It might be important later if we need to perform some lookups of this sample across any intelligence platforms.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lwDQk6Y-LyKHJFcLC-Nthw.png" /></figure><h3>Question 6: Can you find out the exact time when “notion-setup.exe” was last executed on their system? (YYYY-MM-DD HH:MM:SS)</h3><p>For the next task, we need to identify the exact time this binary was executed on the developer’s system. To do that, we’ll pivot away from the <strong>Master File Table (MFT)</strong> and examine another valuable forensic artifact: <strong>Windows Prefetch</strong>.</p><p>The value of Prefetch files is explained well by <a href="https://www.magnetforensics.com/blog/forensic-analysis-of-prefetch-files-in-windows/"><strong>Magnet Forensics</strong></a>:</p><blockquote>Prefetch files are great artifacts for forensic investigators trying to analyze applications that have been run on a system. Windows creates a prefetch file when an application is run from a particular location for the very first time. This is used to help speed up the loading of applications. For investigators, these files contain some valuable data on a user’s application history on a computer.</blockquote><p>Let’s put that into practice! For this challenge, the Prefetch artifacts can be found in:</p><p>C:\Users\LetsDefend\Desktop\ChallengeFile\C\Windows\Prefetch</p><p>But, if you browse the directory, you’ll quickly notice that Prefetch files aren’t exactly human-readable. To parse them, we’ll leverage another excellent <strong>Eric Zimmerman</strong> tool, <strong>PECmd</strong>, which is already installed on the LetsDefend VM.</p><p>To unleash the tool, open PowerShell and run the following command to parse the Prefetch files and export the results to a CSV:</p><pre>.\PECmd.exe -d &quot;C:\Users\LetsDefend\Desktop\ChallengeFile\C\Windows\Prefetch\&quot; --csv &quot;C:\Users\LetsDefend\Desktop&quot; --csvf pecmd.csv</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mgGX_hKpxvSl-t3dnHVVRw.png" /><figcaption><em>PowerShell: Using PECmd on the prefetch artifact</em></figcaption></figure><p>After the command completes, we’ll have a new file named pecmd.csv. To analyze the results, we&#39;ll pivot to another <em>Zimmerman</em> tool, <strong>Timeline Explorer</strong>. <em>Timeline Explorer</em> is a powerful CSV viewer with awesome filtering capabilities. Open <em>Timeline Explorer</em> from the tools directory and load our new file, pecmd.csv.</p><p>In the <strong>Source Filename</strong> column, filter for: notion-setup.exe</p><p>This should return a single result. From there, scroll across to the <strong>Last Run</strong> column to identify the most recent execution time recorded by the Prefetch artifact.</p><p>This gives us the next key event in our timeline and provides the answer to <strong>Question 6</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PwRPUvd5ZMr7fejnwQ52Iw.png" /><figcaption><em>Timeline Explorer: Identifying the Last Run timestamp of notion-setup.exe</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*axYszBQl27TWkqywTCwCOA.png" /></figure><h3>Question 7: It seems that “notion-setup.exe” was just the first step. The malware tried to connect to another URL to download the second stage. What is the URL it attempted to contact?</h3><p>Uh-oh, it seems like notion-setup.exe was only the first stage. The malware attempted to retrieve a second-stage payload after execution. Let&#39;s pivot off what we already know and see what else we can uncover.</p><p>A good place to start is the Windows Event Logs. The logs are located in: C:\Users\LetsDefend\Desktop\ChallengeFile\C\Windows\System32\winevt\Logs</p><p>The first log we’ll investigate is Microsoft-Windows-Bits-Client%4Operational.evtx</p><p>Why start there? At this point, we’re looking for evidence of a follow-on download attempt. Normally, I’d love to have something like <strong>Sysmon</strong> available, but since we don’t, we need to focus on Windows artifacts that attackers commonly abuse. Two good candidates are PowerShell logs and <a href="https://learn.microsoft.com/en-us/windows/win32/bits/background-intelligent-transfer-service-portal"><strong>Background Intelligent Transfer Service (BITS)</strong></a> activity.</p><p>MITRE ATT&amp;CK documents this technique as <a href="https://attack.mitre.org/techniques/T1197/"><strong>BITS Jobs (T1197)</strong></a>:</p><blockquote>Adversaries may abuse BITS jobs to persistently execute code and perform various background tasks. Windows Background Intelligent Transfer Service (BITS) is a low-bandwidth, asynchronous file transfer mechanism exposed through Component Object Model (COM).[1][2] BITS is commonly used by updaters, messengers, and other applications preferred to operate in the background (using available idle bandwidth) without interrupting other networked applications. File transfer tasks are implemented as BITS jobs, which contain a queue of one or more file operations.</blockquote><p>Now that we know which log we want to analyze, we just need a tool to work with it.</p><p>While we <em>could</em> open the event log with the built-in Windows Event Viewer, let’s take the opportunity to go hands-on with another tool included on the LetsDefend VM: <a href="https://eventlogxp.com/"><strong>Event Log Explorer</strong></a>. It’s a powerful third-party event log analysis utility that makes sorting, filtering, and reviewing large volumes of events much easier.</p><p>Open <em>Event Log Explorer</em> and load: Microsoft-Windows-Bits-Client%4Operational.evtx</p><p>Since we already know when notion-setup.exe was executed from the previous question, we have a solid timeframe to work from. Let&#39;s focus on events occurring around that timestamp and see what stands out.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XJ75XDYwvR4F2SW1P5OyaA.png" /><figcaption><em>Event Log Explorer: Focusing on the BITS Client log during the range of the attack</em></figcaption></figure><p>Nice! Looking at the highlighted events, we can see evidence that notion-setup.exe created a BITS job shortly after execution. That&#39;s a strong indicator that the malware was attempting to retrieve additional content from an external source. The next event in the sequence reveals the URL associated with that job.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hCEu2IYDWNIhmJLvqVHepw.png" /><figcaption><em>Event Log Explorer: Identifying the URL used by the second stage</em></figcaption></figure><p>This gives us another valuable IOC and helps extend our attack timeline beyond the initial download and execution of notion-setup.exe. It also reinforces why correlating artifacts across multiple data sources is so important. The browser history told us <em>how</em> the first-stage payload arrived, Prefetch showed us <em>when</em> it last executed, and the BITS logs reveal what the malware attempted to do next.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n_WZr8LgIZLrIy2uNAf9_w.png" /></figure><h3>Question 8: During the investigation, you discover that the second stage of the malware writes data to a specific file on the system. What is the name of this file and its full path?</h3><p>Importantly, we learned from the <em>BITS Client logs</em> that the activity occurred at <strong>7:13:01 AM</strong>. That gives us another point on our timeline and a very specific timestamp to pivot from.</p><p>This time, we’ll need to parse a different artifact: the <strong>USN Journal</strong>. The USN Journal is part of the NTFS file system and maintains a record of file system activity, including file creation and modification events. That makes it a great source for correlating the BITS activity we identified with files that were actually written on disk.</p><p>To parse the USN Journal, we’ll use <strong>Eric Zimmerman’s MFTECmd</strong>, the command-line counterpart to <em>MFTExplorer</em> that we used earlier.</p><p>Open PowerShell and run the command below to generate a CSV file called, journal.csv.</p><pre>.\MFTECmd.exe -f &quot;C:\Users\LetsDefend\Desktop\ChallengeFile\C\$Extend\$J&quot; --csv &quot;C:\Users\LetsDefend\Desktop\&quot; --csvf journal.csv</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/1*gHwPcXWi6L___7gaAGHMow.png" /><figcaption><em>PowerShell: Using MFTECmd to parse the USN Journal</em></figcaption></figure><p>Once the command completes, open journal.csv in <strong>Timeline Explorer</strong>.</p><p>Now, we can focus on events occurring at the same time as the BITS activity identified in <strong>Question 7</strong>. By filtering around the <strong>7:13:01 AM</strong> timeframe, we can quickly narrow the results and look for files that may have been created or modified as part of the second-stage download process.</p><p>One of the temporary files aligns with a filename already identified from the BITS events, but another .tmp file stands out: BITEA82.tmp</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*qWJb0NSs6MadtAB-WMbQlQ.png" /><figcaption><em>Timeline Explorer: Identifying the second stage dropped file</em></figcaption></figure><p>That filename appears at the exact time we’re interested in, making it a strong candidate for the file written by the second stage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B06EAbAwnSke70waFpQgoA.png" /></figure><h3>Question 9: What is the name of the malware family?</h3><p>We’ve made it to the last question. Now let’s tie all of this together!</p><p>One step we skipped back in <strong>Question 5</strong>, but is generally a good habit during an investigation, is checking external threat intelligence sources for any suspicious binaries we identify. Up to this point, we’ve focused primarily on host-based artifacts to build our timeline and understand what happened on the system. Now it’s time to enrich those findings with external threat intelligence.</p><p>Let’s take the SHA256 hash we collected for notion-setup.exe and pivot over to <strong>VirusTotal</strong> to see what the broader security community already knows about the file:</p><pre>https://www.virustotal.com/gui/file/dfb76bcf5a3e29225559ebbdae8bdd24f69262492eca2f99f7a9525628006d88</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QG6K7uB3Ui9tMNGB3tlh6Q.png" /><figcaption><em>VirusTotal: Identifying the malware family from the collected hash</em></figcaption></figure><p>Reviewing the analysis results, we can see that multiple vendors associate the sample with the <a href="https://malpedia.caad.fkie.fraunhofer.de/details/win.bitsloth"><strong>BITSloth</strong></a> malware family.</p><p>This finding pairs nicely with what we’ve already uncovered during the investigation. Back in <strong>Question 7</strong>, we identified evidence of the malware creating a BITS job to attempt retrieval of additional content. That’s important because <strong>BITSloth</strong> is known for abusing the Windows <strong>Background Intelligent Transfer Service (BITS)</strong> for command-and-control and file transfer operations.</p><p>By correlating the behavioral evidence from our forensic artifacts with external threat intelligence, we can increase our confidence in the identification. Nice work, now let’s wrap up this investigation!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zuZabnldp9XnBbm2EZvaAw.png" /></figure><h3>Conclusion:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-Nd6B9n90YUKkfxlni_oyQ.png" /></figure><p>How fun was that! A big thank you to <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a> for another awesome challenge.</p><p>What I enjoyed most about this challenge was how effectively it demonstrated just how much information can be recovered from endpoint artifacts when you know where to look. Starting with a single suspicious executable, we were able to reconstruct an entire attack timeline by correlating data from the <strong>Master File Table (MFT)</strong>, <strong>Chrome History</strong>, <strong>Windows Prefetch</strong>, <strong>BITS Client Event Logs</strong>, the <strong>USN Journal</strong>, and external threat intelligence sources.</p><p>If there was one major takeaway from this investigation, it’s that endpoint artifacts always tell a story. Individually, each artifact only gave us a piece of the puzzle. The browser history helped us identify where the file came from. The MFT provided more download details. Prefetch showed execution activity. The BITS logs revealed a second-stage download attempt, and the USN Journal helped us connect that activity to files written on disk. Individually, those findings were interesting. Together, they allowed us to reconstruct the attack chain with a much higher degree of confidence.</p><p>One thing this challenge also reminded me of is how important regular practice is. While I’ve worked with all of these artifacts and tools before, I still found myself checking documentation and refreshing my memory on command syntax. For me, digital forensics is very much a “use it or lose it” skill. The more time that passes between investigations, the easier it is to forget a command-line switch, an artifact location, or a useful analysis technique. Challenges like this are a great way to keep those skills sharp and reinforce patterns that might prove invaluable during a real incident.</p><p>I chose this week’s challenge because I wanted another opportunity to practice timeline reconstruction and artifact correlation. It ended up being exactly the kind of investigation I enjoy most. Each answer naturally led to the next question, and every question added another piece to the story. By the end, we had progressed from a suspicious download to malware attribution, all through endpoint artifact analysis.</p><p>Thanks for working through this investigation with me. Hopefully, this walkthrough helps you get past a stumbling block or gives you a few ideas you can apply in your own analysis.</p><p>Remember, cybersecurity is a team sport, and we’re in this together! Until next week’s challenge — stay curious and be safe out there.</p><h3>Tools &amp; References:</h3><p><strong>Challenge Link:</strong> <a href="https://app.letsdefend.io/challenge/hidden-backdoor">https://app.letsdefend.io/challenge/hidden-backdoor</a></p><p><strong>Eric Zimmerman’s Tools:</strong> <a href="https://ericzimmerman.github.io/">https://ericzimmerman.github.io/</a></p><p><strong>DB Browser for SQLite:</strong> <a href="https://sqlitebrowser.org/">https://sqlitebrowser.org/</a></p><p><strong>Foxton Forensics — Browser History Examiner — User Guide:</strong> <a href="https://www.foxtonforensics.com/browser-history-examiner/chrome-history-location">https://www.foxtonforensics.com/browser-history-examiner/chrome-history-location</a></p><p><strong>MITRE ATT&amp;CK — Drive-by Compromise (T1189):</strong> <a href="https://attack.mitre.org/techniques/T1189/">https://attack.mitre.org/techniques/T1105/</a></p><p><strong>Magnet Forensics — “Forensic Analysis of Prefetch files in Windows”:</strong> <a href="https://www.magnetforensics.com/blog/forensic-analysis-of-prefetch-files-in-windows/">https://www.magnetforensics.com/blog/forensic-analysis-of-prefetch-files-in-windows/</a></p><p><strong>Microsoft Learn — Background Intelligent Transfer Service:</strong> <a href="https://learn.microsoft.com/en-us/windows/win32/bits/background-intelligent-transfer-service-portal">https://learn.microsoft.com/en-us/windows/win32/bits/background-intelligent-transfer-service-portal</a></p><p><strong>MITRE ATT&amp;CK — BITS Jobs (T1197):</strong> <a href="https://attack.mitre.org/techniques/T1197/">https://attack.mitre.org/techniques/T1197/</a></p><p><strong>Event Log Explorer:</strong> <a href="https://eventlogxp.com/">https://eventlogxp.com/</a></p><p><strong>VirusTotal — notion-setup.exe sample:</strong> <a href="https://www.virustotal.com/gui/file/dfb76bcf5a3e29225559ebbdae8bdd24f69262492eca2f99f7a9525628006d88">https://www.virustotal.com/gui/file/dfb76bcf5a3e29225559ebbdae8bdd24f69262492eca2f99f7a9525628006d88</a></p><p><strong>Malpedia — BITSloth:</strong> <a href="https://malpedia.caad.fkie.fraunhofer.de/details/win.bitsloth">https://malpedia.caad.fkie.fraunhofer.de/details/win.bitsloth</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3fd4338ddc47" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CyberDefenders: BRabbit Lab Walkthrough]]></title>
            <link>https://stumblesec.medium.com/cyberdefenders-brabbit-lab-walkthrough-249791454b31?source=rss-b1b82253e27c------2</link>
            <guid isPermaLink="false">https://medium.com/p/249791454b31</guid>
            <category><![CDATA[cyberdefenders-writeup]]></category>
            <category><![CDATA[cyberdefender]]></category>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[blue-team]]></category>
            <dc:creator><![CDATA[Drew Arpino]]></dc:creator>
            <pubDate>Sun, 03 May 2026 23:01:02 GMT</pubDate>
            <atom:updated>2026-05-03T23:01:02.161Z</atom:updated>
            <content:encoded><![CDATA[<h4>BadRabbit Ransomware Analysis: Correlating Threat Intelligence, Sandbox Reports, and ATT&amp;CK Mapping</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/399/1*NuEeEwLce6BZzLGoiU8zbw.png" /><figcaption>Image Credit: <a href="https://cyberdefenders.org/blueteam-ctf-challenges/brabbit/">https://cyberdefenders.org/blueteam-ctf-challenges/brabbit/</a></figcaption></figure><h3>Introduction:</h3><p>Welcome to my weekly walkthrough! If you’ve stumbled across this post while looking for a detailed guide to the <a href="https://cyberdefenders.org/blueteam-ctf-challenges/brabbit/"><strong>BRabbit</strong></a><strong> </strong>blue team lab from <a href="https://cyberdefenders.org/"><strong>CyberDefenders</strong></a>, you’re in the right place. This one drops us straight into incident response mode, where a single convincing phishing email turns into a full‑blown ransomware outbreak.</p><p>In this scenario, we’re assisting a fictional organization that fell victim to ransomware after an employee opened what appeared to be a routine email from their boss. Familiar logo, familiar email address, and a seemingly harmless attachment. After opening it, the system is compromised, sensitive files are encrypted, and the victim can no longer boot. Yikes.</p><p>On paper, the mission is simple. Identify the malware, understand its behavior, learn how it persists, how it communicates, how it damages the system, and where it might have come from. In practice, it’s a lot messier. The twist here is that we’re not always taking the fastest route to the answer. Instead, I intentionally stayed within the constraints of threat intelligence platforms and public sandbox reports.</p><p>That means leaning heavily on tools like <strong>CyberChef</strong>, <strong>VirusTotal</strong>, <strong>Recorded Future Tria.ge</strong>, <strong>Any.Run</strong>, and <strong>Malpedia</strong>. This isn’t always the most efficient path, but it’s a very realistic one. In real investigations, you’re often correlating CTI, validating what others have already observed, and deciding how much confidence to place in the evidence available, rather than reverse engineering everything from scratch.</p><p>As we work through the questions, we’ll bounce between email analysis, file metadata, behavioral reports, ATT&amp;CK mappings, and attribution, sometimes revisiting the same artifacts from different angles. That repetition is intentional. The goal isn’t just to answer the questions, but to introduce different tools, show how they complement each other, and model an investigation workflow that values context over speed.</p><p>And hey, if you find this walkthrough helpful, whether it helps you level up your memory forensics skills, gets you over a stumbling block, or just serves as a useful reference, consider following me for more weekly deep dives.</p><p>Thanks for reading and going on this investigation with me. Let’s go!</p><h3>Challenge Scenario:</h3><blockquote>You are an investigator assigned to assist Drumbo, a company that recently fell victim to a ransomware attack. The attack began when an employee received an email that appeared to be from the boss. It featured the company’s logo and a familiar email address. Believing the email was legitimate, the employee opened the attachment, which compromised the system and deployed ransomware, encrypting sensitive files. Your task is to investigate and analyze the artifacts to uncover information about the attacker.</blockquote><h3>Setup the Analysis Environment &amp; Extract the Challenge File:</h3><p>Safety first! When working with lab/challenge files from <strong>CyberDefenders</strong> <em>(or any educational lab/challenge/range), </em>it’s important to be responsible and stay safe by interacting with potentially malicious files in a dedicated, isolated virtual machine environment. For this challenge I’m using <a href="https://remnux.org/"><strong>REMnux</strong></a><em>,</em> a specialized <em>Linux</em> distribution for malware analysis.</p><p>To keep this write-up focused, I’m going to skip step-by-step setup directions of <em>REMnux, </em>but if<em> </em>you’d like to set up your own environment, please follow the guide provided by <em>REMnux</em> directly. For reference, I used the virtual appliance method:</p><p><a href="https://docs.remnux.org/install-distro/get-virtual-appliance?source=post_page-----d2311959d5f3--------------------------------">Get the Virtual Appliance | REMnux Documentation</a></p><p>Once you have a safe virtual environment created, updated, isolated, and snapshotted, we can extract the challenge file and start the investigation!</p><h3>Question 1: The phishing email used to deliver the malicious attachment showed several indicators of a potential social engineering attempt. Recognizing these indicators can help identify similar threats in the future.<br>What is the suspicious email address that sent the attachment?</h3><p>Let’s get to it. Our first step is to extract the attachment named Urget Contract Action.zip, which leaves us with our primary artifact, Urget Contract Action.eml.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/890/1*XmSnfhAJNIAkbhdsxMlyNw.png" /><figcaption>Overview of the Challenge File</figcaption></figure><p>Before opening anything further, you might notice a warning.txt file included with the challenge. <strong>This one is important.</strong> It explains that we’ll be interacting with real malware samples, so if you skipped the <em>“Setup the Analysis Environment”</em> section, take a moment to pause here and make sure you’re working in a safe, isolated environment and understand the warning issued by the challenge.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/644/1*QrU4XYKP6pRjquGR7JQ1wg.png" /><figcaption>Heed the warning</figcaption></figure><p>The first thing we need to do is a basic email header analysis. There are a lot of ways to approach this using dedicated mailbox or header analysis tools, but for this writeup, we’ll take a slightly different route and lean on <a href="https://gchq.github.io/CyberChef/"><strong>CyberChef</strong></a>. That gives us the flexibility to handle both header analysis and file extraction in one place.</p><p>You can use either the online or offline version of <em>CyberChef</em>. With either option, the approach is the same. Drop Urget Contract Action.eml directly into the input window.</p><p>To answer <strong>Question 1</strong> and identify indicators of social engineering, we can apply the <em>“Extract email addresses”</em> operation to our recipe. This quickly pulls out all email addresses present in the message headers and body, saving us from manually digging through raw header text.</p><p>And almost immediately, something stands out.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XAkunSshDMzCpWB-qghf5g.png" /><figcaption>CyberChef: Identifying the suspicious sender address</figcaption></figure><p>Instead of coming from Drumbo’s legitimate domain, the sender address uses a fun typo. The domain reads <em>“drurnbo”</em> instead of Drumbo. This kind of typo squatting is a common social engineering tactic, relying on how easily “rn” can visually blend in to look like “m” at a glance. The attacker also leveraged the CEO’s name, adding urgency and legitimacy to the message and increasing the likelihood that the recipient would trust the attachment and open it…which worked!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/792/1*0qdNDvYw8FQM0LvjfsM6hA.png" /></figure><h3>Question 2: The ransomware was identified as part of a known malware family. Determining its family name can provide critical insights into its behavior and remediation strategies.<br>What is the family name of the ransomware identified during the investigation?</h3><p>Next, we need to extract the attachment from the phishing email so we can begin some initial analysis. While it would be much easier to simply open the .eml file in an email client, we can also extract the attachment directly using <strong>CyberChef</strong> and keep everything inside our current workflow.</p><p>To do this, scroll down and identify the section of the email labeled:</p><pre>Content-Disposition: attachment; filename=&quot;Urgent Contract Action.pdf.exe&quot;</pre><p>Just below that header, you’ll see a long Base64-encoded blob. That blob is the attachment itself, named Urgent Contract Action.pdf.exe. The filename alone is already doing some social engineering. The double extension strongly suggests an executable file attempting to masquerade as a harmless PDF.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QwwKxZTBRN_27i5lhEmCuw.png" /><figcaption>CyberChef: Identifying the attachment as Base64</figcaption></figure><p>Keep in mind that the blob is much longer than what’s visible in the screenshot. Make sure to copy the entire Base64 string and then paste it into a new input window within <em>CyberChef</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Iaepnu2OVfoXSi0Ao9jY7g.png" /><figcaption>CyberChef: Decoding and extracting the attachment</figcaption></figure><p>Once pasted in, add the <em>“From Base64”</em> and <em>“Extract Files”</em> operations to the recipe. This allows us to reconstruct the original attachment directly from the email content. In this challenge, the extracted file appears as extracted_at_0x0.exe. Go ahead and save that file.</p><p>The next step is to grab the SHA-256 hash of the extracted executable. This hash is critical because it gives us a fingerprint that can be used to search threat intelligence platforms for known malware samples.</p><p>On a Linux system, we can generate the hash using the following command:</p><pre>sha256sum extracted_at_0x0.exe</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F8n-ofRKiqghfvHdmBxkAg.png" /><figcaption>Calculating the SHA256 hash of the ransomware binary</figcaption></figure><p>Which produces:</p><pre>630325cac09ac3fab908f903e3b00d0dadd5fdaa0875ed8496fcbb97a558d0da</pre><p>With the file hash in hand, it’s time to pivot into external threat intelligence. Copy the hash and submit it to <a href="https://www.virustotal.com/"><strong>VirusTotal</strong></a>. This sample has been observed before and is flagged as malicious by multiple vendors.</p><p>What we care about most for <strong>Question 2</strong>, though, is the malware family classification: <strong>BadRabbit</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LuoKhGLanImPgnrdSBP7qw.png" /><figcaption>VirusTotal: Identifying the ransomware family</figcaption></figure><p>Now that we’ve confirmed the malware family, we can start digging into its behavior and better understand what we’re dealing with.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/807/1*_d3zyMRU4fQKy_TGyYSIjg.png" /></figure><h3>Question 3: Upon execution, the ransomware dropped a file onto the compromised system to initiate its payload. Identifying this file is essential for understanding its infection process.<br>What is the name of the first file dropped by the ransomware?</h3><p>To begin answering <strong>Question 3</strong>, there’s a good lesson worth calling out. When gathering cyber threat intelligence, you often need to consult multiple sources to paint a complete picture. No single platform tells the whole story. That’s exactly what we’re going to do next.</p><p>Let’s take a brief detour away from <em>VirusTotal</em> and highlight another excellent malware analysis and threat intelligence resource: <a href="https://tria.ge/"><strong>Recorded Future Tria.ge</strong></a>. While much of this behavioral detail is technically available in <em>VirusTotal</em>, it’s easier to visualize and explain using <em>Tria.ge’s</em> sandbox reporting.</p><p>Navigate to the <em>Reports</em> tab and submit the <strong>BadRabbit</strong> hash we collected earlier.</p><p>Heads-up, you’ll likely see several results. Go ahead and select a report that matches the same filename as our extracted sample. I’ve linked the exact report I used below to keep things consistent.</p><p><a href="https://tria.ge/251107-yd3m1ahm6v/behavioral1">badrabbit | 630325cac09ac3fab908f903e3b00d0dadd5fdaa0875ed8496fcbb97a558d0da | Triage</a></p><p>Once inside the report, click <strong>Tasks</strong> and then select <em>behavioral1</em>. From there, scroll down to the <em>Processes</em> section.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6cw_yMhnzV6doUM96FEp3g.png" /><figcaption>Tria.ge: Behavioral report &gt; Processes snippet</figcaption></figure><p>This is where things get interesting. The behavioral analysis shows that shortly after execution, the ransomware binary launches rundll32.exe. That process is then used to drop a file named infpub.dat onto the system.</p><p>This answers <strong>Question 3</strong> for us. The first file dropped by the ransomware during execution is infpub.dat. More importantly, this gives us our next breadcrumb.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/803/1*o7Px9U7d7ToRxyPp78iRSQ.png" /></figure><h3>Question 4: Inside the dropped file, the malware contained hardcoded artifacts, including usernames and passwords that could provide clues about its origins or configuration.<br>What is the only person’s username found within the dropped file?</h3><p>Now that we’ve confirmed the name of the dropped file, let’s jump back over to <em>VirusTotal</em> and look at the <em>dropped files</em> view for the original <em>BadRabbit</em> hash we identified in <strong>Question 2</strong>. The goal here is to change perspective. By pivoting back to <em>VirusTotal</em>, we can dig deeper into infpub.dat using threat intelligence that complements what we already saw in <em>Recorded Future Tria.ge</em>.</p><p>Navigate to the <strong>Relations</strong> tab and then select <em>Dropped Files</em>. This view is a bit less structured than what we saw in <em>Tria.ge</em>, but with a little digging, we can locate infpub.dat and click into it to start answering <strong>Question 4</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/834/1*RPg40r4JC3Vs9qJZMUHabQ.png" /><figcaption>VirusTotal: Identifying the hash of infpub.dat</figcaption></figure><p><a href="https://www.virustotal.com/gui/file/579fd8a0385482fb4c789561a30b09f25671e86422f40ef5cca2036b28f99648">VirusTotal</a></p><pre>579fd8a0385482fb4c789561a30b09f25671e86422f40ef5cca2036b28f99648</pre><p>Once on the <em>VirusTotal</em> page for infpub.dat, we get several analysis options. Before jumping straight into our own static analysis, it’s worth seeing what the community and external researchers have already uncovered.</p><p>Head over to the <em>Community</em> tab. This section often contains links to malware write-ups, analyst notes, or external research that can save us time and help validate our assumptions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/742/1*cIOd32ihEQoQbC_FMuhHfA.png" /><figcaption>VirusTotal: Finding external reporting through the community comments</figcaption></figure><p>In this case, there’s a particularly helpful link to an analysis published on ESET’s <em>WeLiveSecurity</em> blog. The report provides key insight into <em>BadRabbit’s</em> internal artifacts and behavior, including the use of embedded credentials.</p><p><a href="https://www.welivesecurity.com/2017/10/24/bad-rabbit-not-petya-back/">Bad Rabbit: Not-Petya is back with improved ransomware</a></p><blockquote>“Mimikatz is launched on the compromised computer to harvest credentials. <strong>A hardcoded list of usernames and passwords is also present</strong>.”</blockquote><p>Reviewing the reported credential data, we see several system or service-related account names. However, one username stands out. Unlike generic entries such as guest, administrator, or service-style accounts, there is a single, clearly human username embedded in the file: alex.</p><p>That makes alex the only person’s username found within the dropped file, and the answer to <strong>Question 4</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/773/1*01j6jFUfHUZTw8er762bxw.png" /><figcaption>Identifying the username through the ESET report</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/808/1*Wivvo9WGUqSQYHtZdU8G8A.png" /></figure><h3>Question 5: After execution, the ransomware communicated with a C2 server. Recognizing its communication techniques can assist in mitigation.<br>What MITRE ATT&amp;CK sub-technique describes the ransomware’s use of web protocols for sending and receiving data?</h3><p>After execution, the ransomware needs a way to communicate with its command-and-control infrastructure. Understanding how it sends and receives data is important, because these techniques often inform both detection and mitigation strategies.</p><p>Since we already have the hash for infpub.dat from <strong>Question 4</strong>, we can pivot to another useful tool to help with this analysis: <a href="https://app.any.run/"><strong>Any.Run</strong></a>. This interactive sandbox is especially helpful for visualizing network behavior, rather than stumbling through static reports.</p><p>Navigate to the <em>Any.Run</em> reports section and search for the hash associated with the dropped file. From the available results, select one of the public analysis runs. For example, the report below matches the same sample and provides clear network data:</p><p><a href="https://app.any.run/tasks/b83b65e0-5717-4e98-9763-32cd281ff023">Analysis infpub.exe (MD5: 1D724F95C61F1055F0D02C2154BBCCD3) Malicious activity - Interactive analysis ANY.RUN</a></p><p>Once inside the report, turn your attention to the <em>Network Threats</em> tab in the bottom pane. Scroll through the color‑coded rows until you reach entries marked as <em>“potentially bad traffic.”</em></p><p>This is where things click. The report highlights <em>WebDAV</em> traffic associated with infpub.dat, showing it being used to send and receive data over the network. WebDAV blends into normal-looking web traffic, which makes it attractive for malware trying to avoid detection.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zw7HPsG-__yFN2ZdfiBdRw.png" /><figcaption>Any.Run: Identifying potentially malicious WebDAV traffic</figcaption></figure><p>This behavior maps to the MITRE ATT&amp;CK sub‑technique <strong>Application Layer Protocol: Web Protocols</strong> (<em>T1071.001</em>). This technique describes adversaries communicating over common web‑based application protocols in order to blend in with legitimate network activity.</p><p><a href="https://attack.mitre.org/techniques/T1071/001/">Application Layer Protocol: Web Protocols</a></p><p>That gives us the answer to <strong>Question 5</strong>. The ransomware’s command‑and‑control traffic is best described by <strong>T1071.001: Application Layer Protocol: Web Protocols</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*iUs77oZGMkLBpP1R5JjisA.png" /></figure><h3>Question 6: Persistence mechanisms are a hallmark of sophisticated ransomware. Identifying how persistence was achieved can aid in recovery and prevention of reinfection.<br>What is the MITRE ATT&amp;CK Sub-Technique ID associated with the ransomware’s persistence technique?</h3><p>Moving right along, we now need to determine how the ransomware maintains persistence on the compromised system. Continuing our pattern of pivoting between tools, let’s revisit the <em>Recorded Future Tria.ge</em> report for the original <em>BadRabbit</em> sample and take another look at the process tree.</p><p>After execution and the dropping of infpub.dat, we see a familiar sequence unfold. The malware spawns cmd.exe, which in turn launches schtasks.exe. This is the built‑in Windows command‑line utility used to create or modify scheduled tasks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pwY-OtotV1hxdedyUBZaQg.png" /><figcaption>Tria.ge: highlighting scheduled task creation for persistence</figcaption></figure><p>That sequence is a strong indicator of a classic persistence mechanism. By creating a scheduled task, the malware ensures it can re‑execute automatically, often on a timer or at system startup, without requiring user interaction.</p><p>This behavior is documented in MITRE ATT&amp;CK as the sub‑technique <strong>Scheduled Task/Job: Scheduled Task</strong> (<em>T1053.005</em>). With that, we’ve answered <strong>Question 6</strong>.</p><p><a href="https://attack.mitre.org/techniques/T1053/005/">Scheduled Task/Job: Scheduled Task</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*n8GU1ihPibxgVIR4wx1Gqg.png" /></figure><h3>Question 7: As part of its infection chain, the ransomware created specific tasks to ensure its continued operation. Recognizing these tasks is crucial for system restoration. What are the names of the tasks created by the ransomware during execution?</h3><p>Now that we’ve confirmed that <strong>T1053.005</strong> (<em>Scheduled Task</em>) was used as the persistence mechanism, the next step is to determine the names of the scheduled tasks created by the ransomware. This detail matters, because knowing exactly what to look for can significantly speed up system restoration and cleanup.</p><p>Luckily for us, this information is available in the same <strong>Recorded Future Tria.ge</strong> process tree we used back in <strong>Question 6</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OTtu64gIg6d4RRtQUiZedQ.png" /><figcaption>Tria.ge: Identifying the names of the scheduled tasks created by the ransomware</figcaption></figure><p>Focusing on the process command‑line arguments, we can clearly see both task creation and deletion events involving schtasks.exe. The key field to look for is the /TN argument, which specifies the task name being created or removed.</p><p>Looking closely at these entries, two task names jump out. During execution, <em>BadRabbit</em> creates scheduled tasks named Rhaegal and Drogon.</p><p>For anyone familiar with <em>Game of Thrones</em>, these names might ring a bell. While the references are fun, they also make these tasks easier to spot during incident response, assuming you know what you’re looking for.</p><p>With that, we’ve answered <strong>Question 7</strong>. The ransomware creates scheduled tasks named Rhaegal and Drogon to maintain persistence.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/808/1*n2uq_A3xAd0NhaZ_gf0fLw.png" /></figure><h3>Question 8: the malicious binary dispci.exe displayed a <strong>suspicious message</strong> upon execution, urging users to disable their defenses. This tactic aimed to evade detection and enable the ransomware&#39;s full execution. What suspicious message was displayed in the Console upon executing this binary?</h3><p>The next step in our analysis is to identify the console message displayed after executing another related malicious binary, dispci.exe. We see this file referenced in the <strong>Recorded Future Tria.ge</strong> report, but at this stage, we don’t yet have much detail on what it actually does.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H8_3bkUmMf52EhaNCle0aQ.png" /><figcaption>Tria.ge: Identifying the process execution of dispci.exe</figcaption></figure><p>To gather more context, let’s pivot back to <strong>VirusTotal</strong> and look at the original <strong>BadRabbit</strong> sample. Under <strong>Relations</strong> → <em>Dropped Files</em>, we can locate dispci.exe and identify its file hash:</p><pre>0f815e2944f12b847e1165517daaab6be67ff4c1daee73b09e8fb3733b974c9f</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/647/1*MBcM4dmfjIqvxiqJbP3FNg.png" /><figcaption>VirusTotal: Identifying the file hash of dispci.exe</figcaption></figure><p>With the hash in hand, we have a few options. We could download the binary from a malware repository for hands‑on static analysis, move over to an interactive sandbox, or continue leaning on existing threat intelligence reporting.</p><p>For this writeup, we’ll stick with <em>VirusTotal</em> and see what’s already available.</p><p>Navigate to the <em>Behaviors</em> tab for dispci.exe. From there, select the <em>Zenbox</em> full sandbox report. One of the more useful features of this report is that it captures screenshots of the malware during execution, which can reveal user‑facing behavior we might otherwise miss.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8NSpqOyM97BweeOm1zrbow.png" /><figcaption>VirusTotal: Opening the Zenbox sandbox report</figcaption></figure><p>To illustrate this, select the Zenbox report and scroll down to the <em>Screenshots</em> section at the bottom of the report.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VxkYaAS1TgcOuYDAI61cfg.png" /><figcaption>Zenbox: Reviewing execution screenshots</figcaption></figure><p>This gives us exactly what we need to answer <strong>Question 8</strong>. Upon execution, dispci.exe displays the following message in the console:</p><p><em>“Disable your anti‑virus and anti‑malware programs.”</em></p><p>This prompt is another attempt at defense evasion through social engineering. By urging the victim to weaken or disable their security controls, the malware improves its chances of executing fully without being hindered by security tools.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*OtKs19Tf706MdE3kyKTceg.png" /></figure><h3>Question 9: To modify the Master Boot Record (MBR) and encrypt the victim’s hard drive, the ransomware utilized a specific driver. Recognizing this driver is essential for understanding the encryption mechanism.<br>What is the name of the driver used to encrypt the hard drive and modify the MBR?</h3><p>To answer <strong>Question 9</strong>, we need to identify the specific driver used by the ransomware to encrypt the victim’s hard drive and modify the Master Boot Record. This driver is a critical part of the encryption chain, because it explains <em>how</em> the ransomware is able to operate at a low level on the system.</p><p>To get there, exit the <em>Behaviors</em> tab and navigate to the <em>Details</em> page for dispci.exe in <em>VirusTotal</em>. This view exposes metadata about the binary.</p><p>Under <em>Signature Info</em> → <em>File Version Information</em>, we see that dispci.exe is associated with <a href="https://diskcryptor.org/"><strong>DiskCryptor</strong></a>. This attribution is reinforced by the metadata copyright information embedded in the binary, which points back to the <em>DiskCryptor</em> project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qhOYOjj1fQIKgTubkjvSgg.png" /><figcaption>VirusTotal: Looking for driver clues on the behaviors tab</figcaption></figure><p>According to the project description, <em>“DiskCryptor is an open encryption solution that offers encryption of all disk partitions, including the system partition.”</em></p><p>That tells us exactly what we need for <strong>Question 9</strong>. The ransomware leverages the <em>DiskCryptor</em> driver to perform full disk encryption and modify the Master Boot Record. With that, we can confidently answer <strong>Question 9</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*S9KNVICV6G3o5M4OSquBkg.png" /></figure><h3>Question 10: Attribution is key to understanding the threat landscape. The ransomware was tied to a known attack group through its tactics, techniques, and procedures (TTPs).<br>What is the name of the threat actor responsible for this ransomware campaign?</h3><p>We’re closing in on the end of our analysis, and now it’s time to look beyond tools and techniques and focus on attribution. The question here isn’t about the nitty-gritty details of how<em> </em>the ransomware works anymore, but who is historically tied to this campaign based on shared tactics, techniques, and procedures.</p><p>To do that, let’s pivot away from sandboxing platforms and threat execution data and move into a dedicated malware knowledge base: <a href="https://malpedia.caad.fkie.fraunhofer.de/"><strong>Malpedia</strong></a>.</p><p><em>Malpedia</em> is an excellent resource for tying malware families to known threat actors and for surfacing a ton of great external reporting in one place. From the home page, search for <em>BadRabbit</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*36D0HrWk2M7I-aaC8ojBIQ.png" /><figcaption>Malpedia: Identifying actors associated with Bad Rabbit</figcaption></figure><p><a href="https://malpedia.caad.fkie.fraunhofer.de/details/win.eternal_petya">EternalPetya (Malware Family)</a></p><p>Right away, we can locate the <em>BadRabbit</em> entry, where it’s described as a ransomware family closely related to <em>Petya</em> and <em>NotPetya</em>. This aligns with what we’ve already observed throughout the challenge, especially the disk‑level encryption behavior and file hashes.</p><p>Scrolling further, <em>Malpedia </em>lists multiple attribution assessments sourced from external intelligence vendors. One threat actor stands out as the most consistently associated with <em>BadRabbit</em>.</p><p><a href="https://attack.mitre.org/groups/G0034/">Sandworm Team</a></p><p><em>Sandworm</em> is a well‑documented threat group linked to destructive campaigns targeting critical infrastructure and large organizations, and it’s commonly associated with <em>NotPetya</em> and related ransomware operations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/808/1*TrSRtFf56o2FHx385SIagg.png" /></figure><h3>Question 11: The ransomware rendered the system unbootable by corrupting critical system components. Identifying the technique used provides insight into its destructive capabilities.<br>What is the MITRE ATT&amp;CK ID for the technique used to corrupt the system firmware and prevent booting?</h3><p>Finally, we’ve made it to the last question. Our closing task is to identify the MITRE ATT&amp;CK technique used by the ransomware to render the victim system unbootable.</p><p>From <strong>Question 9</strong>, we know that <em>DiskCryptor</em> was used to encrypt the hard drive and modify the Master Boot Record. From the question, we can infer that that outcome is that on top of the data being encrypted, the system is left unable to boot normally.</p><p>Rather than speculate, let’s check out the <strong>MITRE ATT&amp;CK</strong> software page for <em>BadRabbit</em> to confirm which <em>Impact</em> technique MITRE themselves associate with this behavior.</p><p><a href="https://attack.mitre.org/software/S0606/">Bad Rabbit</a></p><p>Looking at the listed techniques, one maps directly to the effect described in the question. <a href="https://attack.mitre.org/techniques/T1495/"><strong>Firmware Corruption</strong></a> (<em>T1495</em>) is documented as a technique used to damage critical boot components in order to prevent a system from starting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*waFtWkdxxcQTGnN38Syw6A.png" /><figcaption>MITRE ATT&amp;CK: Identifying Bad Rabbit destructive impact techniques</figcaption></figure><p>MITRE explicitly lists <strong>T1495</strong> as an <em>Impact</em> technique associated with <em>BadRabbit</em>, reflecting the ransomware’s ability to overwrite boot‑related disk structures and leave systems unbootable. That gives us our final answer.</p><p>With that, we’ve completed the analysis, from initial infection through destructive impact and now we can wrap up our investigation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/805/1*Xn-Px4AUW7em9BF6Dlo8vQ.png" /></figure><h3>Conclusion:</h3><p>So, how fun was that? A big thank you to <a href="https://cyberdefenders.org/"><strong>CyberDefenders</strong></a> for another awesome challenge.</p><p>This lab ended up being a good reminder that there’s rarely a single tool, report, or source of truth that magically answers every question. As much as we’d all like a one‑stop solution for threat intelligence, the reality is that investigations often turn into a bit of a research slog. Not because the answers are impossible to find, but because they live across multiple platforms, formats, and perspectives.</p><p>I’ll be honest, I expected this challenge to go a bit faster. Instead, it slowed me down in a good way. It forced me to stop, pivot between tools, reframe questions, and validate instead of jumping straight to conclusions. It’s a realistic (if frustrating) experience, mirroring how real investigations go, especially when you’re operating under constraints and relying on publicly available intelligence.</p><p>From my perspective, the real value here comes from tying different sources together and being exposed to different tools. Interactive sandboxes like <strong>Recorded Future Tria.ge</strong> and <strong>Any.Run</strong> gave us a safe way to observe behavior as it unfolded. Static and reports in <strong>VirusTotal</strong> helped ground and validate those observations with hashes, relationships, and community context. External reporting and curated knowledge bases like <strong>Malpedia</strong> added context and attribution that raw analysis alone didn’t show. None of these tools were sufficient on their own, but together they painted a much clearer picture.</p><p>Thanks for your support and partnering on this investigation. If you found this walkthrough helpful — please give it a clap and consider following me! Your feedback is invaluable, and it pumps me up to support your security journey. Remember, cybersecurity is a team sport, and we’re in this together!</p><p>Until next week’s challenge — stay curious and be safe out there!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/1*lAzW-XArQrYfSbfHFTC0Ww.png" /></figure><h3>Tools &amp; References:</h3><p><strong>Challenge Link: </strong><a href="https://cyberdefenders.org/blueteam-ctf-challenges/brabbit/">https://cyberdefenders.org/blueteam-ctf-challenges/brabbit/</a></p><p><strong>REMnux:</strong> <a href="https://remnux.org/">https://remnux.org/</a></p><p><strong>CyberChef: </strong><a href="https://gchq.github.io/CyberChef/">https://gchq.github.io/CyberChef/</a></p><p><strong>VirusTotal:</strong> <a href="https://www.virustotal.com/">https://www.virustotal.com/</a></p><p><strong>VirusTotal (Urget Contract Action.pdf.exe) — </strong><a href="https://www.virustotal.com/gui/file/630325cac09ac3fab908f903e3b00d0dadd5fdaa0875ed8496fcbb97a558d0da">https://www.virustotal.com/gui/file/630325cac09ac3fab908f903e3b00d0dadd5fdaa0875ed8496fcbb97a558d0da</a></p><p><strong>Recorded Future Tria.ge (Urgent Contract Action.pdf.exe): </strong><a href="https://tria.ge/251107-yd3m1ahm6v/behavioral1">https://tria.ge/251107-yd3m1ahm6v/behavioral1</a></p><p><strong>VirusTotal (infpub.dat) — </strong><a href="https://www.virustotal.com/gui/file/579fd8a0385482fb4c789561a30b09f25671e86422f40ef5cca2036b28f99648">https://www.virustotal.com/gui/file/579fd8a0385482fb4c789561a30b09f25671e86422f40ef5cca2036b28f99648</a></p><p><strong>VirusTotal (dispci.exe) — </strong><a href="https://www.virustotal.com/gui/file/0f815e2944f12b847e1165517daaab6be67ff4c1daee73b09e8fb3733b974c9f">https://www.virustotal.com/gui/file/0f815e2944f12b847e1165517daaab6be67ff4c1daee73b09e8fb3733b974c9f</a></p><p><strong>Welivesecurity by Eset — “<em>Bad Rabbit: Not-Petya is back with improved ransomware</em>”: </strong><a href="https://www.welivesecurity.com/2017/10/24/bad-rabbit-not-petya-back/">https://www.welivesecurity.com/2017/10/24/bad-rabbit-not-petya-back/</a></p><p><strong>Any.Run (infpub.dat): </strong><a href="https://app.any.run/tasks/b83b65e0-5717-4e98-9763-32cd281ff023">https://app.any.run/tasks/b83b65e0-5717-4e98-9763-32cd281ff023</a></p><p><strong>Disk Cryptor: </strong><a href="https://diskcryptor.org/">https://diskcryptor.org/</a></p><p><strong>Malpedia — EternalPetya:</strong> <a href="https://malpedia.caad.fkie.fraunhofer.de/details/win.eternal_petya">https://malpedia.caad.fkie.fraunhofer.de/details/win.eternal_petya</a></p><p><strong>MITRE ATT&amp;CK — Groups — Sandworm Team (G0034):</strong> <a href="https://attack.mitre.org/groups/G0034/">https://attack.mitre.org/groups/G0034/</a></p><p><strong>MITRE ATT&amp;CK — Software — Bad Rabbit (S0606):</strong> <a href="https://attack.mitre.org/software/S0606/">https://attack.mitre.org/software/S0606/</a></p><p><strong>MITRE ATT&amp;CK — Firmware Corruption (T1495):</strong> <a href="https://attack.mitre.org/techniques/T1495/">https://attack.mitre.org/techniques/T1495/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=249791454b31" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LetsDefend: Obfuscated JavaScript Challenge Walkthrough]]></title>
            <link>https://stumblesec.medium.com/letsdefend-obfuscated-javascript-challenge-walkthrough-16fbbbca43ac?source=rss-b1b82253e27c------2</link>
            <guid isPermaLink="false">https://medium.com/p/16fbbbca43ac</guid>
            <category><![CDATA[letsdefend-writeup]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[lets-defend]]></category>
            <category><![CDATA[letsdefendio]]></category>
            <category><![CDATA[blue-team]]></category>
            <dc:creator><![CDATA[Drew Arpino]]></dc:creator>
            <pubDate>Sun, 12 Apr 2026 23:01:01 GMT</pubDate>
            <atom:updated>2026-04-12T23:01:01.676Z</atom:updated>
            <content:encoded><![CDATA[<h4>Malicious JavaScript Analysis: Identifying Obfuscation, WMI Usage, and Network-Based Payload Staging</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/0*NK4OfbpcHPXUmPb4.png" /><figcaption>Image Credit: <a href="https://app.letsdefend.io/challenge/obfuscated-javascript">https://app.letsdefend.io/challenge/obfuscated-javascript</a></figcaption></figure><h3>Introduction:</h3><p>Welcome to my weekly walkthrough! If you’ve stumbled across this blog looking for a detailed guide to the <a href="https://app.letsdefend.io/challenge/obfuscated-javascript"><strong>Obfuscated JavaScript</strong></a> blue team challenge from <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a>, you’re in the right place. This one drops us right into the world of script-based malware where attackers lean on obfuscation to complicate analysis.</p><p>In this challenge, we’re stepping into the role of a cybersecurity analyst responding to reports of strange behavior across internal web applications. What initially looks like routine troubleshooting quickly turns into something more concerning when we discover that several critical JavaScript files have been aggressively obfuscated.</p><p>Our mission is fairly straightforward but tricky in practice. We need to analyze the obfuscated script, identify the techniques used to hide its behavior, and determine whether it contains malicious code. With no automated tooling and no internet access, we’re forced to rely on careful inspection, pattern matching, and a methodical approach using nothing more than the terminal and a text editor. It’s not the sexiest approach, but it works.</p><p>Along the way, we’ll uncover how the script leverages <strong>ActiveX</strong>, <strong>WMI</strong>, and network drive mapping to enumerate the host environment, stage an external payload, and clean up after itself. I’ll walk through each step, explaining not just what we find, but why it matters from a defensive perspective. The goal isn’t just to solve the challenge, but to help contextualize what we find. Let’s go!</p><p>And hey, if this walkthrough helps you level up your JavaScript analysis skills, gets you past a stumbling block, or simply gives you another angle on script-based malware, consider following along for more weekly deep dives.</p><p>Thanks for reading and going on this investigation with me!</p><h3>Challenge Scenario:</h3><blockquote>Imagine you are a cybersecurity analyst at a mid-sized tech company. One morning, you receive multiple reports from employees that their web applications are behaving erratically. Upon investigation, you discover that the source code of several critical JavaScript files has been heavily obfuscated, making it difficult to understand and troubleshoot the code. This obfuscation includes the insertion of numerous misleading comments, variable renaming, and string encoding. Your task is to analyze the obfuscated JavaScript code, identify the obfuscation techniques used, and determine if any malicious code has been inserted.</blockquote><h3>Question 1: What is the name of the ActiveXObject created in the script?</h3><p>Let’s kick off our investigation by extracting the sample from sample.7z. This leaves us with an appropriately named text file, sample, which contains the obfuscated JavaScript we’re going to analyze.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/895/1*976pLXlTeM7gY7GxsJHR2w.png" /><figcaption>Overview of the challenge artifacts.</figcaption></figure><p>Just to get an idea of what we’re working with, go ahead and open the file in the text editor provided by the <strong>LetsDefend</strong> environment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2bnLgYmbefqp8ahR57aWwA.png" /><figcaption>Overview of the sample in a text editor</figcaption></figure><p>Yikes, it’s a mess! Under normal circumstances, we might start this workflow by throwing the script into <strong>CyberChef</strong> or another deobfuscation tool. This time, though, we’re deliberately limiting ourselves to what’s provided in the analysis environment. So, no automated tooling and no internet access. But, what we do have is the terminal and familiar Linux utilities like grep, which can still take us surprisingly far (<em>like the whole way</em>).</p><p>So, instead of trying to deobfuscate everything at once, we can find our footing by looking for recognizable patterns. For <strong>Question 1</strong>, we’re specifically asked to identify the <em>ActiveXObject</em> created in the script. That gives us a clear string to hunt for.</p><p>We’ll start by printing the contents of the sample to the terminal, piping the output into grep, and using the -i flag to ignore case and simply searching for “<em>activex</em>.”</p><pre>cat sample | grep -i &quot;activex&quot;</pre><p>Running this command highlights a handful of non-obfuscated lines buried in the noise. Among them, we find the following code:</p><pre>new ActiveXObject(&quot;WScript.Network&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*r2JEsrbP2JkS8sKK1I-9zg.png" /><figcaption>Terminal: Using grep to identify “activeX”</figcaption></figure><p>This tells us that the script leverages the <em>ActiveXObject</em> named <em>“WScript.Network”</em>. From the limited context we have so far, this suggests the script might be performing basic network enumeration, such as retrieving the computer name, domain membership, or mapped network drives.</p><p>Now that we’ve found some early reconnaissance behavior, let’s dig in further to see what else we can find.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NL1Acc-byKeI53BYSpxZ2Q.png" /></figure><h3>Question 2: What WMI namespace is accessed in the script?</h3><p>Next, we need to identify which Windows Management Instrumentation, or <strong>WMI</strong>, namespace the script accesses. WMI namespaces are essentially logical containers that group related management classes (like components) together. Understanding which namespace is in use helps us infer what kinds of system information the script is aiming to collect.</p><p>We’ll tackle this the same way we did in <strong>Question 1</strong> by narrowing our focus with grep. This time, instead of searching for <em>ActiveX</em>, we’ll key in on <em>WMI</em>:</p><pre>cat sample | grep -i &quot;WMI&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lt6atEWauTIvSA8Vf00dKA.png" /><figcaption>Terminal: Identifying the WMI namespace with grep</figcaption></figure><p>This output gives us a bit more to work with. Right on the first matching line, we can see evidence that the script is interacting with the root\\CIMV2 namespace.</p><p>According to <a href="https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_wmi?view=powershell-7.6">Microsoft</a>, <em>“root\CIMV2”</em> is the default and one of the most commonly used WMI namespaces. It exposes a broad set of system and hardware-related classes, allowing scripts to query information about things like disks, running processes, memory, operating system details, and more.</p><p>While this isn’t inherently malicious, it seems like we’ve stumbled across more potential reconnaissance activity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jQDv8UfCJMIRMZoHvZ5D-A.png" /></figure><h3>Question 3: What is the initial value of the attempt variable in the script?</h3><p>Moving right along to <strong>Question 3</strong>, we need to identify the initial value of the attempt variable in the script. At this point, we’re already comfortable leveraging some lightweight pattern matching, so we’ll continue leaning on the terminal and <em>grep</em>.</p><p>This time, we’ll broaden the search scope slightly by looking for all variable declarations. In this sample, the obfuscation conveniently leaves /var as a recurring pattern, which makes it a useful anchor for limiting our output:</p><pre>cat sample | grep -i &quot;/var&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jy5w7LEbz9Alfyxm-E940Q.png" /><figcaption>Terminal: Identifying the attempt variable</figcaption></figure><p>Voila! This approach yields a small set of variables without overwhelming us with too much noise. Scanning through the output, we’ll spot the definition of the attempt variable with a value of 0, suggesting it might be used as some kind of counter or control variable later in the script.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JFPtaEf1v3wCDU8L6s-ZPA.png" /></figure><h3>Question 4: What function is used to enumerate network drives in the script?</h3><p>We’ve got a rhythm down now. Remember back in <strong>Question 1</strong>, where we stumbled across early evidence of network reconnaissance activity tied to <em>WScript.Network</em>? For <strong>Question 4</strong>, we’ll pivot back to that thread and broaden our search.</p><p>This time, we’ll hunt for references to <em>network</em> more generally and see what turns up:</p><pre>cat sample | grep -i &quot;network&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7AzxuxxMzdqmG76jlKBusQ.png" /><figcaption>Terminal: Identifying the network drive enumeration</figcaption></figure><p>The output here is a bit noisier than before, but if you scan through the results, the third returned line stands out. That’s where we see a call to the network.MapNetworkDrive function.</p><p>This lines up nice and tidy with the <em>WScript.Network</em> object we identified earlier. Put together, it gives us solid evidence that the script is interacting with mapped network drives. Whether it’s enumerating existing mappings, creating new ones, or abusing them for lateral movement is something we’ll need to confirm by looking at how this function is used elsewhere in the code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IuFw3Psyw01m44BHK2cJ1A.png" /></figure><h3>Question 5: How long does the script wait (in milliseconds) after executing the net use command?</h3><p>Next up, we need to determine the waiting period defined in the script after executing the net use command. At first glance, it seems reasonable to search directly for the command itself. I tried grepping for <em>&quot;net use&quot;</em> first, but as you can see, that didn’t quite get us where we needed to go.</p><p>Instead, we need to zoom out slightly and look for broader timing-related evidence. In this case, the string <em>“starttime”</em> turns out to be a much better anchor:</p><pre>cat sample | grep -i &quot;starttime&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TxfMyjplmDdvnjVFulO_Ew.png" /><figcaption>Terminal: Identifying the wait time</figcaption></figure><p>This output reveals the delay logic implemented by the script. Based on the value assigned and how it’s used, we can see that the script waits 3000 milliseconds after executing the net use command to map a non-persistent network drive.</p><p>That’s a short pause before the script continues, giving the mapped network drive time to become available before potentially being leveraged for staging additional payloads or collecting data for exfiltration. Let’s keep going and build out more context.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kcZnyJHear57jEYOPCgl4g.png" /></figure><h3>Question 6: What is the MSI package used for installation in the script called?</h3><p>To answer <strong>Question 6</strong>, we need to identify the MSI package referenced in the script for the next stage of execution. Since the question explicitly mentions <em>installation</em>, it makes more sense to search for the Windows Installer utility itself rather than hunting blindly for .msi strings.</p><p>Instead, we’ll look for <a href="https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/msiexec"><em>msiexec</em></a>, the command-line tool commonly used to install MSI packages on Windows systems:</p><pre>cat sample | grep -i &quot;msiexec.exe&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C228-Lccfbi5LUEPURLMBw.png" /><figcaption>Terminal: Identifying the package through msiexec</figcaption></figure><p>Bingo. This immediately surfaces the relevant line in the script. From the command arguments, we can see that the installer being executed is avp.msi, and it’s being launched directly from the mapped network share we identified earlier.</p><p>This ties back nicely to our observations in <strong>Question 5</strong>. We speculated that the mapped drive could be used for malware staging, and seeing avp.msi hosted on that share gives us increased confidence though we don’t have any firm evidence that it’s malicious.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4NE9I31vuGGXVmTeXPn6ZA.png" /></figure><h3>Question 7: What is the final output message if the network drive removal fails in the script?</h3><p>Coming into the home stretch, the question tells us that the script attempts to remove the mapped network drive and displays a message if that operation fails.</p><p>To track this down, we can keep things simple and adjust our grep filter to look for failure-related strings:</p><pre>cat sample | grep -i &quot;fail&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EJ9Ldiilq4wEy0wjiMdFQQ.png" /><figcaption>Terminal: Identifying the failure message</figcaption></figure><p>This quickly surfaces a message associated with the network drive cleanup logic.</p><p>From this, we can infer that after the MSI payload is executed, the script attempts to disconnect the staging area. If that removal fails, a failure message is displayed. This kind of cleanup behavior is likely an effort to remove artifacts and reduce the forensic footprint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wUV6BkOTpb4dO0070u2zvQ.png" /></figure><h3>Question 8: What function is used to check if a drive is mapped in the script?</h3><p>For the last question, we’ll follow a similar approach to the previous one. The prompt tells us there’s a function in the script responsible for checking whether a network drive is mapped, so we already have a nice hint about what to look for.</p><p>Let’s gather a bit more information by grepping for keywords related to drive mappings:</p><pre>cat sample | grep -i &quot;mapped&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*drNPdPkIvpLzsA1kC_8-hA.png" /><figcaption>Terminal: Identifying the isDriveMapped function</figcaption></figure><p>From this, we can see that the function isDriveMapped is used to determine whether a specific drive letter is already mapped, making it easy for the rest of the script to reference and reuse that information during execution.</p><p>And that’s all she wrote. This wraps up the analysis and confirms that the script includes logic not just to map and remove network drives, but also to track their state along the way. Great job!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l2OcbanvjXCxgtroUeMUxg.png" /></figure><h3>Conclusion:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-KSDG-CG3Da0hbm6JkaVxQ.png" /></figure><p>How fun was that? A big thank you to <strong>LetsDefend</strong> for another solid challenge.</p><p>This challenge was a great reminder that you don’t need advanced reverse engineering skills to extract meaningful insight from a suspicious script. By leaning on static analysis, pattern matching, and some inference from the questions, we were able to uncover suspicious functionality in the script, including host reconnaissance, network drive staging, payload delivery, and cleanup behavior, using nothing more than a terminal and a text editor.</p><p>For me, this challenge was just as much about exposure to different kinds of malware as it was about answering the questions. Obfuscated JavaScript isn’t at the top of my skillset, but working through this scenario highlighted the value of breaking things down, following the artifacts, and letting the script tell the story.</p><p>It also feels less hypothetical than it might have a few years ago. Script-based malware is still very much alive, and it’s the sort of activity defenders continue to encounter in real web environments. Getting comfortable with these patterns, even in a lab setting, pays dividends when similar behaviors show up during incident response or threat hunting.</p><p>Thanks for your support and for partnering with me on this investigation. If this walkthrough helped you over a stumbling block, sharpened your analysis skills, or gave you a new way to approach obfuscated scripts, please give it a clap and consider following me. Your feedback keeps me motivated, and it genuinely helps me support your security journey.</p><p>Until next week’s challenge, stay curious and be safe out there.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/1*lAzW-XArQrYfSbfHFTC0Ww.png" /></figure><h3>Tools &amp; References:</h3><p><strong>Challenge Link: </strong><a href="https://app.letsdefend.io/challenge/obfuscated-javascript">https://app.letsdefend.io/challenge/obfuscated-javascript</a></p><p><strong>Microsoft Learn — about_WMI: </strong><a href="https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_wmi?view=powershell-7.6">https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_wmi?view=powershell-7.6</a></p><p><strong>Microsoft Learn — msiexec:</strong> <a href="https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/msiexec">https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/msiexec</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=16fbbbca43ac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LetsDefend: AI-Powered Ransomware Challenge Walkthrough]]></title>
            <link>https://stumblesec.medium.com/letsdefend-ai-powered-ransomware-challenge-walkthrough-2ff9dc95801b?source=rss-b1b82253e27c------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ff9dc95801b</guid>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[malware-analysis]]></category>
            <category><![CDATA[letsdefendio]]></category>
            <category><![CDATA[lets-defend]]></category>
            <dc:creator><![CDATA[Drew Arpino]]></dc:creator>
            <pubDate>Sun, 29 Mar 2026 23:01:01 GMT</pubDate>
            <atom:updated>2026-03-29T23:01:01.199Z</atom:updated>
            <content:encoded><![CDATA[<h4>Reverse Engineering PromptLock: Static Analysis of AI‑Powered Ransomware Using Ghidra, DiE, and PeStudio</h4><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*s3OsD8aT5POQ6tfG.png" /><figcaption>Image Credit: <a href="https://app.letsdefend.io/challenge/ai-powered-ransomware">https://app.letsdefend.io/challenge/ai-powered-ransomware</a></figcaption></figure><h3>Introduction:</h3><p>Welcome to my weekly walkthrough. If you’ve stumbled across this blog while looking for a step‑by‑step guide to the <a href="https://app.letsdefend.io/challenge/ai-powered-ransomware"><strong>AI-Powered Ransomware</strong></a> challenge from <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a> you’re in the right place. This week’s scenario pushes into unfamiliar territory for me, combining traditional malware analysis with local AI model abuse, and that makes it a great opportunity to slow down, ask questions, and learn together.</p><p>In this challenge, we’re tasked with analyzing <strong>PromptLock</strong>, a cross‑platform ransomware sample written in <strong>Go</strong> that leverages local large language models to generate malicious scripts on the fly.</p><p>Because this is still a growth area for me, this walkthrough leans into methodical static analysis rather than a deep dive with hero‑level reversing. Using tools like <strong>Ghidra</strong>, <strong>Detect It Easy (DiE)</strong>, and <strong>PeStudio</strong>, we’ll pull apart the binary to answer focused questions about how PromptLock works. Along the way, there will absolutely be moments where we stumble or don’t take the most efficient path. That’s part of the learning process, and we’ll still get to the bottom of it.</p><p>The goal here isn’t just to answer the challenge questions, but to build a repeatable workflow you can apply when you encounter unfamiliar malware techniques in the real world, especially as AI starts showing up in unexpected places. If this write‑up helps you learn more about static analysis, local AI abuse, or simply gets you past a stumbling block of your own, I’m glad to help. Let’s go!</p><h3>Challenge Scenario:</h3><blockquote>You are tasked with analyzing <strong>PromptLock</strong>, the first AI-powered ransomware. This malware is written in Go and leverages local AI models to generate malicious scripts on-the-fly. PromptLock can generate scripts from hard-coded prompts to enumerate the local filesystem, inspect target files, exfiltrate selected data, and perform encryption. These scripts are cross-platform compatible, functioning on Windows, Linux and macOS.</blockquote><h3>Question 1: What programming language do the malicious scripts generated by PromptLock use?</h3><p>Let’s kick off this investigation by extracting the challenge file, promptlock.zip. That leaves us with a single executable:</p><pre>e24fe0dd0bf8d3943d9c4282f172746af6b0787539b371e6626bdb86605ccd70.exe</pre><p>To start the analysis, we turn to <a href="https://github.com/horsicq/Detect-It-Easy"><strong>Detect It Easy (DiE)</strong></a>. <em>Detect It Easy</em> is a popular file identification tool that’s especially useful early in a reverse engineering workflow. It can help identify compilers, metadata, and it also gives us access to plaintext strings that might expose clues about how the malware operates.</p><p>Conveniently, <em>Detect It Easy</em> is already installed on the LetsDefend VM under the <em>Tools</em> folder. Once opened, select the PromptLock binary using the <em>File name</em> selector to start the analysis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BRsnEALUwNfq4pCrh98z_g.png" /><figcaption>Detect It Easy: Selecting the Strings View</figcaption></figure><p>Clicking the <em>Strings</em> button lets us inspect human‑readable data embedded in the binary. This is a smart starting point for a cursory review, especially when we’re trying to understand high‑level capabilities without diving straight into disassembly.</p><p>Since this is an introductory reverse‑engineering challenge and I’m very much a beginner, let’s lean on the provided hint for a jump start.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jXN8i_YmNOo9mnfbFr0BSA.png" /></figure><p>Perfect! That hint nudges us toward something visible in the strings output, so let’s search for <em>“code generator”</em> using DiE’s strings filter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2i8i-eJzs3_wmX5MAZ_1IQ.png" /><figcaption>Detect It Easy: Searching strings and pasting into Notepad++</figcaption></figure><p>The search returns a single match, but the raw output is hard to read in <em>DiE</em>. Right‑click the entry, copy the string, and paste it into <a href="https://notepad-plus-plus.org/"><strong>Notepad++</strong></a> or another text editor of your choice. Cleaning up the formatting makes the content much easier to understand.</p><p>The prompt embedded in the binary instructs the LLM to behave as a <em>Lua code generator</em>. That tells us the malicious scripts generated by PromptLock are written in <strong>Lua, </strong>which<strong> </strong>answers <strong>Question 1</strong>.</p><p><em>Lua</em> is lightweight, embeddable, and commonly used as a scripting language, which makes it a good choice for generating malicious scripts. Nice find!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lCbHdhNGA19rT3AerEymYQ.png" /></figure><h3>Question 2: What role is assigned to the LLM for analyze sensitive files and assess cyberphysical threats?</h3><p>We can approach <strong>Question 2</strong> the same way we did in the previous question. This time, we’re looking for strings that describe a role assigned to the LLM through the embedded prompt.</p><p>One keyword from the question stands out immediately: <em>cyberphysical</em>. It’s weird and likely to appear verbatim in the prompt text. That makes it a good candidate for a strings search. Let’s try it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*arsZg2Hae2SB8zr-XO6cSA.png" /><figcaption>Detect It Easy: Searching strings and pasting into Notepad++</figcaption></figure><p>Bingo! That keyword leads us directly to an associated prompt. As before, right‑click the matching string, copy it, and paste it into <strong>Notepad++</strong> or another text editor to make it easier to read.</p><p>Once the formatting is cleaned up, the context is clear. The prompt explicitly instructs the LLM to take on the role of a <strong>cybersecurity expert</strong> for responding to requests. Assigning a role this way is a common prompt‑engineering technique, intended to guide the model toward more context-relevant output.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*14g2euvQbBgPfVyOBSAs4A.png" /></figure><h3>Question 3: What Go version was used to build the PromptLock ransomware?</h3><p>Let’s see if we can continue using <strong>Detect It Easy (DiE)</strong> and its <em>Strings</em> view to identify the <strong>Go</strong> version used to build the PromptLock ransomware.</p><p>To do that, we first need a rough understanding of how <em>Go</em> versioning works. According to <a href="https://en.wikipedia.org/wiki/Go_(programming_language)">Wikipedia</a>, <em>“Go uses a </em><em>go1.[major].[patch] versioning format, such as </em><em>go1.26.0.” </em>This is a helpful tip and suggests we can search for the string go1 in the binary to identify development artifacts.</p><p>With that in mind, let’s search for go1 using DiE’s strings filter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Dj_BwYwKzwiM4U6wyPLMig.png" /><figcaption>Detect It Easy: Finding the Go version string</figcaption></figure><p>There are a bunch of hits for go1, which isn’t too surprising. But, scanning through the results, one entry stands out, because it closely matches the expected go1.X format used for version identifiers.</p><p>That string indicates the specific <em>Go</em> version (<em>go1.24.5</em>) used to compile the binary, giving us the answer to <strong>Question 3</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3Kisuee6wQdkS6wBzz4Tyw.png" /></figure><h3>Question 4: Which AI model does PromptLock use locally via the Ollama API to generate malicious scripts?</h3><p>To answer <strong>Question 4</strong>, we need to crank up the difficulty slightly. This time, there wasn’t an obvious or relevant string in <em>Detect It Easy’s</em><strong> </strong><em>Strings</em> view that pointed directly to the AI model used by the malware.</p><p>That’s our cue to shuffle the approach.</p><p>For this task, let’s move over to <a href="https://github.com/nationalsecurityagency/ghidra"><strong>Ghidra</strong></a>, the popular open‑source reverse engineering tool. From the <em>Tools</em> folder, launch it by running ghidraRun.bat, step through the setup prompts, and allow Ghidra to analyze the PromptLock binary. Once analysis completes, Ghidra asks whether we want to jump straight to the main.main function, which is almost always a solid jumping‑off point.</p><p>With main.main open, focus on the <em>Decompiler</em> window on the right. Scrolling through the variables and references, we’ll stumble across a call to main.model appearing on line 244. That sounds promising…</p><p>Go ahead and click main.model to jump to its definition in the central, listing window.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uUCVUNWyFHsOpfcmHFmvyQ.png" /><figcaption>Ghidra: Identifying the AI model from the main.model function</figcaption></figure><p>Here we find a string value assigned to main.model.str: gpt-oss:20b.</p><p>This tells us which AI model PromptLock is configured to use locally through <strong>Ollama: </strong><em>gpt‑oss:20b</em>. This is an <strong>OpenAI</strong>‑released<strong>, </strong>open‑weight language model designed for running locally. That makes it a good fit for this scenario, as PromptLock seems to generate malicious scripts entirely on‑host without relying on external connectivity or credentials.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RHSSiYivfYs7J9IeDqdHIg.png" /></figure><h3>Question 5: What is the hardcoded IP address that PromptLock connects to?</h3><p>To answer <strong>Question 5</strong>, we need to identify a hard‑coded IP address embedded in the PromptLock binary. While there are a few different ways to approach this using the tools we’ve already touched, let’s pivot and get some hands‑on time with another option: <a href="https://www.winitor.com/"><strong>pestudio</strong></a>.</p><p><em>pestudio</em> is a fantastic static malware analysis tool that can surface a wide range of useful indicators quickly and with very little setup. It’s especially good at identifying things like IP addresses, URLs, and suspicious strings without requiring deep reverse engineering. Conveniently, this tool is also already included on the LetsDefend VM, so let’s take advantage of that.</p><p>Open <em>pestudio</em> and load the PromptLock executable. After a short analysis period, the panels on the left begin to populate. The section we’re interested in first is <em>Indicators </em>at the top.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tzZSWY1uv3oHbkcvbi4IiQ.png" /><figcaption>pestudio: Uncovering a hardcoded IP address</figcaption></figure><p>This gives us a fast way to surface potential network indicators that we can later pivot on using threat intelligence or additional dynamic analysis. In this case, the URL pattern detected by <em>pestudio</em> resolves to the hardcoded IP address we’re looking for: 172[.]42[.]0[.]253.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VIb068FIpFW1q2nmfZBg1A.png" /></figure><h3>Question 6: Which encryption algorithm does the PromptLock ransomware use for file encryption?</h3><p>To answer <strong>Question 6</strong>, let’s jump back to <em>Detect It Easy</em><strong> </strong>and take the path of least resistance by searching for a string related to encryption functionality.</p><p>A good starting point here is searching for the string &quot;encrypt&quot;. That returns a large number of results, which isn’t surprising for a ransomware sample. Fortunately, near the top of the list, there’s something immediately conspicuous: a prompt instruction that explicitly references the <em>SPECK</em> 128‑bit encryption algorithm. You might even notice a small spoiler for <strong>Question 8</strong> hiding nearby.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RAuflvmCB2dWo8RWIG_dtw.png" /><figcaption>Detect It Easy: Locating the ransomware encryption algorithm string</figcaption></figure><p>That string gives us what we need to answer <strong>Question 6</strong>. PromptLock uses <strong>SPECK</strong> 128-bit for encryption.</p><p>The use of <em>SPECK</em> seems consistent with how this malware approaches its overall design. According to <a href="https://en.wikipedia.org/wiki/Speck_(cipher)"><em>Wikipedia</em></a>, <em>SPECK</em> is a “<em>family of lightweight block ciphers</em>”, making it practical for ransomware that prioritizes cross-platform portability and low overhead.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kRbY8MEk2fWHqDbLQTEjnQ.png" /></figure><h3>Question 7: What is the Bitcoin address embedded in the binary?</h3><p>To answer <strong>Question 7</strong>, we can take a straightforward approach by adjusting our search of the embedded strings for &quot;bitcoin&quot;.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XXVonxluF7XNMr4t_CvkTg.png" /><figcaption>Detect It Easy: Discovering the attacker’s Bitcoin wallet address</figcaption></figure><p>It’s a quick payoff. Take a look at the first entry and copy it and paste it into a text editor for easier reading. From there, we’ll find that the prompt instructs the LLM to include a specific <strong>Bitcoin</strong> address in the generated ransom note. Nice!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bS6ZP-rPfmejI6UwnS9bPw.png" /></figure><h3>Question 8: What is the file name contains the list of files to encrypt?</h3><p>We’ve made it to the last question. Remember back in <strong>Question 7</strong> when I mentioned you might have spotted a spoiler for what was coming next?</p><p>If we look closely at the strings output again, specifically at line 11359, right below the one we used to answer <strong>Question 7</strong>, we’ll find another useful instruction. This time, the prompt references a file named target_file_list.log.</p><p>The instructions indicate that this file is used to identify the encryption targets, telling PromptLock which files it should encrypt. That makes target_file_list.log the answer to <strong>Question 8</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5rTM_wK1WS6AA0UFLDfamQ.png" /><figcaption>Detect It Easy: Finding the target list file name string</figcaption></figure><p>This is a particularly valuable piece of evidence from a defensive perspective. Knowing the file name that contains the list of targets could help us better understand the scope of impact on a victim device, recover during an investigation, and build more precise detections.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ge3_taNRyYk3BCDbtQ6yEA.png" /></figure><h3>Conclusion:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MsHYvF_35P2KK4frB-yQmg.png" /></figure><p>How fun was that! A big thank you to <a href="https://app.letsdefend.io/"><strong>LetsDefend</strong></a><strong> </strong>for another great challenge that pushed me into some new territory.</p><p>This one was a good reminder that even with beginner‑level reverse engineering skills, you can still extract a surprising amount of meaningful information from a malware sample. By leaning on static analysis techniques and using the right tools at the right time, we were able to uncover AI model usage, encryption choices, network indicators, and attacker intent without needing to be a reversing wizard. That’s encouraging, especially if you’re earlier in your journey or hesitant to dive into malware analysis.</p><p>For me, this challenge was as much about building confidence as it was about answering questions. Static analysis isn’t always flashy, but it’s incredibly powerful, and working through PromptLock reinforced the value of slowing down, reading carefully, and following the evidence where it leads. There were moments where I stumbled or took a less‑than‑ideal path, but each of those course corrections helped reinforce the process and make the lessons stick.</p><p>It also feels like scenarios like this aren’t just theoretical. As AI becomes more accessible and more normalized, it’s not hard to imagine malware authors experimenting with similar designs. Getting comfortable with the terminology, tooling, and patterns now feels like a smart way to stay ahead of the curve, even if the analysis feels a little weird at first.</p><p>Thanks for your support and partnering on this investigation. If you found this walkthrough helpful — please give it a clap and consider following me! Your feedback is invaluable, and it pumps me up to support your security journey. Remember, cybersecurity is a team sport, and we’re in this together!</p><p>Until next week’s challenge — stay curious and be safe out there!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/1*lAzW-XArQrYfSbfHFTC0Ww.png" /></figure><h3>Tools &amp; References:</h3><p><strong>Challenge Link: </strong><a href="https://app.letsdefend.io/challenge/ai-powered-ransomware">https://app.letsdefend.io/challenge/ai-powered-ransomware</a></p><p><strong>Detect It Easy:</strong> <a href="https://github.com/horsicq/Detect-It-Easy">https://github.com/horsicq/Detect-It-Easy</a></p><p><strong>Notepad++</strong>: <a href="https://notepad-plus-plus.org/">https://notepad-plus-plus.org/</a></p><p><strong>Wikipedia — Go (Programming Language):</strong> <a href="https://en.wikipedia.org/wiki/Go_(programming_language)">https://en.wikipedia.org/wiki/Go_(programming_language)</a></p><p><strong>Ghidra: </strong><a href="https://github.com/nationalsecurityagency/ghidra">https://github.com/nationalsecurityagency/ghidra</a></p><p><strong>pestudio:</strong> <a href="https://www.winitor.com/">https://www.winitor.com/</a></p><p><strong>Wikipedia — Speck (cipher):</strong> <a href="https://en.wikipedia.org/wiki/Speck_(cipher)">https://en.wikipedia.org/wiki/Speck_(cipher)</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ff9dc95801b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>