<?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 Jinay on Medium]]></title>
        <description><![CDATA[Stories by Jinay on Medium]]></description>
        <link>https://medium.com/@jynxora?source=rss-8bf272601c2c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*isb4zpYhgKT7N4dIyrboYQ.jpeg</url>
            <title>Stories by Jinay on Medium</title>
            <link>https://medium.com/@jynxora?source=rss-8bf272601c2c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 13:00:28 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jynxora/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[Day 180 — WipeTrace: Anti-Forensic Disk Wiping Detection Through Block-Level Analysis]]></title>
            <link>https://systemweakness.com/day-180-wipetrace-anti-forensic-disk-wiping-detection-through-block-level-analysis-169a9686ac59?source=rss-8bf272601c2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/169a9686ac59</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[digital-forensic-tools]]></category>
            <category><![CDATA[700daysofskill]]></category>
            <category><![CDATA[digital-forensics]]></category>
            <category><![CDATA[anti-forensics]]></category>
            <dc:creator><![CDATA[Jinay]]></dc:creator>
            <pubDate>Tue, 10 Mar 2026 17:55:09 GMT</pubDate>
            <atom:updated>2026-03-12T10:38:47.791Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ij3OTn8zjcSEnl8oT_pyVA.png" /></figure><h3>Introduction</h3><p>One of the most common anti-forensic actions taken before device seizure is disk wiping.</p><p>When a drive is overwritten, the original data may be permanently destroyed. However, the process of wiping itself often leaves detectable patterns in the raw storage medium.</p><p>The goal of <strong>WipeTrace</strong> is not data recovery.<br> Instead, the tool focuses on detecting <strong>evidence that wiping occurred</strong>, identifying the likely wipe method, and presenting that evidence in a structured forensic report.</p><p>This article explains the architecture and detection strategy behind WipeTrace.</p><h3>The Core Idea</h3><p>Different wipe strategies leave distinct byte-level signatures.</p><p>For example:</p><p>Zero-fill wipe — majority 0x00, extremely low entropy<br>0xFF overwrite — majority 0xFF, extremely low entropy<br>Random overwrite — entropy near 8 bits per byte<br>Multi-pass wipe — alternating patterns of fills and random data<br>Partial wipe — mixed fill bytes with scattered entropy</p><p>By analyzing disk images <strong>block by block</strong>, it becomes possible to detect these patterns.</p><h3>System Architecture</h3><p>WipeTrace follows a multi-stage scanning pipeline:</p><ol><li><strong>Hashing</strong></li></ol><ul><li>SHA-256 computed for the full disk image</li></ul><p>2. <strong>Partition Map Parsing</strong></p><ul><li>MBR / GPT structures extracted</li><li>identifies actual used disk regions</li></ul><p>3. <strong>Block Classification</strong></p><ul><li>image streamed in 512-byte blocks</li><li>rule-based classifier assigns wipe categories</li></ul><p>4. <strong>Machine Learning Validation</strong></p><ul><li>ML ensemble reduces false positives from compressed or encrypted data</li></ul><p>5. <strong>Region Aggregation</strong></p><ul><li>suspicious blocks merged into wipe regions</li></ul><p>6.<strong> Intent Scoring</strong></p><ul><li>a 0–100 forensic score representing likelihood of deliberate wiping</li></ul><p>7. <strong>Report Generation</strong></p><ul><li>structured JSON + investigator report</li></ul><h3>Detection Engine</h3><p>The rule-based classifier uses entropy analysis and byte distribution metrics.</p><p>Some examples:</p><blockquote>90% 0x00 → ZERO_WIPE</blockquote><blockquote>90% 0xFF → FF_WIPE</blockquote><blockquote>entropy ≥7.6 → RANDOM_WIPE</blockquote><blockquote>structured mid-entropy → LOW_ENTROPY_SUSPECT</blockquote><p>The system currently uses <strong>7 classification categories</strong>.</p><h3>Machine Learning Layer</h3><p>A four-model ensemble is used to distinguish legitimate high-entropy data from wipe patterns.</p><p>Models used:</p><ul><li>RandomForest</li><li>ExtraTrees</li><li>GradientBoosting</li><li>IsolationForest</li></ul><p>The feature space includes:</p><ul><li>byte distribution statistics</li><li>entropy variation across sub-blocks</li><li>bigram transition entropy</li><li>spectral analysis</li><li>run-length statistics</li></ul><p>The model was trained on roughly <strong>15,000 synthetic samples</strong>.</p><h3>Reducing False Positives</h3><p>High-entropy data such as encrypted volumes or compressed archives can resemble wipe patterns.</p><p>To mitigate this:</p><ul><li>partition boundary analysis prevents misclassification of unwritten disk space</li><li>aggregation filters remove isolated noisy blocks</li><li>ML validation reduces misclassification of legitimate high-entropy data</li></ul><p>Testing shows:</p><ul><li>typical false positives under <strong>5%</strong></li><li>worst cases under <strong>15%</strong></li><li>deterministic wipe patterns detected with <strong>0% false positives</strong></li></ul><h3>Chain of Custody</h3><p>Every stage of the analysis process generates a cryptographically linked log entry.</p><p>Each entry includes:</p><ul><li>event type</li><li>timestamp</li><li>SHA-256 evidence hash</li><li>previous hash reference</li></ul><p>This creates a <strong>tamper-evident chain of custody log</strong>.</p><h3>Limitations</h3><p>Like any forensic tool, WipeTrace has constraints.</p><p>For example:</p><ul><li>SSD TRIM operations may produce patterns similar to zero-fill wipes</li><li>full-disk wipes before any data was written cannot be distinguished from unused drives</li></ul><p>Because of this, results should always be interpreted alongside other forensic evidence.</p><h3>Conclusion</h3><p>WipeTrace started as a hackathon prototype but gradually evolved into a more robust forensic analysis tool.</p><p>The project explores how a combination of:</p><ul><li>rule-based detection</li><li>statistical analysis</li><li>machine learning</li><li>forensic workflow design</li></ul><p>can be used to detect anti-forensic disk wiping.</p><p>The full project is available on GitHub:</p><blockquote><a href="https://github.com/jynxora/wipetrace"><strong>https://github.com/jynxora/wipetrace</strong></a></blockquote><p>#700DaysOfSkill</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=169a9686ac59" width="1" height="1" alt=""><hr><p><a href="https://systemweakness.com/day-180-wipetrace-anti-forensic-disk-wiping-detection-through-block-level-analysis-169a9686ac59">Day 180 — WipeTrace: Anti-Forensic Disk Wiping Detection Through Block-Level Analysis</a> was originally published in <a href="https://systemweakness.com/">System Weakness</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 174 — Building a Data Wiping Detection Engine in 24 Hours (ISEA Hackathon)]]></title>
            <link>https://meetcyber.net/day-174-building-a-data-wiping-detection-engine-in-24-hours-isea-hackathon-8274c231a6ff?source=rss-8bf272601c2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/8274c231a6ff</guid>
            <category><![CDATA[data-forensics]]></category>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[digital-forensics]]></category>
            <category><![CDATA[detection]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Jinay]]></dc:creator>
            <pubDate>Sun, 01 Mar 2026 18:54:11 GMT</pubDate>
            <atom:updated>2026-03-02T10:53:21.379Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2V5i3C6Pr2W3zS9qfVf7cQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ugH168zL0NvnZ5YUwKWX1Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*keQ_0XDEoThxLSkJwkwXLQ.png" /><figcaption>Detection Engine Dashboard</figcaption></figure><p>This weekend, I participated in a 24-hour ISEA Anti-Forensic Detection Hackathon.</p><p>We didn’t place.</p><p>But we built a working forensic prototype that detects intentional data wiping at the raw disk-image level.</p><p>This is a breakdown of what we built, what worked, and what didn’t.</p><h3>The Problem</h3><p>When attackers attempt to destroy evidence, they often:</p><ul><li>Overwrite sectors with 0x00</li><li>Overwrite with 0xFF</li><li>Use high-entropy random data</li><li>Perform multi-pass overwrite patterns</li></ul><p>Standard forensic analysis shows large regions of “empty” or “free” space.</p><p>But free space and wiped space are not the same.</p><p>We wanted to detect:<br> <strong>Evidence of intentional overwrite behavior.</strong></p><h3>Architecture Overview</h3><p>The system pipeline:</p><ol><li>Disk image uploaded</li><li>Hash computed (integrity assurance)</li><li>Raw stream reader processes image in 4KB blocks</li><li>Each block classified:</li></ol><ul><li>ZERO</li><li>FF</li><li>RANDOM (entropy threshold)</li><li>MULTI (pattern-based detection)</li><li>NORMAL</li></ul><p>5. Consecutive suspicious blocks aggregated into regions</p><p>6. Intent score calculated</p><p>7. JSON output generated</p><p>8. Dashboard visualizes suspicious regions</p><p>All logic is deterministic.</p><p>No ML.<br>No black-box scoring.<br>Every decision is explainable.</p><h3>Technical Core</h3><h3>Block Classification</h3><p>Entropy-based detection for RANDOM blocks<br> Byte-frequency analysis for pattern detection<br> Threshold tuning to avoid flagging legitimate compressed regions</p><h3>Region Aggregation</h3><p>Instead of treating blocks independently, we merged contiguous suspicious blocks.</p><p>This reduced noise significantly and made intent scoring meaningful.</p><h3>Intent Scoring</h3><p>Score based on:</p><ul><li>Block continuity</li><li>Entropy profile</li><li>Pattern type</li><li>Region size</li></ul><p>Filtered small accidental anomalies.</p><h3>What Worked</h3><ul><li>Modular engine design under 24-hour constraint</li><li>Streaming model avoided memory overload</li><li>Region merging drastically improved clarity</li><li>Dashboard clearly visualized wipe behavior</li></ul><h3>What Didn’t</h3><ul><li>No large-scale wipe dataset for benchmarking</li><li>No correlation with filesystem metadata (future improvement)</li><li>Performance not optimized for multi-GB enterprise images yet</li></ul><h3>Key Insight</h3><p>Attackers can delete files.</p><p>But they cannot easily hide overwrite patterns without cost.</p><p>Detection should focus on behavior at the physical layer — not just file metadata.</p><p>This hackathon reinforced something simple:</p><p>Anti-forensics leaves artifacts too.</p><p>Day 174 of 700.<br>We didn’t win.<br>But we built something real.</p><p><strong>GitHub Link to Detection Engine Tool:</strong></p><blockquote><a href="https://github.com/jynxora/ISEA_Hackathon_Anti-Forensic_Trace_Cleaner_Detection">https://github.com/jynxora/ISEA_Hackathon_Anti-Forensic_Trace_Cleaner_Detection</a></blockquote><blockquote><strong>#700DaysOfSkill</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8274c231a6ff" width="1" height="1" alt=""><hr><p><a href="https://meetcyber.net/day-174-building-a-data-wiping-detection-engine-in-24-hours-isea-hackathon-8274c231a6ff">Day 174 — Building a Data Wiping Detection Engine in 24 Hours (ISEA Hackathon)</a> was originally published in <a href="https://meetcyber.net/">MeetCyber</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 161 — Building a Reliable Windows Process Monitoring Layer]]></title>
            <link>https://meetcyber.net/day-161-building-a-reliable-windows-process-monitoring-layer-b36e5fdbb489?source=rss-8bf272601c2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/b36e5fdbb489</guid>
            <category><![CDATA[documentation]]></category>
            <category><![CDATA[ransomware]]></category>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[windows]]></category>
            <dc:creator><![CDATA[Jinay]]></dc:creator>
            <pubDate>Tue, 20 Jan 2026 20:46:21 GMT</pubDate>
            <atom:updated>2026-01-21T17:27:26.741Z</atom:updated>
            <content:encoded><![CDATA[<h3>Day 161 — Building a Reliable Windows Process Monitoring Layer</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G1S1rJCFh0GbHZrmSAxgLg.png" /></figure><p>Most security projects rush into <strong>detection logic</strong>.</p><p>Rules. Scores. Alerts.<br> All built on top of telemetry that hasn’t been questioned, stressed, or validated.</p><p>This post documents the <strong>opposite approach</strong>.</p><p>As part of my Semester 2 minor project on <strong>human-operated ransomware</strong>, I started with a single question:</p><blockquote>Can I trust the process creation data I’m about to build everything on?</blockquote><p>Before thinking about detection, correlation, or ransomware behavior, I implemented and <strong>stress-tested a foundational Windows process monitoring module</strong>.</p><h3>Why Process Creation Matters (in Human-Operated Ransomware)</h3><p>Human-operated ransomware (Ryuk / Conti / similar) is not a single malware execution.</p><p>It’s a <strong>sequence of operator-driven actions</strong>:</p><ul><li>reconnaissance</li><li>privilege escalation</li><li>lateral movement</li><li>tooling deployment</li><li>defense evasion</li><li>and only then encryption</li></ul><p>Process creation telemetry sits at the center of this:</p><ul><li>cmd.exe, powershell.exe, wmic.exe</li><li>admin tools launched interactively</li><li>payload staging via LOLBins</li><li>unusual parent–child relationships</li></ul><p>If this layer is unreliable, everything built above it collapses.</p><h3>Design Goals of process_monitor.py</h3><p>The module was intentionally designed to be <strong>boring and correct</strong>, not clever.</p><h3>Goals:</h3><ul><li>Real-time process creation visibility</li><li>Event-driven (not polling-based)</li><li>Minimal assumptions</li><li>Structured, machine-readable output</li><li>Stable under long runtime</li><li>Graceful failure handling</li></ul><h3>Non-goals (at this stage):</h3><ul><li>No detection logic</li><li>No alerts</li><li>No scoring</li><li>No threat labels</li></ul><p>This is <strong>telemetry</strong>, not intelligence.</p><h3>How the Module Works (High-Level)</h3><ul><li>Uses <strong>WMI event notifications</strong> (Win32_ProcessStartTrace)</li><li>Listens for process creation events in real time</li><li>Captures structured fields:</li></ul><ol><li>timestamp</li><li>process name</li><li>PID</li><li>parent PID</li><li>command line</li><li>executable path</li><li>user context (when available)</li></ol><ul><li>Logs each event in <strong>JSON Lines (JSONL)</strong> format</li><li>Designed to be modular and extensible</li></ul><p>The choice of WMI was deliberate:</p><ul><li>event-driven</li><li>low overhead</li><li>native to Windows</li><li>commonly available in enterprise environments</li></ul><h3>Why Stress &amp; Reliability Testing Came Before Features</h3><p>It’s easy to write a script that works for 10 minutes.</p><p>It’s harder to answer:</p><ul><li>What happens after hours?</li><li>What happens under load?</li><li>What happens when WMI misbehaves?</li><li>What happens with reduced privileges?</li><li>What happens if logs are tampered with?</li><li>What happens during heavy disk I/O?</li></ul><p>So instead of adding features, I spent time <strong>trying to break the module</strong>.</p><h3>Stress &amp; Validation Scenarios Tested</h3><p>The validation phase deliberately avoided “happy paths”.</p><p>Tests included:</p><ul><li>Normal user application launches</li><li>Burst process creation (rapid spawns)</li><li>PowerShell execution variants</li><li>Long-running sustained monitoring</li><li>WMI service interruption and recovery</li><li>Execution under reduced privileges</li><li>Log file deletion / corruption attempts</li><li>Heavy disk I/O during active monitoring</li></ul><p>Each test was documented with:</p><ul><li>description</li><li>expected behavior</li><li>observed behavior</li><li>rationale</li></ul><h3>Key Observations</h3><ul><li>The module remained stable under prolonged execution</li><li>No crashes, deadlocks, or silent failures observed</li><li>Process events were consistently captured</li><li>Graceful degradation when permissions were limited</li><li>Clean recovery from WMI instability</li><li>Logging remained consistent under disk stress</li></ul><p>Just as important:</p><ul><li>the limits of userland visibility became clearer</li><li>assumptions that <em>don’t</em> hold in real environments were identified early</li></ul><p>This is exactly why this phase exists.</p><h3>Why This Matters for Anti-Ransomware Work</h3><p>Ransomware detection often fails because:</p><ul><li>signals are noisy</li><li>telemetry is incomplete</li><li>foundations are assumed, not validated</li></ul><p>By validating the <strong>data layer first</strong>, later stages can focus on:</p><ul><li>behavioral correlation</li><li>timeline reconstruction</li><li>pre-encryption warning signs</li><li>human-in-the-loop decision points</li></ul><p>Not magic.<br>Not prevention fantasies.<br>Just solid ground.</p><h3>Code &amp; Validation Artifacts</h3><ul><li><strong>Process Monitoring Module (Python):</strong><br><a href="https://github.com/jynxora/Human-Operated-Ransomware-Minor-Project/blob/main/Modules/process_monitor.py"> <em>GitHub link to </em></a><a href="https://github.com/jynxora/Human-Operated-Ransomware-Minor-Project/blob/main/Modules/process_monitor.py"><em>process_monitor.py</em></a></li><li><strong>Reliability &amp; Stress Validation Report (PDF):</strong><br> <a href="https://github.com/jynxora/Human-Operated-Ransomware-Minor-Project/blob/main/Research/Reliability%20and%20Stress%20Validation%20of%20process_monitor.py.pdf"><em>GitHub link to Stress validation and Reliability tests (PDF)</em></a></li></ul><p>Both are shared as <strong>ongoing project artifacts</strong>, not finished products.</p><h3>What’s Next</h3><ul><li>Baseline profiling of normal process behavior</li><li>Parent–child relationship modeling</li><li>Correlation with other telemetry sources</li><li>Mapping observed behaviors to pre-ransom attack stages</li></ul><p>But only because the foundation has been tested first.</p><p>This project is intentionally slow, deliberate, and constraint-aware.</p><p>Detection comes later.<br>Correctness comes first.</p><blockquote><strong>#700DaysOfSkill</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b36e5fdbb489" width="1" height="1" alt=""><hr><p><a href="https://meetcyber.net/day-161-building-a-reliable-windows-process-monitoring-layer-b36e5fdbb489">Day 161 — Building a Reliable Windows Process Monitoring Layer</a> was originally published in <a href="https://meetcyber.net/">MeetCyber</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 158 — Detecting Human-Operated Ransomware Before Encryption: Scope, Constraints, and…]]></title>
            <link>https://medium.com/@jynxora/day-158-detecting-human-operated-ransomware-before-encryption-scope-constraints-and-c07304d12157?source=rss-8bf272601c2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/c07304d12157</guid>
            <category><![CDATA[academia]]></category>
            <category><![CDATA[research]]></category>
            <category><![CDATA[ransomware]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[dfir]]></category>
            <dc:creator><![CDATA[Jinay]]></dc:creator>
            <pubDate>Sat, 17 Jan 2026 18:45:29 GMT</pubDate>
            <atom:updated>2026-01-17T18:45:29.448Z</atom:updated>
            <content:encoded><![CDATA[<h3>Day 158 — Detecting Human-Operated Ransomware <em>Before</em> Encryption: Scope, Constraints, and Feasibility</h3><p>Most ransomware discussions still revolve around malware samples, payloads, and signatures.</p><p>Human-Operated Ransomware doesn’t work that way.</p><p>Ryuk, Conti, BlackMatter-style attacks are <strong>hands-on-keyboard operations</strong> with long dwell times, deliberate reconnaissance, credential harvesting, lateral movement, and backup sabotage — often <strong>weeks before encryption</strong>.</p><p>That dwell time is the only real opportunity defenders get.</p><p>This article (and the attached research document) is not about building a finished product. It is about answering harder questions first:</p><ul><li>What attacker behaviors reliably appear <em>before</em> encryption?</li><li>What telemetry is realistically accessible from Windows <strong>userland</strong>?</li><li>What detection ideas sound good on paper but collapse under real constraints?</li><li>Where should a semester-scale project draw hard boundaries instead of pretending to be an EDR?</li></ul><p>The document covers:</p><ul><li>A structured threat model for Human-Operated Ransomware</li><li>Clear IN-SCOPE vs OUT-OF-SCOPE definitions</li><li>Detection goals vs attacker goals</li><li>Userland limitations (polling delays, protected processes, audit dependencies)</li><li>Feasible vs partially feasible vs impossible detections</li><li>A tiered detection philosophy focused on <em>early warning</em>, not prevention</li></ul><p>No automation claims.<br>No AI buzzwords.<br>No “stop ransomware forever” nonsense.</p><p>Just technical reality, documented before code is written.</p><p>The full research PDF and ongoing notes are available here:<br> 🔗 <a href="https://github.com/jynxora/Human-Operated-Ransomware-Minor-Project/blob/main/Research/Threat_Model_for_Human-Operated_Ransomware_Scope_Assumptions_and_Design_Implications.pdf">GitHub repo link to PDF</a></p><p>This repository will continue evolving as the project moves from research → design → controlled prototyping.</p><blockquote><strong>#700DaysOfSkill</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c07304d12157" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 154 — Why Ransomware Is Usually Detected Too Late?]]></title>
            <link>https://medium.com/@jynxora/day-154-why-ransomware-is-usually-detected-too-late-2111bfbbd312?source=rss-8bf272601c2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/2111bfbbd312</guid>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[malware]]></category>
            <category><![CDATA[ransomware]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[research]]></category>
            <dc:creator><![CDATA[Jinay]]></dc:creator>
            <pubDate>Fri, 09 Jan 2026 19:46:11 GMT</pubDate>
            <atom:updated>2026-01-09T19:46:11.209Z</atom:updated>
            <content:encoded><![CDATA[<h3>Day 154 — Why Ransomware Is Usually Detected Too Late?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/942/1*hH55h34_e2ynrQKItcfg3w.png" /><figcaption>Command prompt dump output of the Alternate Data Stream</figcaption></figure><p><strong><em>Ransomware is rarely a surprise.</em></strong></p><p>Encryption feels sudden, but the attack almost never is.</p><p>By the time files are locked or data is leaked, the attacker has usually:</p><ul><li>entered the network hours, days, or weeks earlier</li><li>explored systems quietly</li><li>harvested credentials</li><li>tested lateral movement paths</li><li>disabled or bypassed defenses</li><li>and verified that monetization is viable</li></ul><p>This write-up focuses on <strong>what happens before the ransom note appears</strong>.</p><h3>Commodity Malware vs Human-Operated Ransomware</h3><p>Most people still picture ransomware as:</p><blockquote><em>phishing email → malware executes → files encrypted → ransom demanded</em></blockquote><p>That model fits <strong>commodity ransomware</strong>.</p><p>Human-operated ransomware works differently.</p><p>In these campaigns, attackers:</p><ul><li>manually access systems (often via exposed RDP)</li><li>adapt in real time</li><li>use legitimate admin tools</li><li>disengage if conditions aren’t favorable</li><li>and return later when the environment is weaker</li></ul><p>The ransomware payload is often the <em>last</em> thing deployed.</p><h3>The Pre-Ransom Attack Chain</h3><p>Across campaigns like <strong>Wadhrama (PARINACOTA), DoppelPaymer, Ryuk</strong>, the same stages appear repeatedly:</p><ol><li><strong>Initial Access</strong><br>RDP brute force, phishing, exposed services, weak configurations</li><li><strong>Reconnaissance</strong><br>Network scanning, AD enumeration, system profiling</li><li><strong>Credential Theft</strong><br>LSASS dumping, service account abuse, plaintext secrets</li><li><strong>Lateral Movement</strong><br>PsExec, WMI, Cobalt Strike, native admin tooling</li><li><strong>Persistence &amp; Defense Evasion</strong><br>New accounts, registry run keys, disabled security tools, cleared logs</li></ol><p>Only <em>after</em> these stages succeed does encryption or extortion begin.</p><h3>Why Detection Fails</h3><p>Most of these actions:</p><ul><li>trigger alerts that are treated as “noise”</li><li>look like administrative activity</li><li>occur over long time windows</li><li>don’t cause immediate damage</li></ul><p>As a result, organizations often:</p><ul><li>see the signals</li><li>but don’t connect them into a single attack narrative</li></ul><p>By the time ransomware is deployed, response options are limited and disruptive.</p><h3>What This Research Is (and Isn’t)</h3><p>This document is:</p><ul><li>background research</li><li>attack-chain mapping</li><li>tradecraft analysis</li><li>pattern recognition</li></ul><p>It is <strong>not</strong>:</p><ul><li>a detection engine</li><li>a finished defensive product</li><li>a policy recommendation</li></ul><p>Those come later — <em>after</em> the problem is understood properly.</p><h3>Full Research Notes</h3><p>The complete background research, references, and campaign breakdowns are available here:</p><h4>PDF on GitHub:</h4><p><a href="https://github.com/jynxora/Human-Operated-Ransomware-Minor-Project/blob/main/Research/Human-Operated-Ransomware.pdf">https://github.com/jynxora/Human-Operated-Ransomware-Minor-Project/blob/main/Research/Human-Operated-Ransomware.pdf</a></p><p>This repository will evolve as the project moves from research → modeling → implementation.</p><p>If you’re interested in <strong>why ransomware succeeds before encryption ever runs</strong>, the PDF contains the actual substance.</p><blockquote><strong>#700DaysOfSkill</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2111bfbbd312" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 151 — Behemoth OverTheWire Series [Levels 0-8] Walkthrough]]></title>
            <link>https://meetcyber.net/day-151-behemoth-overthewire-series-levels-0-8-walkthrough-ba0cb63d950b?source=rss-8bf272601c2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba0cb63d950b</guid>
            <category><![CDATA[binary-exploitation]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ctf]]></category>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[ctf-writeup]]></category>
            <dc:creator><![CDATA[Jinay]]></dc:creator>
            <pubDate>Fri, 02 Jan 2026 12:36:48 GMT</pubDate>
            <atom:updated>2026-01-02T15:28:42.407Z</atom:updated>
            <content:encoded><![CDATA[<h3>Day 151 — Behemoth OverTheWire Series [Levels 0-8] Walkthrough</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gBlvLaOTJj8XllROpK_Jnw.png" /></figure><blockquote><strong>Behemoth Completed: What Exploitation Really Feels Like</strong></blockquote><p>Behemoth is done.<br>Not “finished quickly.”<br>Not “followed a walkthrough.”<br>Done — after sitting inside uncomfortable problems long enough for the mechanics to stick.</p><p>This post is not a step-by-step exploit guide.<br>The full details live in the linked PDF and Markdown write-ups.</p><p>What this post explains is <strong>what the Behemoth series actually teaches</strong>, if you don’t rush it.</p><h3>Why Behemoth Is Different</h3><p>Behemoth removes comfort early.</p><p>There are no friendly banners.<br>No helpful prompts.<br>In fact, no level descriptions at all.</p><p>You are expected to:</p><ul><li>observe binary behavior</li><li>infer memory layout</li><li>reason about stack behavior</li><li>and accept that most attempts will fail before anything works</li></ul><p>This is deliberate.</p><h3>The Progression That Matters</h3><p>The early levels train <em>recognition</em>:</p><ul><li>plaintext comparisons</li><li>obvious buffer overflows</li><li>unsafe environment trust</li></ul><p>Mid-levels train <em>control</em>:</p><ul><li>%n format string writes</li><li>GOT overwrites</li><li>signal timing and filesystem races</li></ul><p>Late levels train <em>ownership</em>:</p><ul><li>shellcode execution gated by program logic</li><li>exploitation that only works outside debuggers</li><li>full responsibility for return addresses and offsets</li></ul><p>Level 7 is where excuses end.</p><h3>The Final Lesson (Level 7)</h3><p>Level 7 is a classic stack overflow — but stripped of hand-holding.</p><p>You must:</p><ul><li>calculate the exact overwrite offset</li><li>understand where EIP is controlled</li><li>place a NOP sled intentionally</li><li>select a return address that lands reliably</li><li>and execute it <strong>without debugging assistance</strong></li></ul><p>If you rely on tools without understanding, you stall.<br>If you understand but rush, you crash.<br>If you stay long enough, it works.</p><p>That is the real lesson.</p><h3>Why the Write-ups Exist</h3><p>Every level includes:</p><ul><li>what was attempted</li><li>what failed</li><li>what assumptions were wrong</li><li>what finally mattered</li><li>and why the exploit worked</li></ul><p>The goal isn’t proof of success.<br>It’s <strong>transferable reasoning</strong>.</p><h4>PDF write-up (final level 7):</h4><p><a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-7/Behemoth_Level-7.pdf">https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-7/Behemoth_Level-7.pdf</a></p><h4>Markdown write-up (final level 7):</h4><p><a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-7/Behemoth_level-7.md">https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-7/Behemoth_level-7.md</a></p><h4>Complete Behemoth series index:</h4><p><a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/tree/main">https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/tree/main</a></p><p>If you’re learning exploitation and feel “slow” — this is what slow progress actually looks like when it’s real.</p><blockquote><strong>#700DaysOfSkill </strong>#binaryexploitation #cybersecurity #overthewire</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba0cb63d950b" width="1" height="1" alt=""><hr><p><a href="https://meetcyber.net/day-151-behemoth-overthewire-series-levels-0-8-walkthrough-ba0cb63d950b">Day 151 — Behemoth OverTheWire Series [Levels 0-8] Walkthrough</a> was originally published in <a href="https://meetcyber.net/">MeetCyber</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 150 — Behemoth Level-6 OverTheWire Walkthrough]]></title>
            <link>https://meetcyber.net/day-150-behemoth-level-6-overthewire-walkthrough-844dcbb1ac55?source=rss-8bf272601c2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/844dcbb1ac55</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[binary-exploitation]]></category>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[ctf-writeup]]></category>
            <category><![CDATA[ctf]]></category>
            <dc:creator><![CDATA[Jinay]]></dc:creator>
            <pubDate>Thu, 01 Jan 2026 17:24:51 GMT</pubDate>
            <atom:updated>2026-01-01T19:20:35.414Z</atom:updated>
            <content:encoded><![CDATA[<h3>Day 150 — Behemoth Level-6 OverTheWire Walkthrough</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xbda61K3XNQMMpvWU1pvuQ.png" /></figure><p><strong><em>Behemoth Level-6: When Output Matters More Than Exploits…</em></strong></p><p>Most people approach exploitation expecting memory corruption.<br> Behemoth Level-6 breaks that expectation deliberately.</p><p>There is no overflow here.<br> No race condition.<br> No return address to hijack.</p><p>Instead, the program asks a simple question:</p><blockquote>Does the output start with “HelloKitty”?</blockquote><p>If yes — a privileged shell is spawned.</p><p>If not — nothing happens.</p><h3>What’s Actually Vulnerable?</h3><p>The vulnerability lies in <strong>logic</strong>, not memory.</p><ul><li>behemoth6 executes behemoth6_reader</li><li>the reader executes attacker-supplied shellcode from shellcode.txt</li><li>the parent process compares <strong>only the first 10 bytes</strong> of output</li><li>any mismatch fails silently</li></ul><p>This means:</p><ul><li>arbitrary code execution is allowed</li><li>but <strong>only behaviorally correct code wins</strong></li></ul><h3>Why Tool-Generated Shellcode Failed</h3><p>Shellcode generated locally <em>looked correct</em>.<br> It executed without errors.<br> But it didn’t work.</p><p>Why?</p><p>Because shellcode is <strong>environment-sensitive</strong>.</p><p>Register state, syscall behavior, and execution context differ between:</p><ul><li>your local VM</li><li>and the Behemoth server</li></ul><p>The fix wasn’t “better shellcode”.<br> It was <strong>building shellcode in the environment where it runs</strong>.</p><pre>pwn shellcraft i386.linux.echo HelloKitty &gt; shellcode.txt</pre><p>That single decision unlocked the level.</p><h3>The Real Lesson</h3><p>Behemoth Level-6 teaches something subtle but important:</p><blockquote><em>Exploitation is not about shells.<br> It’s about satisfying program logic under constraints.</em></blockquote><p>This level rewards:</p><ul><li>reading code carefully</li><li>understanding comparisons</li><li>respecting execution context</li><li>and knowing when tools help vs when they hide understanding</li></ul><h3>Write-ups &amp; Resources</h3><h4>PDF write-up:</h4><p><a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-6/Behemoth_Level-6.pdf">https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-6/Behemoth_Level-6.pdf</a></p><h4>Markdown version:</h4><p><a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-6/Behemoth_Level-6.MD">https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-6/Behemoth_Level-6.MD</a></p><h4>Complete Behemoth series:</h4><p><a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/README.md">https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/README.md</a></p><p>If you’re learning binary exploitation, don’t skip logic bugs.<br>They’re quieter — and often deadlier.</p><blockquote><strong>#700DaysOfSkill</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=844dcbb1ac55" width="1" height="1" alt=""><hr><p><a href="https://meetcyber.net/day-150-behemoth-level-6-overthewire-walkthrough-844dcbb1ac55">Day 150 — Behemoth Level-6 OverTheWire Walkthrough</a> was originally published in <a href="https://meetcyber.net/">MeetCyber</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 148 — Behemoth Level-5 OverTheWire Walkthrough]]></title>
            <link>https://meetcyber.net/day-148-behemoth-level-5-overthewire-walkthrough-95706ff3b2e1?source=rss-8bf272601c2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/95706ff3b2e1</guid>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[ctf-writeup]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ctf]]></category>
            <dc:creator><![CDATA[Jinay]]></dc:creator>
            <pubDate>Tue, 30 Dec 2025 17:06:35 GMT</pubDate>
            <atom:updated>2025-12-30T21:40:19.039Z</atom:updated>
            <content:encoded><![CDATA[<h3>Day 148 — Behemoth Level-5 OverTheWire Walkthrough</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*CVaKe67XHwlzLQEeLhtQkg.png" /></figure><p><strong><em>Behemoth Level-5: The Password Was Protected — Until the Program Leaked It Itself</em></strong></p><p>Behemoth Level-5 is uncomfortable in a very specific way.</p><p>There is <strong>no vulnerability you “trigger”</strong>.<br> No buffer you overflow.<br> No file permission you bypass.</p><p>The binary does everything <em>correctly</em> — and still hands you the password.</p><p>That’s what makes this level important.</p><h3>The Setup: Privilege Is Not the Problem</h3><p>At first glance, Behemoth Level-5 looks locked down properly.</p><p>The binary:</p><ul><li>runs with elevated privileges</li><li>opens /etc/behemoth_pass/behemoth6</li><li>reads the password successfully</li></ul><p>There’s no path traversal.<br> No symlink abuse.<br> No TOCTOU race like Level-4.</p><p>If your mental model of exploitation stops at <em>“how do I read the file?”</em>, this level feels like a dead end.</p><p>But that’s the trap.</p><h3>The Real Question: Where Does the Data Go Next?</h3><p>Instead of asking <em>how</em> the file is accessed, this level forces a better question:</p><blockquote><strong><em>What happens to the data after it’s read?</em></strong></blockquote><p>Stepping through the binary in GDB makes this clear very quickly.</p><p>After file I/O completes, execution flows into a completely different subsystem:</p><ul><li>hostname resolution (gethostbyname)</li><li>socket creation (socket)</li><li>port conversion (htons)</li><li>data transmission (sendto)</li></ul><p>This isn’t logging.<br> This isn’t debugging output.</p><p>It’s <strong>intentional network transmission</strong>.</p><h3>A Dangerous Assumption: “It’s Only Localhost”</h3><p>The binary resolves localhost and sends the password over a TCP socket.</p><p>The implicit assumptions are obvious:</p><ul><li>“It’s only loopback traffic”</li><li>“No one else will be listening”</li><li>“Local == safe”</li></ul><p>None of those are security guarantees.</p><p>From an attacker’s perspective, this is ideal:</p><ul><li>no timing constraints</li><li>no race conditions</li><li>no need to interfere with execution</li></ul><p>The binary leaks the secret on its own.</p><h3>Exploitation Without Interference</h3><p>The exploit doesn’t modify state.<br> It doesn’t corrupt memory.<br> It doesn’t race the filesystem.</p><p>It simply <strong>listens</strong>.</p><p>By binding to the target port before execution, the attacker passively receives the password as soon as the binary runs.</p><p>This is a pure <strong>logic-level information disclosure</strong>:</p><blockquote><em>A privileged operation followed by an unprotected side effect.</em></blockquote><p>And those are some of the hardest bugs to reason about — because nothing “breaks”.</p><h3>Why This Level Matters More Than It Looks</h3><p>Behemoth Level-5 mirrors real-world failures closely:</p><ul><li>internal services exposing secrets on localhost</li><li>debug backchannels left enabled</li><li>“trusted” network paths with no authentication</li><li>plaintext transmission inside supposedly secure boundaries</li></ul><p>In real systems, these bugs survive audits because:</p><ul><li>permissions look correct</li><li>access controls appear intact</li><li>nothing crashes</li><li>nothing looks suspicious</li></ul><p>Until someone listens.</p><h3>The Takeaway</h3><p>This level reinforces a principle that carries far beyond wargames:</p><blockquote><strong><em>Security is not just about protecting access — it’s about controlling data flow.</em></strong></blockquote><p>If sensitive data is read correctly but handled incorrectly afterward, the system is still compromised.</p><p>Behemoth Level-5 doesn’t reward cleverness.<br> It rewards <strong>attention to consequence</strong>.</p><h3>Full Technical Write-up</h3><p>The complete analysis — including:</p><ul><li>libc call tracing</li><li>socket behavior</li><li>port discovery</li><li>and exploitation mechanics</li></ul><p>is documented in detail here:</p><h4><strong>PDF write-up:</strong></h4><p><a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-5/Behemoth_Level-5.pdf"><em>https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-5/Behemoth_Level-5.pdf</em></a></p><h4><strong>Markdown write-up:</strong></h4><p><a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-5/Behemoth_Level-5.md"><em>https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-5/Behemoth_Level-5.md</em></a></p><h4><strong>Entire Behemoth series:</strong></h4><p><a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough"><em>https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough</em></a></p><p>If you’re interested in how <em>non-memory</em> bugs leak real secrets, the full write-up is where the actual work lives.</p><blockquote><strong>#700DaysOfSkill</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=95706ff3b2e1" width="1" height="1" alt=""><hr><p><a href="https://meetcyber.net/day-148-behemoth-level-5-overthewire-walkthrough-95706ff3b2e1">Day 148 — Behemoth Level-5 OverTheWire Walkthrough</a> was originally published in <a href="https://meetcyber.net/">MeetCyber</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 147 — Behemoth Level-4 OverTheWire Walkthrough]]></title>
            <link>https://meetcyber.net/day-147-behemoth-level-4-overthewire-walkthrough-31ede4243bd8?source=rss-8bf272601c2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/31ede4243bd8</guid>
            <category><![CDATA[binary-exploitation]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[ctf]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ctf-writeup]]></category>
            <dc:creator><![CDATA[Jinay]]></dc:creator>
            <pubDate>Mon, 29 Dec 2025 12:33:16 GMT</pubDate>
            <atom:updated>2025-12-29T14:48:05.113Z</atom:updated>
            <content:encoded><![CDATA[<h3>Day 147 — Behemoth Level-4 OverTheWire Walkthrough</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SGmmECjhXybDN4BSq5BKjw.png" /></figure><p><strong><em>Behemoth Level-4: Turning a Race Condition into a Guaranteed Win</em></strong></p><p>Behemoth Level-4 looks deceptively simple on the surface.<br> There’s no buffer overflow, no shellcode, no ROP chains — and that’s exactly why it’s dangerous.</p><p>This level demonstrates how <strong>logic flaws combined with filesystem trust</strong> can lead to reliable privilege escalation, <em>without touching memory corruption at all</em>.</p><p>More importantly, it teaches a lesson many beginners miss:</p><blockquote><strong><em>If you can pause execution, a race condition stops being a race.</em></strong></blockquote><p>This write-up documents how that idea applies in practice.</p><h3>Initial Observation: Predictable Behavior</h3><p>Running the binary repeatedly revealed an interesting pattern:</p><ul><li>The program attempts to read a file under /tmp</li><li>The filename increases deterministically:</li></ul><pre>/tmp/21 → /tmp/23 → /tmp/25 → /tmp/27 ...</pre><ul><li>If the file does not exist, execution exits with:</li></ul><pre>PID not found!</pre><p>This immediately suggests that the filename is derived from <strong>process state</strong>, not randomness.</p><p>That hypothesis is confirmed under disassembly.</p><h3>Root Cause: Predictable Temporary File Path</h3><p>Disassembling the binary in GDB reveals a critical line:</p><pre>call getpid@pltba</pre><p>Internally, the program constructs a path similar to:</p><pre>sprintf(path, &quot;/tmp/%d&quot;, getpid());</pre><p>Then proceeds to open and read from that file.</p><p>Key observations:</p><ul><li>The filename is <strong>fully predictable</strong></li><li>/tmp is a shared, attacker-writable directory</li><li>No validation is performed:</li><li>no O_EXCL</li><li>no mkstemp</li><li>no symlink checks</li><li>no ownership or permission verification</li></ul><p>At this point, the vulnerability is clear:</p><h3>Vulnerability Class</h3><p><strong>TOCTOU (Time-of-Check to Time-of-Use) race condition combined with symlink abuse</strong></p><h3>Why This Is Exploitable</h3><p>The binary runs with elevated privileges (behemoth5).</p><p>That means:</p><ul><li>If it can be tricked into opening a sensitive file,</li><li>the kernel will allow the read,</li><li>and the contents will be printed to stdout.</li></ul><p>The only obstacle is <strong>timing</strong>:<br> the attacker needs to place a malicious file at exactly the right moment.</p><p>But instead of racing…</p><h3>Eliminating the Race Entirely</h3><p>Rather than relying on filesystem timing, the exploit removes uncertainty completely by using <strong>process signals</strong>.</p><h3>Key insight:</h3><p>Linux allows a process to be <strong>frozen at kernel level</strong> using SIGSTOP.</p><p>This signal:</p><ul><li>cannot be ignored</li><li>cannot be handled</li><li>halts execution immediately</li></ul><p>This gives us a perfect exploitation window.</p><h3>Exploitation Strategy</h3><p>The exploit follows four deterministic steps:</p><h3>1. Launch the binary in the background</h3><pre>/behemoth/behemoth4 &amp;</pre><p>This allows the shell to regain control while the process is running.</p><h3>2. Capture the Process ID</h3><pre>ProcessID=$!</pre><p>$! expands to the PID of the most recent background process — exactly the value used by the binary to construct /tmp/&lt;PID&gt;.</p><h3>3. Freeze Execution</h3><pre>kill -STOP $ProcessID</pre><p>At this point:</p><ul><li>the process is paused</li><li>no file operations have occurred yet</li><li>execution state is frozen</li></ul><p>The race is now under attacker control.</p><h3>4. Plant the Symlink</h3><pre>ln -s /etc/behemoth_pass/behemoth5 /tmp/$ProcessID</pre><p>This creates a symbolic link with the <strong>exact filename</strong> the program expects.</p><p>The program believes it will read:</p><pre>/tmp/&lt;PID&gt;</pre><p>But the kernel resolves:</p><pre>/etc/behemoth_pass/behemoth5</pre><h3>5. Resume Execution</h3><pre>kill -CONT $ProcessID</pre><p>The program continues execution as if nothing happened.</p><p>Internally, it now performs:</p><pre>fopen(&quot;/tmp/&lt;PID&gt;&quot;, &quot;r&quot;);</pre><p>Which resolves to:</p><pre>fopen(&quot;/etc/behemoth_pass/behemoth5&quot;, &quot;r&quot;);</pre><p>The password is printed to stdout.</p><h3>Final Working Payload</h3><pre>/behemoth/behemoth4 &amp;<br>ProcessID=$!<br>kill -STOP $ProcessID<br>ln -s /etc/behemoth_pass/behemoth5 /tmp/$ProcessID<br>kill -CONT $ProcessID</pre><p><strong>Result:</strong><br> Privileged file read → password for the next level disclosed.</p><p>No crashes.<br>No race conditions.<br>No luck.</p><h3>Why This Works So Reliably</h3><p>This exploit succeeds because:</p><ul><li>The filename is predictable</li><li>The program trusts /tmp</li><li>Execution can be paused deterministically</li><li>The kernel enforces permissions <em>after</em> path resolution</li></ul><p>This is a <strong>logic failure</strong>, not a technical edge case.</p><h3>Key Learnings</h3><ul><li>/tmp is hostile territory by default</li><li>Predictable filenames are vulnerabilities</li><li>TOCTOU bugs become trivial when timing is eliminated</li><li>SIGSTOP / SIGCONT are powerful exploitation primitives</li><li>Memory corruption is not required for privilege escalation</li></ul><blockquote><em>Behemoth Level-4 teaches that </em><strong><em>control beats speed</em></strong><em>.<br> If you can pause the program, the race is already won.</em></blockquote><h3>Write-ups &amp; Resources</h3><ul><li><strong>PDF Write-up:</strong><br> <a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-4/Behemoth_Level-4.pdf">Behemoth Level-4 — PDF</a></li><li><strong>Markdown Write-up:</strong><br> <a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/README.md">Behemoth Level-4 — MD</a></li><li><strong>Entire Behemoth Series:</strong><br> <a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/README.md">Behemoth Wargame Series</a></li></ul><h3>Closing Note</h3><p>Levels like this are easy to underestimate because they don’t “feel” like exploitation.</p><p>But in real systems, <strong>logic bugs plus filesystem trust</strong> are often more dangerous than memory bugs.</p><p>Behemoth Level-4 is a reminder that attackers don’t need complexity — <br> they need <strong>leverage</strong>.</p><blockquote><strong>#700DaysOfSkill</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=31ede4243bd8" width="1" height="1" alt=""><hr><p><a href="https://meetcyber.net/day-147-behemoth-level-4-overthewire-walkthrough-31ede4243bd8">Day 147 — Behemoth Level-4 OverTheWire Walkthrough</a> was originally published in <a href="https://meetcyber.net/">MeetCyber</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 146 — Behemoth Level-3 OverTheWire Walkthrough]]></title>
            <link>https://meetcyber.net/day-146-behemoth-level-3-overthewire-walkthrough-d83b945138c5?source=rss-8bf272601c2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/d83b945138c5</guid>
            <category><![CDATA[ctf]]></category>
            <category><![CDATA[ctf-writeup]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Jinay]]></dc:creator>
            <pubDate>Sun, 28 Dec 2025 16:42:18 GMT</pubDate>
            <atom:updated>2025-12-28T19:36:42.108Z</atom:updated>
            <content:encoded><![CDATA[<h3>Day 146 — Behemoth Level-3 OverTheWire Walkthrough</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NzSP85qPi8fxQduZtYhB0Q.png" /></figure><p><em>Behemoth Level-3 finally fell — not because I discovered a new trick, but because I stopped trusting the debugger.</em></p><p>This level taught me something that no beginner exploitation tutorial emphasizes enough:</p><blockquote><strong><em>A correct exploit can still fail if you only test it in the wrong execution context.</em></strong></blockquote><p>This post documents <em>what the vulnerability was</em>, <em>how it was exploited</em>, <em>why it kept failing</em>, and <em>what finally worked</em>.</p><h3>The Vulnerability (On Paper)</h3><p>Behemoth Level-3 contains a classic and dangerous bug:</p><p><strong>Uncontrolled format string vulnerability</strong></p><p>User input is passed directly into printf without a format specifier:</p><pre>printf(argv[1]);</pre><p>This immediately enables:</p><ul><li>arbitrary memory reads</li><li>arbitrary memory writes using %n / %hhn</li><li>control-flow hijacking via GOT overwrite</li></ul><p>The binary is:</p><ul><li>non-PIE</li><li>writable GOT</li><li>ASLR disabled on the target system</li></ul><p>On paper, this is straightforward.</p><p>In practice, it wasn’t.</p><h3>Exploitation Strategy</h3><p>The goal was to hijack execution by overwriting a GOT entry.</p><h3>Target</h3><ul><li>puts@GOT → redirected to shellcode placed on the stack</li></ul><h3>Why byte-wise overwrite?</h3><p>Full %n writes were unstable and risky.</p><p>Instead, I used:</p><ul><li>%hhn for <strong>byte-by-byte GOT overwrite</strong></li><li>strict control over cumulative printed byte count</li><li>ordered writes to avoid corruption</li></ul><p>Each byte was validated independently.</p><p>By the time I reached the final stages:</p><ul><li>3 out of 4 bytes were landing exactly as intended</li><li>padding math was correct</li><li>stack offset was stable</li><li>shellcode address was accurate</li></ul><p>And yet — no shell.</p><h3>The Failure That Didn’t Make Sense</h3><p>Everything <em>should</em> have worked.</p><p>Under <strong>GDB</strong>, the exploit appeared broken:</p><ul><li>last byte inconsistently failed</li><li>addresses looked slightly off</li><li>control-flow never fully redirected</li></ul><p>At this point, most people either:</p><ul><li>copy a working payload from a write-up, or</li><li>assume they “don’t get format strings”</li></ul><p>I did neither.</p><h3>The Breakthrough: Stop Trusting the Debugger</h3><p>The turning point was simple — and painful in hindsight.</p><p>I stopped testing exclusively inside GDB.</p><p>Instead, I executed the exploit <strong>locally in real conditions</strong>, piping the payload directly:</p><pre>echo -e &quot;&lt;payload&gt;&quot; | ./behemoth3</pre><p>Result?</p><p><strong>Immediate success.</strong></p><p>The exploit was correct all along.</p><h3>What changed?</h3><ul><li>Stack layout outside GDB</li><li>Environment variable placement</li><li>Execution flow timing</li></ul><p>Debugger behavior ≠ real execution.</p><p>This single decision solved days of confusion.</p><h3>What Behemoth Level-3 Actually Teaches</h3><p>This level is not really about format strings.</p><p>It teaches:</p><ul><li>why debugger-only testing is dangerous</li><li>how fragile byte-precise exploits are</li><li>how “almost correct” is still completely wrong</li><li>how long it can take to trust your own reasoning</li><li>how ego fatigue appears <em>right before</em> success</li></ul><p>It tests whether you can stay inside a problem after the fun part is over.</p><h3>TL;DR</h3><ul><li><strong>Vulnerability:</strong> Format string vulnerability enabling arbitrary writes</li><li><strong>Exploit:</strong> Byte-wise GOT overwrite using %n</li><li><strong>Failure Cause:</strong> Debugger-only testing masked real execution behavior</li><li><strong>Fix:</strong> Execute payload outside GDB in real runtime context</li><li><strong>Lesson:</strong> Precision + correct environment matter more than cleverness</li></ul><h3>Write-ups &amp; Resources</h3><ul><li><strong>PDF Write-up (Detailed):</strong><br><a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-3/Behemoth_Level-3.pdf">Behemoth Level-3 — PDF</a></li><li><strong>Markdown Write-up (GitHub):</strong><br><a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/blob/main/level-3/Behemoth_Level-3.md">Behemoth Level-3 — Markdown</a></li><li><strong>Entire Behemoth Series (Levels 0–3 of 8):</strong><br><a href="https://github.com/jynxora/OverTheWire-Behemoth-Series-Walkthrough/tree/main">Behemoth Wargame Series</a></li></ul><h3>Final Note</h3><p>Behemoth Level-3 didn’t fall because I got smarter.</p><p>It fell because I stayed long enough to notice what everyone rushes past.</p><p>That’s the real filter.</p><blockquote><strong>#700DaysOfSkill</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d83b945138c5" width="1" height="1" alt=""><hr><p><a href="https://meetcyber.net/day-146-behemoth-level-3-overthewire-walkthrough-d83b945138c5">Day 146 — Behemoth Level-3 OverTheWire Walkthrough</a> was originally published in <a href="https://meetcyber.net/">MeetCyber</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>