<?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 Pratik Gurav on Medium]]></title>
        <description><![CDATA[Stories by Pratik Gurav on Medium]]></description>
        <link>https://medium.com/@pratik0x?source=rss-7134f1073431------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*fCbKnvVSKelPsRsgxcfiYQ.png</url>
            <title>Stories by Pratik Gurav on Medium</title>
            <link>https://medium.com/@pratik0x?source=rss-7134f1073431------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 18:33:20 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@pratik0x/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[DNS Exfiltration: The Quiet Data Channel]]></title>
            <link>https://pratik0x.medium.com/dns-exfiltration-the-quiet-data-channel-052af8692609?source=rss-7134f1073431------2</link>
            <guid isPermaLink="false">https://medium.com/p/052af8692609</guid>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[soc]]></category>
            <category><![CDATA[detection-engineering]]></category>
            <category><![CDATA[incident-response]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Pratik Gurav]]></dc:creator>
            <pubDate>Wed, 30 Sep 2026 01:31:02 GMT</pubDate>
            <atom:updated>2026-09-30T01:31:02.026Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>How DNS queries become a covert tunnel.</em></h4><p>You’re watching HTTPS traffic. You’re monitoring file uploads. But data is still leaving your network.</p><p>How? Through the one protocol that almost never gets blocked: DNS.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*64UsQ1tAIPxg3_QdYAuUtg.png" /></figure><h3>How DNS Becomes a Data Tunnel</h3><p>Normal DNS query:</p><pre>Query: mail.google.com<br>Response: 142.250.185.37</pre><p>DNS exfiltration:</p><pre>Query: 4a6f686e.sensitive-file.attacker.com<br>       ↑<br>  &quot;John&quot; in hex, encoded in subdomain</pre><p>The attacker’s DNS server receives the query, extracts the data from the subdomain, and never sends it to the real destination.</p><h3>Why DNS Exfiltration Works</h3><p>✓ DNS is rarely blocked — blocking DNS breaks the internet</p><p>✓ High query volume hides it — thousands of queries daily</p><p>✓ Encryption isn’t needed — data is in the query itself, not the payload</p><p>✓ Many orgs don’t log DNS — no visibility = no detection</p><h3>The Three DNS Exfiltration Patterns</h3><p>1. Abnormally Long Queries</p><pre>Normal: cdn.example.com (15 chars)<br>Exfil:  d8f3a9b2c1e5f7g4h6i8j0k2l4m6n8o0p2q4r6s8t0.attacker.com (65 chars)te</pre><p>2. High Query Volume to One Domain</p><pre>10:00:01 → a1b2c3.evil.com<br>10:00:02 → d4e5f6.evil.com  <br>10:00:03 → g7h8i9.evil.com<br>[...hundreds more in minutes...]</pre><p>3. Randomized Subdomains</p><pre>8f3a.attacker.com<br>2c1e.attacker.com<br>7g4h.attacker.com</pre><p>Normal subdomains: mail., www., cdn.<br>Exfil subdomains: random hex/base64</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YSyo0oUvYkuN1t1CRjUE_A.png" /></figure><h3>Quick Detection Rule</h3><p>Flag DNS queries matching:</p><pre>✓ Subdomain length &gt;40 characters<br>✓ &gt;50 queries to same domain in 5 minutes<br>✓ High entropy (randomness) in subdomain<br>✓ Non-standard TLDs (.xyz, .top, .club)</pre><p><strong>KQL Detection Query</strong></p><pre>DnsEvents<br>| where TimeGenerated &gt; ago(1h)<br>| extend <br>    QueryLength = strlen(Name),<br>    Subdomain = split(Name, &quot;.&quot;)[0],<br>    SubdomainEntropy = entropy(Subdomain)  // Custom function<br>| where QueryLength &gt; 40 or SubdomainEntropy &gt; 3.5<br>| summarize <br>    QueryCount = count(),<br>    UniqueSubdomains = dcount(Subdomain)<br>    by Name, ClientIP<br>| where QueryCount &gt; 50 or UniqueSubdomains &gt; 20<br>| order by QueryCount desc</pre><h3>Real-World Example</h3><p>Scenario: User downloads a “resume.pdf” — actually malware.</p><p>The malware reads passwords.txt, encodes it, and exfiltrates via DNS:</p><pre>cGFzc3dvcmQ.exfil.attacker.com<br>xMTIzNDU.exfil.attacker.com  <br>2Njc4OTAh.exfil.attacker.com</pre><h3>Defense Strategy</h3><p>1. Log all DNS queries (internal + external)</p><p>2. Use a DNS sinkhole (block known exfil domains)</p><p>3. Monitor for patterns:</p><ul><li>Query length anomalies</li><li>Burst query volumes</li><li>Random subdomain generation</li></ul><p>4. Restrict DNS to authorized servers only (no direct external DNS)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8ezZdMauGUot8beAcOQ2vQ.png" /></figure><h3>The Quiet Channel</h3><p>DNS exfiltration is effective because it’s invisible to traditional monitoring. No large file uploads, no suspicious HTTPS connections — just innocent-looking name resolutions.</p><p>Until you start watching the queries themselves.</p><p>Are you logging DNS queries in your environment? If not, you might be missing the quietest data leak of all.</p><p><strong><em>→ Explore entropy-based detection patterns in my GitHub’s YARA rule library: </em></strong><a href="https://github.com/pratik0x/yara-rules"><strong><em>https://github.com/pratik0x/yara-rules</em></strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=052af8692609" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOC Investigation Diary #03 — Network Indicators and the Hunt for C2]]></title>
            <link>https://pratik0x.medium.com/soc-investigation-diary-03-network-indicators-and-the-hunt-for-c2-fa81cb94558c?source=rss-7134f1073431------2</link>
            <guid isPermaLink="false">https://medium.com/p/fa81cb94558c</guid>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[incident-response]]></category>
            <category><![CDATA[soc]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[blue-team]]></category>
            <dc:creator><![CDATA[Pratik Gurav]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 03:31:02 GMT</pubDate>
            <atom:updated>2026-09-28T03:31:02.078Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Behavioral patterns in outbound traffic analysis.</em></h4><p>The malware was deleted. The process was killed. The endpoint is clean.</p><p>But your attacker? They’re still connected — quietly beaconing to their command-and-control server every 60 seconds, waiting for the next instruction.</p><p>Finding C2 traffic isn’t about blocking known bad IPs. It’s about recognizing the behavioral fingerprint of remote control hiding in your legitimate traffic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QfilPWO5KkXrena_WhgSIw.png" /></figure><h3>Why C2 Detection Matters</h3><p>You can clean a hundred infected endpoints, but if the C2 channel stays active:</p><ul><li>Reinfection happens within minutes</li><li>Lateral movement continues undetected</li><li>Data exfiltration persists through the “cleaned” network</li></ul><p>The C2 server is the attacker’s lifeline. Cut it, and you break the attack chain.</p><h3>The Three C2 Behavioral Patterns</h3><h3>Pattern 1: The Heartbeat (Beaconing)</h3><p>What it looks like:<br>Regular, predictable outbound connections at fixed intervals.</p><pre>10:00:00 → example.com (150 bytes out, 89 bytes in)<br>10:05:00 → example.com (150 bytes out, 89 bytes in)<br>10:10:00 → example.com (150 bytes out, 89 bytes in)<br>10:15:00 → example.com (150 bytes out, 89 bytes in)</pre><p>Why attackers do this:</p><ul><li>Check if the implant is still alive</li><li>Poll for new commands</li><li>Maintain persistence</li></ul><p>Detection markers:</p><ul><li>✓ Consistent time intervals (every 5min, 15min, 1hr)</li><li>✓ Similar packet sizes (±10%)</li><li>✓ Same source/destination pair</li><li>✓ Occurs outside business hours</li></ul><p>KQL Hunt Query:</p><pre>// Detect beaconing behavior in network connections<br>NetworkConnectionEvents<br>| where TimeGenerated &gt; ago(24h)<br>| summarize<br>ConnectionCount = count(),<br>AvgTimeBetween = avg(prev(TimeGenerated) - TimeGenerated),<br>StdDevTimeBetween = stdev(prev(TimeGenerated) - TimeGenerated),<br>UniqueBytes = dcount(SentBytes)<br>by RemoteIP, RemoteUrl, DeviceName<br>| where ConnectionCount &gt; 20<br>| where StdDevTimeBetween &lt; 30 // Low deviation = regular intervals<br>| where UniqueBytes &lt; 5 // Similar packet sizes<br>| project DeviceName, RemoteIP, RemoteUrl, ConnectionCount, AvgTimeBetween<br>| order by ConnectionCount desc</pre><h3>Pattern 2: The Data Mule (Exfiltration)</h3><p>What it looks like:<br>Large outbound transfers to unusual destinations.</p><pre>Host: workstation-42<br>Upload: 2.3 GB → cloud-storage-api.xyz<br>Duration: 47 minutes<br>Protocol: HTTPS (encrypted)<br>Time: 3:47 AM</pre><p>Why it’s suspicious:</p><ul><li>Workstations don’t typically upload GBs overnight</li><li>Unknown cloud services</li><li>Encrypted traffic (can’t inspect payload)</li></ul><p>Detection markers:</p><ul><li>✓ High outbound/inbound ratio (80% outbound)</li><li>✓ Connections to recently registered domains</li><li>✓ Long-duration sessions (&gt;30min)</li><li>✓ Non-standard ports (8443, 4443, 9443)</li></ul><p>KQL Hunt Query:</p><pre>// Detect potential data exfiltration<br>NetworkConnectionEvents<br>| where TimeGenerated &gt; ago(7d)<br>| where RemotePort in (443, 8443, 4443, 9443)<br>| summarize<br>TotalSent = sum(SentBytes),<br>TotalReceived = sum(ReceivedBytes),<br>SessionDuration = max(TimeGenerated) - min(TimeGenerated),<br>ConnectionCount = count()<br>by DeviceName, RemoteIP, RemoteUrl<br>| extend UploadRatio = (TotalSent * 100) / (TotalSent + TotalReceived)<br>| where TotalSent &gt; 500000000 // &gt;500MB uploaded<br>| where UploadRatio &gt; 70 // 70%+ outbound traffic<br>| project DeviceName, RemoteUrl, TotalSentGB = TotalSent/1GB,<br>UploadRatio, SessionDuration<br>| order by TotalSentGB desc</pre><h3>Pattern 3: The Conversation (Interactive Sessions)</h3><p>What it looks like:<br>Bidirectional traffic with irregular timing, someone is typing commands.</p><pre>15:23:14 → C2 server (234 bytes) // Command sent<br>15:23:15 ← C2 server (1,847 bytes) // Output received<br>15:24:03 → C2 server (189 bytes) // Next command<br>15:24:04 ← C2 server (945 bytes) // Output received</pre><p>Why it’s different:</p><ul><li>Not automated/regular like beaconing</li><li>Human typing speed patterns</li><li>Varied packet sizes (command output differs)</li></ul><p>Detection markers:</p><ul><li>✓ Irregular intervals (human timing)</li><li>✓ Variable packet sizes</li><li>✓ Back-and-forth pattern (not just beacons)</li><li>✓ Often on non-standard ports</li></ul><p>KQL Hunt Query:</p><pre>// Detect interactive C2 sessions<br>NetworkConnectionEvents<br>| where TimeGenerated &gt; ago(24h)<br>| where RemotePort !in (80, 443) // Focus on non-web traffic first<br>| order by DeviceName, TimeGenerated asc<br>| extend TimeDiff = next(TimeGenerated) - TimeGenerated<br>| where TimeDiff between (1s .. 60s) // Human-speed interactions<br>| summarize<br>Interactions = count(),<br>AvgTimeBetween = avg(TimeDiff),<br>UniquePacketSizes = dcount(SentBytes)<br>by DeviceName, RemoteIP, RemotePort<br>| where Interactions &gt; 10<br>| where UniquePacketSizes &gt; 5 // Variable data sizes<br>| project DeviceName, RemoteIP, RemotePort, Interactions, AvgTimeBetween</pre><h3>The C2 Infrastructure Footprint</h3><p>Beyond traffic patterns, look at where they’re connecting:</p><p>Suspicious Destination Characteristics:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/737/1*fntexdom_VDqmV_LRPEekg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QLA9DkdUhknGvwHWtn8oJQ.png" /></figure><p>KQL Hunt Query (Enrichment):</p><pre>// Enrich connections with threat intelligence<br>let ThreatFeeds = externaldata(MaliciousIP: string, ThreatType: string)<br>[@&quot;https://your-threat-feed.com/iocs.csv&quot;] with (format=&quot;csv&quot;);<br>NetworkConnectionEvents<br>| where TimeGenerated &gt; ago(24h)<br>| join kind=leftouter (ThreatFeeds) on $left.RemoteIP == $right.MaliciousIP<br>| where isnotempty(ThreatType)<br>| summarize FirstSeen = min(TimeGenerated),<br>LastSeen = max(TimeGenerated),<br>AffectedDevices = dcount(DeviceName)<br>by RemoteIP, ThreatType<br>| order by AffectedDevices desc</pre><h3>The Network Flow Diagram</h3><p>Here’s how C2 traffic flows through your defenses:</p><pre>┌─────────────┐<br>│  Infected   │<br>│  Endpoint   │<br>└──────┬──────┘<br>       │ 1. Beacon (HTTPS/443)<br>       ↓<br>┌─────────────┐<br>│  Firewall   │ ← Often allows 443 outbound<br>└──────┬──────┘<br>       │<br>       ↓<br>┌─────────────┐<br>│   Proxy/    │ ← Check here: URL filtering, SSL inspection<br>│     DNS     │<br>└──────┬──────┘<br>       │<br>       ↓<br>┌─────────────┐<br>│ C2 Server   │<br>│ (Attacker)  │<br>└─────────────┘<br>       │<br>       │ 2. Command response<br>       ↓<br>   [Repeat]</pre><p>Detection Points:</p><ul><li>Endpoint: Process making connection, user context</li><li>Firewall: Unusual outbound ports, geo-blocking</li><li>Proxy: URL categorization, certificate inspection</li><li>DNS: Query patterns, DGA detection</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g_SbUB-aIx23Gwd5983ZIg.png" /></figure><h3>Common C2 Detection Mistakes</h3><p>❌ Only blocking known bad IPs — Attackers rotate infrastructure hourly</p><p>❌ Ignoring encrypted traffic — “It’s HTTPS, can’t inspect” = blind spot</p><p>❌ Looking for large transfers only — Command beacons are small but deadly</p><p>❌ Not baselining normal — Can’t spot abnormal without knowing normal</p><p>❌ Hunting once and stopping — C2 detection is continuous, not one-time</p><h3>Closing Thoughts</h3><p>C2 traffic doesn’t announce itself with flashing lights. It masquerades as normal network behavior, hiding in your daily traffic flow.</p><p>But behavior doesn’t lie:</p><ul><li>Beaconing has rhythm</li><li>Exfiltration has volume</li><li>Interactive sessions have conversation patterns</li></ul><p><strong>Next time you’re hunting for C2:</strong></p><ol><li>Look for beaconing regularity (time + packet size)</li><li>Hunt for exfiltration volumes (GB uploads to new destinations)</li><li>Detect interactive sessions (irregular bidirectional traffic)</li><li>Check destination reputation (new domains, sketchy hosting)</li><li>Baseline normal to spot abnormal</li></ol><p>The attacker needs their C2 connection. Make finding it your priority.</p><p><strong><em>→ Explore entropy-based detection patterns in my GitHub’s YARA rule library: </em></strong><a href="https://github.com/pratik0x/yara-rules"><strong><em>https://github.com/pratik0x/yara-rules</em></strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fa81cb94558c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Event ID 4688: What Process Creation Really Tells You]]></title>
            <link>https://pratik0x.medium.com/event-id-4688-what-process-creation-really-tells-you-babbc57f6bd9?source=rss-7134f1073431------2</link>
            <guid isPermaLink="false">https://medium.com/p/babbc57f6bd9</guid>
            <category><![CDATA[security-operation-center]]></category>
            <category><![CDATA[detection-engineering]]></category>
            <category><![CDATA[incident-response]]></category>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Pratik Gurav]]></dc:creator>
            <pubDate>Sat, 26 Sep 2026 09:31:01 GMT</pubDate>
            <atom:updated>2026-09-26T09:31:01.619Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Command line obfuscation and parent-child relationships.</em></h4><p>Most analysts see Event ID 4688 and think “a process started.” But this event is a goldmine hiding three critical pieces of attack evidence.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oqOn-ppmSa1DC2B-dRE0GQ.png" /></figure><h3>1. The Parent-Child Relationship</h3><p>Normal:</p><pre>explorer.exe → chrome.exe</pre><p>Suspicious:</p><pre>winword.exe → powershell.exe → cmd.exe</pre><p>Red flag: Office apps shouldn’t spawn shells.</p><h3>2. Command Line Obfuscation</h3><p>Legitimate:</p><pre>powershell.exe -File C:\Scripts\backup.ps1</pre><p>Obfuscated:</p><pre>powershell.exe -enc JABhAD0AJwBoAHQAdABwADoALwA...</pre><p>Red flag: Base64-encoded commands hide malicious intent.</p><p>Common obfuscation patterns:</p><ul><li>Base64 encoding (-enc, -encodedcommand)</li><li>Carets/escapes (p^o^w^e^r^s^h^e^l^l)</li><li>Variable concatenation ($a=&#39;po&#39;;$b=&#39;wer&#39;;IEX($a+$b+&#39;shell&#39;))</li></ul><h3>3. The Process Context</h3><p>What to check:</p><ul><li>User: SYSTEM running user-mode apps? Privilege escalation.</li><li>Path: C:\Users\Public\ or C:\Temp\? Unusual execution location.</li><li>Process name: svch0st.exe vs svchost.exe? Typosquatting.</li></ul><h3>Quick Detection Rule</h3><p>Flag these 4688 patterns</p><pre>✓ Office apps spawning cmd/powershell<br>✓ Encoded PowerShell commands<br>✓ Processes from temp directories<br>✓ Misspelled system process names</pre><p><strong><em>Pro tip: </em></strong><em>Enable “Process Creation includes command line” in your audit policy. Event 4688 without command lines is like a crime scene photo with the evidence blurred out.</em></p><blockquote><strong>→ Explore entropy-based detection patterns in my GitHub’s YARA rule library: </strong><a href="https://github.com/pratik0x/yara-rules"><strong>https://github.com/pratik0x/yara-rules</strong></a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=babbc57f6bd9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOC Investigation Diary #02 — Reading Windows Event Logs Like a Detective]]></title>
            <link>https://pratik0x.medium.com/soc-investigation-diary-02-reading-windows-event-logs-like-a-detective-6817706821d6?source=rss-7134f1073431------2</link>
            <guid isPermaLink="false">https://medium.com/p/6817706821d6</guid>
            <category><![CDATA[soc]]></category>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[incident-response]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[detection-engineering]]></category>
            <dc:creator><![CDATA[Pratik Gurav]]></dc:creator>
            <pubDate>Sat, 26 Sep 2026 01:31:01 GMT</pubDate>
            <atom:updated>2026-09-26T01:31:01.855Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Event ID patterns that reveal attack stages.</em></h4><p>You’ve isolated the suspicious workstation. Now comes the real work: 47,000 Windows Event Logs staring back at you.</p><p>Somewhere in that haystack is the story of how the attacker got in, what they did, and where they went. But reading event logs linearly? That’s like reading a crime novel one random page at a time.</p><p>Today’s diary: how to read Windows Event Logs like a detective piecing together a timeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uxDqfHNvAjPv6pUktoYJrg.png" /></figure><h3>The Crime Scene Analogy</h3><p>Good detectives don’t process a crime scene randomly. They:</p><ol><li>Identify the crime (What happened?)</li><li>Establish the timeline (When did it happen?)</li><li>Find the evidence trail (How did they do it?)</li><li>Connect the dots (Who, what, where, why?)</li></ol><p>Event log investigation works the same way.</p><h3>Stage 1: The Initial Compromise</h3><p>Event IDs to Hunt:</p><ul><li>4624 (Logon) — Type 3 (network) or Type 10 (RDP)</li><li>4625 (Failed logon) — Brute force attempts before success</li><li>4648 (Explicit credential use) — “Run as” or credential spraying</li><li>4776 (NTLM auth) — Domain authentication attempts</li></ul><p>What I Look For:ext</p><pre>Unusual logon times → After-hours access<br>Logon Type 3 from internal host → Lateral movement prep<br>Multiple 4625 followed by 4624 → Successful brute force<br>Source IP not in known ranges → External compromise</pre><p>Detective Question: <em>“When was the first abnormal successful login?”</em></p><h3>Stage 2: Credential Access &amp; Privilege Escalation</h3><p>Event IDs to Hunt:</p><ul><li>4672 (Special privileges assigned) — Administrator logon</li><li>4673 (Sensitive privilege use) — SeDebugPrivilege (common in credential dumping)</li><li>4688 (Process creation) — LSASS access, Mimikatz-like commands</li><li>4697 (Service installed) — Persistence via new services</li></ul><p>Pattern Recognition:</p><p>A normal admin session:</p><pre>4624 (Admin logon) → 4672 (Admin rights) → 4688 (Legitimate admin tools)</pre><p>A credential dumping attack:</p><pre>4624 (User logon) → 4688 (cmd.exe spawns rundll32) → <br>4673 (SeDebugPrivilege) → 4688 (LSASS access via procdump)</pre><p>Detective Question: <em>“What did they do immediately after gaining access?”</em></p><h3>Stage 3: Lateral Movement</h3><p>Event IDs to Hunt:</p><ul><li>5140 (Network share accessed) — ADMIN,C,<em>C</em>, IPC$ access</li><li>5145 (Detailed file share) — What files were accessed</li><li>4648 (Explicit credentials) — Pass-the-hash indicators</li><li>4624 Type 3 (Network logon) — Remote authentication</li></ul><p>Timeline Tells the Story:</p><pre>Host A: 4688 (net.exe use \\HostB\C$)<br>       ↓<br>Host B: 4624 Type 3 (Network logon from Host A)<br>       ↓<br>Host B: 5140 (\\HostB\ADMIN$ accessed)<br>       ↓<br>Host B: 4688 (cmd.exe → malicious.exe)</pre><p>Detective Question: <em>“How many systems did they touch?”</em></p><h3>Stage 4: Data Exfiltration &amp; Impact</h3><p>Event IDs to Hunt:</p><ul><li>4663 (Object access) — File access auditing</li><li>5156 (Windows Filtering Platform) — Outbound connections</li><li>1102 (Security log cleared) — Anti-forensics</li><li>4719 (System audit policy changed) — Disabling logging</li></ul><p>Red Flags:</p><pre>Large volume 4663 events → Mass file access<br>5156 to unusual external IPs → Data exfiltration<br>1102 Security log cleared → Covering tracks<br>4719 Audit policy disabled → Going dark</pre><p>Detective Question: <em>“What were they after, and did they get it?”</em></p><h3>The Event Timeline Visualization</h3><p>Here’s how I build the attack narrative:</p><p>Step 1: Extract Key Events</p><pre>PowerShell</pre><pre>Get-WinEvent -FilterHashtable @{<br>    LogName=&#39;Security&#39;<br>    ID=4624,4625,4672,4688,4697,5140<br>    StartTime=(Get-Date).AddDays(-7)<br>} | Select TimeCreated, ID, Message | Export-Csv timeline.csv</pre><p>Step 2: Timeline Template:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/914/1*B-_ikJaqP00sPmDAVAMqfQ.png" /></figure><p>Step 3: Identify Gaps</p><p>Missing events between stages? Check:</p><ul><li>Application logs (PowerShell, Task Scheduler)</li><li>System logs (Service starts, crashes)</li><li>Firewall logs (Network connections)</li></ul><h3>Common Event Log Reading Mistakes</h3><p>❌ Reading chronologically — Jump to anomaly times first, then expand</p><p>❌ Ignoring event correlation — 4688 without parent process context is incomplete</p><p>❌ Trusting timestamps blindly — Attackers can manipulate system time</p><p>❌ Only checking Security logs — Application and System logs hold critical context</p><p>❌ Not filtering noise — Focus on authentication, process creation, network activity first</p><h3>Sigma Rule: Detect Credential Dumping Pattern</h3><p>Deploy this Sigma rule to catch the attack pattern in real-time:</p><pre>title: Credential Dumping via LSASS Access<br>id: a1b2c3d4-5678-90ab-cdef-1234567890ab<br>status: stable<br>description: Detects processes accessing LSASS memory<br>author: YourName<br>date: current-date<br>logsource:<br>    product: windows<br>    service: security<br>detection:<br>    selection:<br>        EventID: 4688<br>        NewProcessName|endswith:<br>            - &#39;\procdump.exe&#39;<br>            - &#39;\mimikatz.exe&#39;<br>            - &#39;\dumpert.exe&#39;<br>        CommandLine|contains:<br>            - &#39;lsass&#39;<br>            - &#39;sekurlsa&#39;<br>    privilege:<br>        EventID: 4673<br>        PrivilegeList: &#39;SeDebugPrivilege&#39;<br>    timeframe: 2m<br>    condition: selection and privilege<br>falsepositives:<br>    - Legitimate debugging tools by IT staff<br>level: high<br>tags:<br>    - attack.credential_access<br>    - attack.t1003.001</pre><h3>The Detective’s Checklist</h3><p>When investigating Windows Event Logs:</p><p>✅ Establish the initial compromise time (First abnormal 4624)</p><p>✅ Map privilege escalation (4672, 4673, 4688 sequence)</p><p>✅ Track lateral movement (5140, 4624 Type 3 across hosts)</p><p>✅ Identify anti-forensics (1102, 4719)</p><p>✅ Build a visual timeline (Excel, ELK, or pen and paper)</p><p>✅ Correlate with other data sources (EDR, firewall, proxy logs)</p><h3>Closing Thoughts</h3><p>Windows Event Logs aren’t just audit trails — they’re the crime scene documentation of your network. Every Event ID is a clue. The pattern between them tells the story.</p><p>Next time you’re staring at thousands of events:</p><ol><li>Start with authentication (4624, 4625, 4648)</li><li>Look for privilege escalation (4672, 4673, 4688)</li><li>Track lateral movement (5140, 4624 Type 3)</li><li>Identify the impact (4663, 5156, 1102)</li><li>Build the timeline</li></ol><p>The attacker left their story in your logs. You just need to know how to read it.</p><h3>Call-to-Action</h3><p>🎯 Deploy this Sigma rule in your SIEM and see what credential dumping attempts you’ve been missing.</p><p>What Event IDs do you always check first in an investigation? Share your detective techniques in the comments.</p><blockquote><strong>→ Explore entropy-based detection patterns in my GitHub’s YARA rule library: </strong><a href="https://github.com/pratik0x/yara-rules"><strong>https://github.com/pratik0x/yara-rules</strong></a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6817706821d6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[False Positive Fatigue: When Alert Volume Becomes Your Problem]]></title>
            <link>https://pratik0x.medium.com/false-positive-fatigue-when-alert-volume-becomes-your-problem-296266c2decf?source=rss-7134f1073431------2</link>
            <guid isPermaLink="false">https://medium.com/p/296266c2decf</guid>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[detection-engineering]]></category>
            <category><![CDATA[security-operation-center]]></category>
            <dc:creator><![CDATA[Pratik Gurav]]></dc:creator>
            <pubDate>Sun, 20 Sep 2026 13:31:01 GMT</pubDate>
            <atom:updated>2026-09-20T13:31:01.521Z</atom:updated>
            <content:encoded><![CDATA[<h4>A detection that generates 1,000 alerts isn’t automatically better than one generating 10.</h4><p>Sometimes, it’s much worse.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KUB6ToEuWYEDwOJLopuOlQ.png" /></figure><p>When analysts repeatedly investigate alerts that turn out to be benign, something important starts happening:</p><p><strong>attention becomes the scarce resource.</strong></p><p>This is where false-positive fatigue becomes a detection-engineering problem — not just an analyst problem.</p><p>Imagine a rule generating 1,000 alerts:</p><ul><li>950 benign</li><li>50 potentially interesting</li></ul><p>The detection technically works.</p><p>But the signal is buried under noise.</p><p>That creates a dangerous feedback loop:</p><p><strong>More noise → less attention → slower investigation → greater chance of missing the real signal.</strong></p><p>This is why I don’t evaluate a detection purely by asking:</p><blockquote><em>“Did it fire?”</em></blockquote><p>I also ask:</p><blockquote><em>“Did it fire for the right reasons?”</em></blockquote><p>Tuning isn’t about making alert counts look smaller.</p><p>It’s about increasing the proportion of alerts that deserve an analyst’s attention.</p><p>Sometimes that means adding context.</p><p>Sometimes it’s exclusions.</p><p>Sometimes the better answer is changing the detection logic completely.</p><p><strong>A quiet detection isn’t necessarily a good detection.</strong></p><p>But a detection that consistently produces useful, actionable signal is much closer to one.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=296266c2decf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOC Investigation Diary #01 — Alert Triage in a 3-Alert Minute]]></title>
            <link>https://pratik0x.medium.com/soc-investigation-diary-01-alert-triage-in-a-3-alert-minute-777b8648bc23?source=rss-7134f1073431------2</link>
            <guid isPermaLink="false">https://medium.com/p/777b8648bc23</guid>
            <category><![CDATA[malware-analysis]]></category>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[security-operation-center]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[threat-intelligence]]></category>
            <dc:creator><![CDATA[Pratik Gurav]]></dc:creator>
            <pubDate>Sun, 20 Sep 2026 07:01:02 GMT</pubDate>
            <atom:updated>2026-09-20T07:01:02.325Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Prioritization frameworks when everything looks urgent.</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QdRAJMeA6QEskiL-NRv-Mg.png" /></figure><p>Three alerts arrive almost at the same time.</p><p>All three are marked <strong>high severity</strong>.</p><p>The easy mistake is to treat them equally.</p><p>The harder and more useful skill is deciding which one deserves attention first.</p><p>When I start triage, I don’t look at severity alone. I try to quickly answer four questions:</p><p><strong>1. What happened?</strong><br>What event actually triggered the alert?</p><p><strong>2. Who or what is involved?</strong><br>Which user, host, process, account, or application is affected?</p><p><strong>3. What happened before and after?</strong><br>A single event rarely tells the whole story. Parent processes, command lines, authentication activity, network connections, and subsequent actions can change the interpretation completely.</p><p><strong>4. What is the potential impact?</strong><br>A suspicious process on an isolated workstation is different from the same behavior on a privileged account or critical server.</p><p>This gives me a quick way to separate <strong>severity from priority</strong>.</p><p>A high-severity alert with little supporting evidence may need investigation.</p><p>A medium-severity alert showing a suspicious process chain followed by credential access may deserve attention first.</p><p>That’s where context becomes more valuable than the alert label.</p><p>I also try to form a small hypothesis instead of immediately searching through everything:</p><blockquote><strong><em>“What would I expect to see if this alert represents a real attack?”</em></strong></blockquote><p>Then I look for evidence that supports — or disproves — that hypothesis.</p><p>The goal of the first few minutes isn’t to solve the entire incident.</p><p>It’s to reduce uncertainty quickly enough to make the <strong>next correct decision</strong>.</p><h3>Takeaway</h3><p><strong>Good triage isn’t about investigating everything first. It’s about identifying what matters first.</strong></p><p>The better the prioritization, the more time the SOC gets back for actual investigation instead of alert queues.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=777b8648bc23" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Section Names That Scream: Recognizing Packer Artifacts]]></title>
            <link>https://pratik0x.medium.com/section-names-that-scream-recognizing-packer-artifacts-dbf789a2a214?source=rss-7134f1073431------2</link>
            <guid isPermaLink="false">https://medium.com/p/dbf789a2a214</guid>
            <category><![CDATA[reverse-engineering]]></category>
            <category><![CDATA[malware-analysis]]></category>
            <category><![CDATA[threat-intelligence]]></category>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Pratik Gurav]]></dc:creator>
            <pubDate>Sun, 20 Sep 2026 01:31:01 GMT</pubDate>
            <atom:updated>2026-09-20T01:31:01.384Z</atom:updated>
            <content:encoded><![CDATA[<p>When I look at PE sections, I don’t immediately ask:</p><p><strong>“Is this malware?”</strong></p><p>I ask:</p><p><strong>“Does this structure look normal for this binary?”</strong></p><p>Section names can provide an early clue.</p><p>Names such as .UPX0, .UPX1, .aspack, .adata, or unusual custom names can sometimes point toward packing or obfuscation. But the important word is <strong>sometimes</strong>.</p><p>A suspicious-looking section name isn’t proof of packing.</p><p>Attackers can rename sections. Legitimate software can use unusual names. Packers can modify much more than the section names themselves.</p><p>So I look at the combination:</p><p><strong>Section name + entropy + permissions + size + characteristics + entry point</strong></p><p>For example, an executable section with unusually high entropy and an entry point located inside an unexpected section gives me a much stronger reason to investigate packing than the section name alone.</p><p>This is one of the recurring lessons in static analysis:</p><p><strong>Individual indicators create questions. Multiple independent indicators create confidence.</strong></p><p>The section table isn’t just metadata.</p><p>It’s one of the first places where the structure of a PE starts telling me how I should investigate it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WhKQa-1m8PwSiYQCavGGGQ.png" /></figure><blockquote><strong><em>→ Building detection rules for these patterns? My GitHub has Sigma and YARA examples: </em></strong><a href="https://github.com/pratik0x"><strong><em>https://github.com/pratik0x</em></strong></a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dbf789a2a214" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[DIE vs. PE-Bear vs. PEStudio: Which Tool for Which Question?]]></title>
            <link>https://pratik0x.medium.com/die-vs-pe-bear-vs-pestudio-which-tool-for-which-question-5514867bdd7a?source=rss-7134f1073431------2</link>
            <guid isPermaLink="false">https://medium.com/p/5514867bdd7a</guid>
            <category><![CDATA[malware-analysis]]></category>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[reverse-engineering]]></category>
            <dc:creator><![CDATA[Pratik Gurav]]></dc:creator>
            <pubDate>Sat, 19 Sep 2026 01:31:01 GMT</pubDate>
            <atom:updated>2026-09-19T01:31:01.546Z</atom:updated>
            <content:encoded><![CDATA[<h4>Three static analysis tools dominate my workflow. Each answers a different question faster than the others.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ey6ulveoZs9_FaN8Fc-0zg.png" /></figure><p>DIE (Detect It Easy)<br>Best for: Entropy visualization, packer/compiler signature detection, quick section overview.<br>Why: Massive signature database, instant entropy graphs, minimal learning curve.</p><p>PE-Bear<br>Best for: Deep PE structure inspection, detailed import/export table analysis, resource browsing.<br>Why: More granular than DIE; better for understanding <em>why</em> a PE is structured oddly.</p><p>PEStudio<br>Best for: Indicator scoring, string analysis with threat context, VirusTotal integration.<br>Why: Built specifically for malware triage — flags suspicious imports, strings, and certificates automatically with risk scoring.</p><p>My Actual Workflow</p><ol><li>DIE first — 30 seconds, entropy + packer signature check</li><li>If structure is unusual → PE-Bear for granular inspection</li><li>If I need risk-scored indicators fast → PEStudio for automated flagging</li><li>If still uncertain → Move to dynamic analysis</li></ol><p>One tool rarely tells the whole story. Layering them in sequence saves hours of guessing.</p><blockquote><strong>→ Tool comparison matrix and integration scripts in my GitHub:</strong></blockquote><blockquote><a href="https://github.com/pratik0x"><strong>https://github.com/pratik0x</strong></a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5514867bdd7a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Malware Analysis Diary #04 — Code Signing and the Trust Paradox]]></title>
            <link>https://pratik0x.medium.com/malware-analysis-diary-04-code-signing-and-the-trust-paradox-d06ed0499015?source=rss-7134f1073431------2</link>
            <guid isPermaLink="false">https://medium.com/p/d06ed0499015</guid>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[malware-analysis]]></category>
            <category><![CDATA[reverse-engineering]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[infosec]]></category>
            <dc:creator><![CDATA[Pratik Gurav]]></dc:creator>
            <pubDate>Fri, 18 Sep 2026 17:31:01 GMT</pubDate>
            <atom:updated>2026-09-18T17:31:01.559Z</atom:updated>
            <content:encoded><![CDATA[<h4>A valid digital signature doesn’t mean clean code. It means someone paid for a certificate — and that’s a much lower bar than most people assume.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/798/1*A3RVQUcF0O7wHet6hGR7UQ.png" /></figure><p>Analysts often treat “digitally signed” as a green light. It shouldn’t be. Understanding how code signing actually works — and how it fails — changes how you triage samples.</p><p>How Code Signing Is Supposed to Work</p><p>A developer obtains a certificate from a trusted Certificate Authority (CA), signs their binary, and Windows verifies that signature against the CA’s trust chain. In theory, this proves authorship and integrity.</p><p>In practice, several failure modes exist.</p><p>Failure Mode 1: Stolen Certificates</p><p>Attackers steal legitimate signing certificates from compromised companies. The malware carries a completely valid signature — from a real, trusted vendor. Windows shows no warning. This is common in supply chain attacks and APT campaigns.</p><p>Failure Mode 2: Cheap or Abused CAs</p><p>Some CAs perform minimal identity verification. Attackers register shell companies, obtain certificates, sign malware, and let the cert get revoked days later — after the damage is done. By the time revocation propagates, initial infections have already succeeded.</p><p>Failure Mode 3: Expired or Self-Signed Certs</p><p>Some malware ships with self-signed or expired certificates specifically to exploit systems where certificate validation is misconfigured or ignored entirely.</p><p>What to Actually Check</p><ul><li>Certificate chain validity — Does it trace to a trusted root?</li><li>Issuer reputation — Well-known CA or an obscure one?</li><li>Signing timestamp vs. compile timestamp — Large gaps are suspicious</li><li>Revocation status — Has this cert been revoked since signing?</li><li>Subject name plausibility — Does the signer’s identity match the software’s claimed purpose?</li></ul><p>The Real Lesson</p><p>Signed doesn’t mean safe. It means traceable — if the certificate is legitimate and not stolen. Treat signature verification as one data point among many, not a final verdict.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d06ed0499015" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Timestamp Trap: Why Build Dates Lie]]></title>
            <link>https://pratik0x.medium.com/the-timestamp-trap-why-build-dates-lie-132612c48405?source=rss-7134f1073431------2</link>
            <guid isPermaLink="false">https://medium.com/p/132612c48405</guid>
            <category><![CDATA[reverse-engineering]]></category>
            <category><![CDATA[malware-analysis]]></category>
            <category><![CDATA[infosec]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[blue-team]]></category>
            <dc:creator><![CDATA[Pratik Gurav]]></dc:creator>
            <pubDate>Fri, 18 Sep 2026 12:33:17 GMT</pubDate>
            <atom:updated>2026-09-18T12:33:17.801Z</atom:updated>
            <content:encoded><![CDATA[<p>Timestamps are trivially spoofed. Every malware analyst knows this.</p><p>Yet we still look at them. Why? Because even fake timestamps tell stories.</p><p>A PE compiled on<strong> January 1, 1970?</strong> The timestamp didn’t fail by accident — the attacker deliberately set it. That’s OPSEC behavior, and it’s informative.</p><p>Similarly, a timestamp in <strong>2037 </strong>signals a different class of attacker: either careless, or using automated build pipelines that don’t sanitize timestamps.</p><p>The timestamp itself isn’t evidence. The <em>choice</em> to forge it — or the choice to leave it honest — reveals intent or infrastructure habits.</p><p>Legitimate software almost never has obviously fake timestamps. Malware families often do, clustering around specific dates (collective reuse of build environments, shared infrastructure).</p><p>Never trust the timestamp. But always note it.</p><p>It’s not about the date. It’s about the pattern the date reveals.</p><p><em>Lab observation. No samples, payloads, or operational details included.</em></p><blockquote>→ Timestamp clustering and malware family fingerprinting in my GitHub: <a href="https://github.com/pratik0x">https://github.com/pratik0x</a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=132612c48405" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>