<?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 Jaseer VK on Medium]]></title>
        <description><![CDATA[Stories by Jaseer VK on Medium]]></description>
        <link>https://medium.com/@jaseervk321?source=rss-949defe7d91e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*PgmA9SwH4jXWMGcaoASLXA.jpeg</url>
            <title>Stories by Jaseer VK on Medium</title>
            <link>https://medium.com/@jaseervk321?source=rss-949defe7d91e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 08:55:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jaseervk321/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[Understanding CVE-2026–123633.How a Use-After-Free Vulnerability Can Lead to Remote Code Execution:]]></title>
            <link>https://medium.com/@jaseervk321/understanding-cve-2026-123633-how-a-use-after-free-vulnerability-can-lead-to-remote-code-execution-647dc0ccfc77?source=rss-949defe7d91e------2</link>
            <guid isPermaLink="false">https://medium.com/p/647dc0ccfc77</guid>
            <category><![CDATA[cwe]]></category>
            <category><![CDATA[cve]]></category>
            <category><![CDATA[use-after-free]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[ngnix]]></category>
            <dc:creator><![CDATA[Jaseer VK]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 14:02:03 GMT</pubDate>
            <atom:updated>2026-11-19T14:06:56.489Z</atom:updated>
            <content:encoded><![CDATA[<p><em>An easy-to-understand explanation of memory reuse, memory corruption, and how an attacker may gain control over a vulnerable NGINX worker process.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BrclupkQhRZVHgBMjnB1LQ.png" /></figure><h3>Introduction</h3><p>Imagine a software application using a temporary storage box to keep information while processing a request.</p><p>Once the application finishes using that box, it releases it. But what happens if the application continues using the box even after releasing it?</p><p>That is the basic idea behind a <strong>Use-After-Free (UAF)</strong> vulnerability.</p><p>A UAF bug can become particularly dangerous when an attacker can influence what happens to the released memory. In certain situations, this can lead to memory corruption and potentially Remote Code Execution (RCE).</p><p>One example is <strong>CVE-2026–123633</strong>, a vulnerability affecting NGINX when it uses HTTP/2 to receive client requests and forwards those requests to a backend server.</p><p>Let’s understand how this works.</p><h3>1. First, understand how memory is used</h3><p>When a program processes a request, it needs memory to temporarily store information.</p><p>For example:</p><ol><li>A client sends a request.</li><li>NGINX allocates memory to store connection and request-related information.</li><li>NGINX processes the request.</li><li>Once the memory is no longer needed, NGINX releases it.</li></ol><p>Think of memory as a temporary workspace.</p><h3>2. What is a Use-After-Free vulnerability?</h3><p>A Use-After-Free occurs when a program tries to access memory after that memory has already been released.</p><p>Consider this simplified example:</p><pre>Step 1: Memory is allocated<br>Program → Memory A<br>Step 2: Memory is released<br>Program → Memory A (freed)<br>Step 3: Program still uses the old pointer<br>Program → Memory A (invalid access)</pre><p>The important detail is that releasing memory does not necessarily erase the pointer that refers to it.</p><p>The pointer may still contain the old memory address. It is now called a <strong>dangling pointer</strong>.</p><h3>3. How does memory reuse make this dangerous?</h3><p>Here is where the situation becomes more interesting.</p><p>When memory is freed, the memory allocator may make that same address available for another allocation.</p><p>Suppose:</p><ul><li>Request A uses Memory A.</li><li>The application releases Memory A.</li><li>Request B later receives the same memory address for a different purpose.</li><li>The old pointer from Request A still points to that address.</li></ul><p>Now the old pointer may access data belonging to Request B.</p><pre>Initially:<br>Old Pointer ──────→ Memory A<br>                         |<br>                    Request A data<br>After memory is freed:<br>Old Pointer ──────→ Memory A (freed)<br>After memory is reused:<br>Old Pointer ──────→ Memory A<br>                         |<br>                    Request B data</pre><p>This is called <strong>memory reuse</strong>.</p><p>It is important to understand that memory reuse alone does not automatically cause RCE. The vulnerability occurs when the program continues accessing the memory through an invalid pointer.</p><h3>4. How can this lead to Remote Code Execution?</h3><p>This is the most important part.</p><p>Imagine that an attacker can influence the data that gets placed into a memory location after it has been freed.</p><p>If the vulnerable program later accesses that location through its old pointer, it may interpret the new data incorrectly or overwrite other memory.</p><p>This can cause <strong>memory corruption</strong>.</p><p>In certain circumstances, an attacker may use that corruption to influence the program’s execution flow.</p><p>For example, if the attacker can influence where the program executes next, they may be able to make the program execute attacker-controlled instructions.</p><p>That is the basic connection between UAF and RCE.</p><p>The simplified chain is:</p><pre>Use-After-Free<br>      ↓<br>Memory gets reused<br>      ↓<br>Old pointer accesses reused memory<br>      ↓<br>Memory corruption<br>      ↓<br>Execution flow may be influenced<br>      ↓<br>Potential Remote Code Execution</pre><p><strong>Important:</strong> Not every UAF vulnerability leads to RCE. Some only cause application crashes or Denial of Service (DoS). Successful RCE depends on whether the attacker can reliably turn the memory corruption into control over program execution.</p><h3>5. How does this happen in CVE-2026–123633?</h3><p>Now let’s connect the concept to the actual NGINX vulnerability.</p><p>NGINX is commonly used as a reverse proxy. It receives requests from clients and forwards them to backend application servers.</p><p>For example:</p><pre>User&#39;s Browser<br>      |<br>      | HTTP/2 Request<br>      v<br>    NGINX<br>      |<br>      | Forward request<br>      v<br> Backend Application</pre><p>CVE-2026–123633 affects specific NGINX configurations where HTTP/2 is enabled for client connections and requests are forwarded to a backend.</p><p>The vulnerability involves how NGINX manages reusable connections when its available worker_connections are running low.</p><h3>The attack flow</h3><p>The research published by Wiz describes the following sequence:</p><p><strong>Step 1: The attacker sends a specially crafted HTTP/2 request.</strong></p><p>The attacker begins sending an incomplete HTTP/2 HEADERS frame. NGINX temporarily treats the connection as reusable because it has not yet created an active request stream.</p><p><strong>Step 2: The request becomes active.</strong></p><p>The attacker sends the remaining part of the frame. NGINX creates a request stream and begins processing the request.</p><p>However, the connection remains incorrectly marked as reusable.</p><p><strong>Step 3: NGINX needs another connection slot.</strong></p><p>When NGINX forwards the request to a backend, it needs an upstream connection.</p><p>If available connection slots are running low, NGINX may attempt to free up resources by closing connections marked as reusable.</p><p>The problem is that the attacker’s connection is still being used to process the request.</p><p><strong>Step 4: The connection memory is freed too early.</strong></p><p>NGINX attempts to close the connection. Under the described error condition, it frees the connection’s memory even though the original request-processing code still references it.</p><p>This creates the Use-After-Free condition.</p><p><strong>Step 5: The old pointer is used again.</strong></p><p>The original request processing continues using the previously freed memory.</p><p>That memory may have been reused for another purpose. The old pointer can therefore refer to memory whose contents are no longer what NGINX expects.</p><p>This is the critical memory-safety failure that can be exploited further.</p><h3>Does the first request contain an RCE payload?</h3><p>Not necessarily. This is an important distinction.</p><p>The attacker does not simply send a Linux command in the first request and wait for a second request to execute it.</p><p>Instead, the specially crafted HTTP/2 traffic manipulates NGINX’s connection-handling logic to trigger the UAF condition. Exploiting that memory corruption further requires additional techniques.</p><p>The research describes techniques such as memory disclosure and heap grooming, along with an ASLR bypass, to make exploitation reliable. The researchers demonstrated RCE in a laboratory environment.</p><p>In simple terms:</p><ul><li>The crafted HTTP/2 traffic triggers the vulnerable condition.</li><li>The freed memory creates an opportunity for memory corruption.</li><li>Further exploitation techniques can turn that corruption into control over execution.</li><li>If successful, the attacker may execute code with the privileges of the NGINX worker process.</li></ul><h3>6. What is the role of ASLR?</h3><p><strong>ASLR (Address Space Layout Randomization)</strong> is a security mechanism that randomizes where important parts of a program are placed in memory.</p><p>This makes it harder for attackers to predict memory addresses.</p><p>For example:</p><p>Without ASLR:</p><pre>Program code → 0x400000</pre><p>With ASLR:</p><pre>Program code → Randomized address</pre><p>If an attacker does not know the relevant memory addresses, exploiting memory corruption to influence execution becomes more difficult.</p><p>The CVE description specifically notes that code execution is possible when ASLR is disabled or when the attacker can bypass it.</p><h3>7. What is the impact?</h3><p>Successful exploitation may allow a remote attacker to:</p><ul><li>Execute arbitrary code with NGINX worker privileges.</li><li>Disrupt services by crashing NGINX worker processes.</li><li>Potentially access sensitive information or modify data within the worker’s permissions.</li></ul><p>The vulnerability does not require the backend application itself to contain a security flaw. The problem exists in NGINX’s own HTTP/2 connection handling.</p><h3>8. How can organizations protect themselves?</h3><p>The recommended action is to update affected NGINX deployments to a fixed version.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s5frp0RqoEf1o_uS9NF4Kw.png" /></figure><p>These are the affected and fixed versions listed in F5’s advisory. Always check the vendor advisory and your distribution’s security notices because distributions may backport patches.</p><p>If an immediate update is not possible, temporarily disabling HTTP/2 may reduce exposure. Test application compatibility before applying this mitigation.</p><h3>Conclusion</h3><p>CVE-2026–123633 demonstrates how a seemingly small memory-management mistake can become a serious security issue.</p><p>The problem begins when NGINX frees connection memory while request-processing code still needs it. Memory reuse can then make the situation more dangerous, potentially allowing an attacker to corrupt memory and influence program execution.</p><p>The key lesson is that <strong>freeing memory is not enough; a program must also ensure that no active code continues using the released memory.</strong></p><p>Understanding this relationship between Use-After-Free, memory reuse, memory corruption, and execution control is essential when studying modern memory-safety vulnerabilities.</p><h3>References</h3><ol><li><a href="https://www.wiz.io/blog/nginx-http2-rce-vulnerabilities?utm_source=chatgpt.com">Wiz Research — Unauthenticated Remote Code Execution in NGINX</a>.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=647dc0ccfc77" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PHP2Shell Explained: How Two Critical PHP Vulnerabilities Could Turn a Web Request Into Remote Code…]]></title>
            <link>https://medium.com/@jaseervk321/php2shell-explained-how-two-critical-php-vulnerabilities-could-turn-a-web-request-into-remote-code-7466b7b7678f?source=rss-949defe7d91e------2</link>
            <guid isPermaLink="false">https://medium.com/p/7466b7b7678f</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[php2shell]]></category>
            <dc:creator><![CDATA[Jaseer VK]]></dc:creator>
            <pubDate>Tue, 27 Oct 2026 11:42:53 GMT</pubDate>
            <atom:updated>2026-11-19T14:51:08.208Z</atom:updated>
            <content:encoded><![CDATA[<h3>PHP2Shell Explained: How Two Critical PHP Vulnerabilities Could Turn a Web Request Into Remote Code Execution</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ib0Gx2pEqA_rbcECx0Ohwg.png" /></figure><h3>Introduction</h3><p><em>An easy-to-understand guide to CVE-2026–109618 and CVE-2026–109619, the memory-management flaws behind PHP2Shell, and what developers and security researchers can learn from them.</em></p><p>Imagine running a website that handles thousands of visitors every day. Your login system works, your passwords are hashed, and your application validates user input.</p><p>Then, someone sends a specially crafted HTTP request to your server. They do not need to log in. They do not need to upload a traditional PHP web shell. In certain vulnerable configurations, the request can exploit a flaw inside PHP itself and potentially allow the attacker to execute commands on the server.</p><p>That is the security concern behind <strong>PHP2Shell</strong>, the name used for two critical vulnerabilities disclosed in PHP on October 21, 2026.</p><p>The vulnerabilities are tracked as <strong>CVE-2026–109618</strong> and <strong>CVE-2026–109619</strong>. Both received a CVSS v4.0 severity score of 9.2 out of 10. They can potentially allow remote code execution (RCE) without authentication on affected systems.</p><p>The official PHP project released security updates for both vulnerabilities, and proof-of-concept details have begun circulating publicly. This makes understanding and patching the issue particularly important.</p><p>Sources: <a href="https://www.php.net/archive/2026.php">Official PHP security announcement</a> | <a href="https://tryhackme.com/resources/blog/php2shell-patch">TryHackMe’s PHP2Shell technical analysis</a></p><h3>1. First, what is PHP2Shell?</h3><p>Before looking at the vulnerabilities, let us understand the technology involved.</p><p>PHP is a programming language used by websites to perform tasks such as processing login requests, displaying dynamic content, handling file uploads, and communicating with databases.</p><p>Platforms and applications such as WordPress, Drupal, and Joomla can use PHP to run their server-side functionality.</p><p>When someone visits a PHP-powered website, the server processes the request using the PHP runtime. The runtime is the software that executes PHP code and handles the internal work required to process each request.</p><p>PHP2Shell is not simply a vulnerable WordPress plugin or a poorly written PHP script. The original PHP2Shell vulnerabilities affect <strong>PHP’s underlying request-processing and memory-management behaviour</strong>.</p><p>The name describes the potential result: an attacker may turn a specially crafted web request into the ability to execute code on the server.</p><p>In simpler terms, an attacker might not need to find a vulnerable application function. They may be able to target the software responsible for processing the request before the application even begins its normal work.</p><p>That distinction is important because application-level protections cannot reliably fix a vulnerability in the underlying PHP runtime.</p><h3>2. Why are these vulnerabilities dangerous?</h3><p>Three terms help explain the risk.</p><p><strong>Remote code execution (RCE)</strong> means an attacker can cause a vulnerable system to execute code remotely. Depending on the vulnerability and the attacker’s level of control, that code might run operating-system commands or access application data.</p><p><strong>Unauthenticated</strong> means the attacker does not need to successfully log in before attempting the attack.</p><p><strong>Memory corruption</strong> means a program has incorrectly handled the memory it uses to store information. The result might be a crash, unexpected behaviour, disclosure of data, or code execution.</p><p>PHP2Shell involves problems with how PHP handles memory when requests fail or when information from an earlier request remains in memory longer than it should.</p><p>To understand this, we need to look at the two vulnerabilities separately.</p><h3>3. CVE-2026–109618: What happens when PHP runs out of memory?</h3><p>The first vulnerability involves an out-of-memory condition, commonly abbreviated as <strong>OOM</strong>.</p><h3>What does out of memory mean?</h3><p>Every running program needs memory to store information and perform operations.</p><p>For example, when a website processes a form, PHP may allocate memory to store the submitted fields, file metadata, and other request information.</p><p>PHP also has a memory_limit setting that limits the amount of memory a PHP request can consume.</p><p>If the request requires more memory than PHP is permitted to use, PHP may encounter a fatal out-of-memory error.</p><p>Under normal circumstances, this should cause the operation to fail safely.</p><p>But what if the failure happens at precisely the wrong moment?</p><h3>How the vulnerability works</h3><p>According to the <a href="https://github.com/php/php-src/security/advisories/GHSA-w8hw-w9fx-j79w">official PHP advisory</a>, PHP can interrupt request processing when an allocation fails. In certain circumstances, some internal request information may not yet be fully initialized.</p><p>The request then moves into cleanup, where PHP releases resources and processes the state left behind by the failed operation.</p><p>The problem is that cleanup can encounter information that is not in the state it expects.</p><p>Under exploitable conditions, this can result in memory corruption and remote code execution.</p><p>Think of it like assembling a machine. A worker begins connecting several components, but the process is interrupted halfway through. Another worker arrives to clean up and assumes every component was installed correctly. That assumption leads to the cleanup process handling an incomplete assembly incorrectly.</p><p>The analogy is not technically exact, but it captures the core problem: an unexpected failure leaves internal state in a condition that later operations do not safely handle.</p><p>Researchers demonstrated remote code execution against Apache installations using mod_php. The relevant request-processing path can be reached before the website&#39;s own PHP application code executes.</p><p>That matters because the vulnerable code may run before the application’s normal authentication or input-validation logic has an opportunity to intervene.</p><p><strong>The key lesson:</strong> a memory limit does not automatically make a program safe when memory allocation fails. The program must also handle the failure correctly.</p><h3>4. CVE-2026–109619: The danger of using memory that has already been freed</h3><p>The second vulnerability involves a different memory-safety problem: <strong>use-after-free</strong>.</p><h3>What is use-after-free?</h3><p>Programs allocate memory when they need to store information. When the information is no longer required, that memory can be released and reused.</p><p>A use-after-free vulnerability occurs when a program continues to use a reference to memory after that memory has been freed.</p><p>Imagine writing an important phone number on a sticky note, then throwing the note away. Later, someone reuses the same space for a different note, but another person still believes the old phone number is there.</p><p>They read the wrong information because their reference is outdated.</p><p>Something similar can happen inside a program when a pointer still refers to memory that has already been released.</p><h3>How PHP2Shell uses this weakness</h3><p>PHP workers may process multiple web requests during their lifetime.</p><p>Information belonging to one request should be reset before its memory is released and the worker moves on to another request.</p><p>However, PHP has internal global state associated with errors, sessions, objects, and extensions. Under certain conditions, an error or another interrupted operation can leave that state pointing to request memory that has already been freed.</p><p>A later request handled by the same worker may encounter this stale state before PHP fully initializes the new request.</p><p>The resulting use-after-free can allow memory disclosure or, under exploitable conditions, remote code execution.</p><p>In simple terms:</p><ol><li>PHP processes a request and stores internal information.</li><li>An unexpected failure interrupts part of the normal cleanup process.</li><li>Memory is released, but a reference to that memory remains.</li><li>The same worker processes another request.</li><li>An operation encounters the stale reference before normal initialization has corrected the state.</li></ol><p>The exact conditions depend on the internal state involved, the PHP build, and the request-processing environment.</p><p>The official <a href="https://github.com/php/php-src/security/advisories/GHSA-6wmf-4rv5-p3rp">CVE-2026–109619 advisory</a> describes the issue in detail.</p><h3>What about fatal_error_backtraces?</h3><p>PHP can retain information about the call stack associated with a fatal error. A call stack, or backtrace, helps developers understand which functions were active when something went wrong.</p><p>The PHP research identifies a path involving fatal-error backtraces: attacker-controlled input can contribute to an error condition, and stale internal state may subsequently be consumed under the required conditions.</p><p>This is one example of how diagnostic and cleanup behaviour can become security-sensitive.</p><p>The important point is not that backtraces are inherently dangerous. It is that internal state must be managed correctly even when an operation terminates unexpectedly.</p><h3>5. What could an attacker achieve?</h3><p>Remote code execution is serious because it can allow an attacker to do more than view a website’s public pages.</p><p>Depending on the privileges of the affected PHP process, the accessible files, application configuration, and network permissions, a successful compromise could potentially enable an attacker to:</p><ul><li>Read sensitive application files and credentials accessible to the PHP worker.</li><li>Modify website content or application files that the worker is permitted to change.</li><li>Execute additional commands under the permissions of the compromised process.</li><li>Access data available to the affected application.</li><li>Establish a foothold for further attacks if other weaknesses are present.</li></ul><p>However, there is an important distinction: <strong>remote code execution does not automatically mean root access</strong>.</p><p>For example, PHP may run under a restricted service account such as www-data on some Linux systems. If code execution occurs under that account, the attacker initially inherits its permissions, not necessarily those of the root user.</p><p>The actual impact depends on how the server and application are configured.</p><p>This is why running web applications with minimal permissions is an important security practice, even when the underlying runtime is fully patched.</p><h3>6. A realistic example: A vulnerable WordPress website</h3><p>Imagine a small online store running WordPress on a Linux server.</p><p>The owner has installed security plugins, uses HTTPS, and requires strong passwords for administrator accounts. However, the server is running a vulnerable PHP release.</p><p>An attacker discovers that the underlying PHP runtime has not been updated.</p><p>In an applicable vulnerable environment, the attacker may attempt to trigger the memory-handling flaw through a crafted HTTP request without logging in.</p><p>If the attack succeeds, the attacker may gain code-execution capability under the permissions of the PHP process.</p><p>If that process can read the site’s configuration file, the attacker might be able to obtain database credentials. If it can modify website files, the attacker might be able to alter pages or insert malicious code.</p><p>If the same server also contains unrelated applications with weak isolation, the initial compromise could create opportunities for further attacks.</p><p>This example illustrates potential consequences, not a claim that every WordPress installation is exploitable.</p><p>WordPress plugins are not necessarily responsible for the original defect. The vulnerability is in PHP itself, so updating plugins alone does not repair the affected runtime.</p><p>The correct response is to identify the PHP version used by the website, check the hosting provider’s security updates, and apply the appropriate fix.</p><h3>7. Understanding the attack flow in a controlled lab</h3><p>I recently explored PHP2Shell in a TryHackMe learning environment. Hands-on labs are useful because they show how a vulnerability moves from a technical explanation to a reproducible security problem.</p><p>For this type of lab, it helps to separate the attack into its main stages.</p><p><strong>Stage 1: Identify the target</strong></p><p>The researcher starts with the IP address or URL of the intentionally vulnerable machine provided by the lab.</p><p>The goal is to understand the target environment rather than blindly send requests to an unknown system.</p><p><strong>Stage 2: Understand the vulnerable component</strong></p><p>The researcher reviews the PHP runtime, request-processing environment, and relevant vulnerability details.</p><p>Version information helps with initial assessment, but a version string alone cannot establish every aspect of exploitability. Vendors may also backport security patches without changing to the upstream version number listed in an advisory.</p><p><strong>Stage 3: Understand the failure condition</strong></p><p>The exercise demonstrates how specially constructed requests can trigger unexpected behaviour in PHP’s request processing or memory management.</p><p>The important concept is that the failure happens inside the runtime, rather than necessarily in a vulnerable application function.</p><p><strong>Stage 4: Validate the result</strong></p><p>In a dedicated lab, the researcher follows the room’s instructions and verifies the demonstrated impact using the lab’s intended method.</p><p>The purpose is to understand what the result proves, identify the relevant process permissions, and distinguish successful code execution from a simple error response.</p><p><strong>Stage 5: Connect the attack to remediation</strong></p><p>Finally, the researcher identifies the affected runtime, reviews the official advisory, and determines which patch or other approved remediation is appropriate.</p><p>This final stage is just as important as demonstrating the vulnerability. A successful lab exercise should teach you how to recognize and prevent the same class of issue in real environments.</p><h3>What about the payload and attacking commands?</h3><p>The exact PHP2Shell proof-of-concept depends on the vulnerable path and target environment. I am not reproducing a weaponized, copy-paste RCE payload in this public article because it could be reused against real internet-facing systems.</p><p>For practical testing, use the payload and exploit instructions supplied by your authorized TryHackMe exercise, and run them only against the target assigned to that lab.</p><p>For defensive investigation on a system you administer, the following commands can help establish the local PHP CLI version and its configuration:</p><pre>php -v<br>php --ini</pre><p>To check whether a training web server is reachable, you can use a normal HTTP request:</p><pre>curl -I http://&lt;LAB_TARGET&gt;/</pre><p>Replace &lt;LAB_TARGET&gt; with the assigned lab address. This is a connectivity check, not an exploit or a vulnerability test.</p><p><strong>Important:</strong> the PHP CLI configuration may differ from the configuration used by a public-facing website. Checking php -v on a server does not, by itself, prove that its web-serving PHP runtime is patched.</p><p>The correct workflow is to verify the version and security package actually used by the affected web service.</p><h3>8. Which PHP versions are affected?</h3><p>PHP published fixes for the two original PHP2Shell vulnerabilities on October 21, 2026.</p><p>The upstream patched versions are:</p><p>PHP branchFirst patched versionPHP 8.58.5.12PHP 8.48.4.27PHP 8.38.3.36PHP 8.28.2.35</p><p>Installations running earlier releases within these branches should be treated as affected unless their vendor confirms that the required security fixes have been applied.</p><p>PHP 8.1 and older branches are end-of-life and do not receive ordinary upstream security releases for these vulnerabilities. Some distributions or commercial vendors may provide backported fixes, so administrators should verify their specific packages rather than rely exclusively on the displayed version number.</p><p>You can follow the <a href="https://www.php.net/archive/2026.php">official PHP security announcement</a> for release information.</p><h3>9. How can administrators protect their servers?</h3><p>The most important action is to update PHP to a release that contains the original PHP2Shell fixes.</p><h4>1. Patch the actual web-serving PHP runtime</h4><p>Identify whether the application runs PHP through Apache mod_php, PHP-FPM, php-cgi, FrankenPHP, LiteSpeed, or another deployment.</p><p>Check the package and runtime used by the actual web application. Where applicable, restart the relevant services and workers after updating.</p><h4>2. Do not depend on one configuration change</h4><p>Disabling session upload-progress tracking can reduce exposure to a particular attack path, but it does not repair the original out-of-memory flaw.</p><p>Temporary configuration mitigations must be evaluated against the relevant PHP advisory. They should not be treated as a substitute for the security update.</p><h4>3. Review web and PHP logs</h4><p>Look for unusual request patterns, unexpected multipart upload activity, repeated memory-related errors, abnormal PHP worker behaviour, and unexpected child processes or outbound connections.</p><p>These indicators are investigative leads, not proof of exploitation. The absence of suspicious logs does not prove that a server is safe.</p><h4>4. Reduce the impact of a compromise</h4><p>Run PHP workers with the minimum permissions necessary. Avoid storing secrets in locations readable by unrelated applications, restrict unnecessary outbound connections, and maintain appropriate isolation between sites.</p><p>These measures do not fix PHP2Shell, but they can limit the damage if an application or runtime is compromised.</p><h4>5. Investigate potential compromise</h4><p>If there is evidence of exploitation, preserve relevant logs, follow the incident-response process, and assess whether credentials accessible to the affected process need to be rotated. Patching alone does not remove an attacker’s persistence if the system was already compromised.</p><h3>10. What PHP2Shell teaches us as security researchers</h3><p>PHP2Shell is a useful case study because the vulnerabilities do not depend solely on a classic web-application mistake such as SQL injection, cross-site scripting, or an insecure file-upload function.</p><p>Instead, they demonstrate how errors in lower-level memory management can undermine the security of applications built on top of a runtime.</p><p>They also highlight several lessons.</p><p><strong>First, unexpected failures must be handled safely.</strong> A program should not assume that internal data is fully initialized just because a previous operation began successfully.</p><p><strong>Second, memory cleanup is part of security.</strong> Releasing memory without resetting references to it can create use-after-free vulnerabilities that later operations may expose.</p><p><strong>Third, patching the underlying runtime matters.</strong> A website may use secure application code and still be affected by a vulnerability in its execution environment.</p><p><strong>Finally, a proof of concept and a complete remediation plan are different things.</strong> Demonstrating an exploit helps establish impact. Defenders still need to identify affected deployments, apply the correct updates, verify the result, and investigate any evidence of compromise.</p><p>For anyone learning penetration testing, TryHackMe-style labs can help turn these concepts into practical experience. But the real value comes from understanding why the attack works and how to prevent it — not simply obtaining command execution.</p><h3>Conclusion</h3><p>PHP2Shell shows how a flaw deep inside a widely used programming-language runtime can have consequences across many different websites and applications.</p><p>CVE-2026–109618 involves unsafe memory handling when PHP encounters out-of-memory conditions. CVE-2026–109619 involves stale internal state that may be used after its associated memory has been released.</p><p>Under the required conditions, both can potentially lead to unauthenticated remote code execution.</p><p>The practical response is clear: identify affected PHP deployments, apply the appropriate security updates, verify the runtime used by the web application, and investigate suspicious activity where necessary.</p><p>For security researchers, this incident is also a reminder that some of the most important vulnerabilities are not visible in the application code we inspect every day. Sometimes, the critical failure happens in the runtime underneath it.</p><h3>References and Further Reading</h3><ol><li><strong>PHP — Official security announcements and patched releases</strong><br><a href="https://www.php.net/archive/2026.php">https://www.php.net/archive/2026.php</a></li><li><strong>PHP Security Advisory — CVE-2026–109618: RCE via OOM corruption</strong><br><a href="https://github.com/php/php-src/security/advisories/GHSA-w8hw-w9fx-j79w">https://github.com/php/php-src/security/advisories/GHSA-w8hw-w9fx-j79w</a></li><li><strong>PHP Security Advisory — CVE-2026–109619: RCE via stale global state</strong><br><a href="https://github.com/php/php-src/security/advisories/GHSA-6wmf-4rv5-p3rp">https://github.com/php/php-src/security/advisories/GHSA-6wmf-4rv5-p3rp</a></li><li><strong>TryHackMe — The PHP Patch Is Out. The Bug Wasn’t Where Anyone Thought</strong><br><a href="https://tryhackme.com/resources/blog/php2shell-patch">https://tryhackme.com/resources/blog/php2shell-patch</a></li><li><strong>TryHackMe — PHP2Shell: Tracking an Unpatched RCE Scare in Real Time</strong><br><a href="https://tryhackme.com/resources/blog/php2shell-update">https://tryhackme.com/resources/blog/php2shell-update</a></li><li><strong>Google Cloud — Responding to core PHP vulnerabilities</strong><br><a href="https://cloud.google.com/blog/products/identity-security/responding-to-core-php-vulnerabilities-cve-2026-109618-cve-2026-109619">https://cloud.google.com/blog/products/identity-security/responding-to-core-php-vulnerabilities-cve-2026-109618-cve-2026-109619</a></li><li><strong>UK National Cyber Security Centre — Critical security issue affecting PHP</strong><br><a href="https://www.ncsc.gov.uk/news/critical-security-issue-affecting-php">https://www.ncsc.gov.uk/news/critical-security-issue-affecting-php</a></li></ol><h3>Connect &amp; Contact</h3><ul><li><strong>Buy Me a Coffee:</strong> <a href="https://buymeacoffee.com/jaseervk">buymeacoffee.com/jaseervk</a></li><li><strong>GitHub:</strong> <a href="https://github.com/jaseervk">github.com/jaseervk</a></li><li><strong>Portfolio:</strong> <a href="https://www.jaseervk.com/">www.jaseervk.com</a></li><li><strong>Blog:</strong> <a href="https://blog.jaseervk.com/">blog.jaseervk.com</a></li><li><strong>LinkedIn:</strong> <a href="https://www.linkedin.com/in/jaseer-vk-">linkedin.com/in/jaseer-vk-</a></li><li><strong>Medium:</strong> <a href="https://medium.com/@jaseervk321">medium.com/@jaseervk321</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7466b7b7678f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cybersecurity Roadmap: A Step-by-Step Learning Guide]]></title>
            <link>https://medium.com/@jaseervk321/cybersecurity-roadmap-a-step-by-step-learning-guide-6a28151d3641?source=rss-949defe7d91e------2</link>
            <guid isPermaLink="false">https://medium.com/p/6a28151d3641</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[beginners-guide]]></category>
            <category><![CDATA[roadmaps]]></category>
            <dc:creator><![CDATA[Jaseer VK]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 11:02:38 GMT</pubDate>
            <atom:updated>2026-11-19T14:53:18.223Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PcS1QYJ92xW0p5CEKBQR_w.png" /></figure><h3>Introduction</h3><p>Cybersecurity is a broad field that includes networking, operating systems, programming, security tools, penetration testing, and threat detection.</p><p>This roadmap covers the fundamental concepts, tools, practical labs, and security frameworks to study while building a foundation in cybersecurity.</p><h3>1. Computer Fundamentals</h3><ul><li>How computers works</li><li>CPU, RAM, ROM, and storage</li><li>Operating systems and applications</li><li>Virtualizations and virtual machines</li><li>Basic computer troubleshooting</li></ul><h3>2. Networking</h3><ul><li>OSI model</li><li>TCP/IP model</li><li>TCP vs. UDP</li><li>IP addresses: IPv4 and IPv6</li><li>Private vs. public IP addresses</li><li>MAC addresses</li><li>Subnetting</li><li>Default gateway</li><li>DNS, DHCP, ARP, ICMP, and other network protocols</li><li>HTTP vs. HTTPS</li><li>SSL/TLS</li><li>SSH, FTP, SMTP, and other protocols</li><li>Ports and protocols</li><li>VLANs and firewalls</li><li>Proxies and reverse proxies</li><li>VPNs</li><li>Wi-Fi security</li><li>Network security</li><li>Network traffic analysis</li><li>Packet capture</li></ul><h3>3. Linux Fundamentals</h3><ul><li>Linux architecture</li><li>Linux distributions</li><li>Linux filesystem</li><li>Basic terminal commands</li><li>File and directory management</li><li>Users and groups</li><li>File permissions</li><li>System logs</li><li>SSH configuration</li><li>Linux network commands</li></ul><h3>4. Windows Fundamentals</h3><ul><li>Windows architecture</li><li>Windows filesystem</li><li>Users and groups</li><li>NTFS permissions</li><li>Local and administrator accounts</li><li>Task Manager</li><li>Processes and services</li><li>Windows Registry</li><li>Event Viewer</li><li>PowerShell</li><li>Microsoft Defender</li><li>Windows Firewall</li></ul><h3>5. Programming and Scripting</h3><ul><li>Programming fundamentals</li><li>Variables and data types</li><li>Conditional statements and loops</li><li>For loops and iteration</li><li>Functions</li><li>Object-oriented programming (OOP) concepts</li><li>Python</li><li>Bash scripting</li><li>SQL fundamentals</li><li>JSON and XML</li><li>REST APIs</li><li>Git and GitHub</li></ul><h3>6. Cybersecurity Fundamentals</h3><ul><li>What is cybersecurity?</li><li>CIA Triad: Confidentiality, Integrity, and Availability</li><li>Authentication and authorization</li><li>Principle of least privilege</li><li>Threats, vulnerabilities, and risks</li><li>Security controls</li><li>Risk assessment</li><li>Common attack types</li><li>Malware</li><li>Phishing</li><li>Social engineering</li><li>CVE, CWE, and CVSS</li><li>OWASP Top 10</li><li>MITRE ATT&amp;CK</li></ul><h3>7. Cryptography</h3><ul><li>Plaintext and ciphertext</li><li>Encryption and decryption</li><li>Symmetric and asymmetric encryption</li><li>Hashing and salting</li><li>Encryption vs. hashing</li><li>Public and private keys</li><li>TLS certificates</li><li>Password hashing</li></ul><h3>8. Web Technologies</h3><ul><li>How websites work</li><li>Frontend and backend</li><li>HTML, CSS, and JavaScript</li><li>HTTP requests and responses</li><li>HTTP status codes</li><li>HTTP methods</li><li>HTTP headers and cookies</li><li>Sessions</li><li>Same-Origin Policy</li><li>Web servers</li><li>Reverse proxies</li></ul><h3>9. Common Vulnerabilities</h3><p>You can find common vulnerabilities in these :</p><ul><li>OWASP Top 10 for web applications</li><li>OWASP Top 10 for mobile applications</li><li>OWASP Top 10 for APIs</li></ul><h3>10. Security Tools</h3><ul><li>Nmap</li><li>Metasploit</li><li>John the Ripper</li><li>Wireshark</li><li>Gobuster</li><li>Hydra</li><li>Burp Suite</li><li>SQLmap</li><li>Netcat</li><li>OWASP ZAP</li><li>Nessus</li></ul><p><strong>There is also other tools more than these</strong></p><h3>11. Web Application Penetration Testing</h3><ul><li>Penetration testing methodologies</li><li>Information gathering</li><li>Passive and active reconnaissance</li><li>Authentication and authorization testing</li><li>OWASP Top 10 for web applications</li><li>API testing</li><li>Risk rating</li><li>Reporting and remediation</li></ul><p><strong>For practice use portswigger web security academy and also refer owasp top 10 for web</strong></p><h3>12. Network Penetration Testing</h3><ul><li>Port scanning</li><li>Service scanning</li><li>Version detection</li><li>Vulnerability scanning</li><li>Exploitation</li><li>Lateral movement</li><li>Privilege escalation</li><li>Reporting</li></ul><h3>13. Active Directory Security</h3><ul><li>Windows domains</li><li>Active Directory architecture</li><li>Domain Controllers</li><li>Active Directory Users and Computers</li><li>Organizational Units (OUs)</li><li>Group Policy Objects (GPOs)</li><li>Kerberos authentication</li><li>NTLM authentication</li><li>LDAP</li><li>Service Principal Names (SPNs)</li><li>BloodHound</li><li>Impacket</li><li>Kerbrute</li><li>Pass-the-Hash</li><li>Golden Ticket attacks</li></ul><h3>14. SOC and Blue Team</h3><ul><li>Security Operations Center (SOC)</li><li>Security Information and Event Management (SIEM)</li><li>Security logs</li><li>Alert triage</li><li>Threat monitoring</li><li>Threat hunting</li><li>Incident response</li><li>Intrusion Detection and Prevention Systems (IDS/IPS)</li><li>Endpoint Detection and Response (EDR)</li><li>Network Detection and Response (NDR)</li><li>Alert investigation</li><li>MITRE ATT&amp;CK</li><li>Security documentation</li></ul><h3>15. SOC Tools</h3><ul><li>Wazuh</li><li>Splunk</li><li>Microsoft Sentinel</li><li>Sysmon (Windows)</li><li>Windows Event Viewer</li><li>Auditd (Linux)</li><li>Suricata</li><li>Wireshark</li><li>YARA</li><li>Sigma rules</li></ul><h3>16. Mobile Application Security</h3><ul><li>Android architecture</li><li>Android application concepts</li><li>Android permissions</li><li>OWASP Top 10 for mobile applications</li><li>Reverse engineering</li><li>Static and dynamic analysis</li><li>Frida</li><li>Drozer</li><li>MobSF</li><li>JADX-GUI</li><li>Android Debug Bridge (ADB)</li><li>Objection</li><li>SSL pinning</li></ul><h3>17. Security Standards and Frameworks</h3><ul><li>OWASP Top 10</li><li>MITRE ATT&amp;CK</li><li>Common Weakness Enumeration (CWE)</li><li>Common Vulnerabilities and Exposures (CVE)</li><li>Common Vulnerability Scoring System (CVSS)</li><li>NIST standards</li><li>ISO/IEC 27001</li><li>Osintframeworks</li></ul><h3>18. Practical Labs and Learning Platforms</h3><h3>Hands-on Cybersecurity Labs</h3><ul><li>TryHackMe</li><li>Hack The Box</li><li>PortSwigger Web Security Academy</li><li>OverTheWire</li><li>OWASP Juice Shop</li><li>DVWA</li><li>Metasploitable</li><li>VulnHub</li><li>PicoCTF</li></ul><h3>SOC and Blue Team Practice</h3><ul><li>Blue Team Labs Online</li><li>Tryhackme</li><li>LetsDefend</li></ul><h3>Linux and Security References</h3><ul><li>Linux Journey</li><li>Pentestmonkey</li><li>Wappalyzer</li><li>GTFOBins</li><li>Cisco Networking Academy</li></ul><h3>Vulnerability Disclosure and Bug Bounty Platforms</h3><ul><li>Bugcrowd</li><li>HackerOne</li><li>YesWeHack</li><li>Intigriti</li><li>Bugbase</li></ul><h3>Final Roadmap Checklist</h3><ul><li>Computer fundamentals</li><li>Networking</li><li>Linux fundamentals</li><li>Windows fundamentals</li><li>Programming and scripting</li><li>Cybersecurity fundamentals</li><li>Cryptography</li><li>Web technologies</li><li>Common vulnerabilities</li><li>Security tools</li><li>Web application penetration testing</li><li>Network penetration testing</li><li>Active Directory security</li><li>SOC and Blue Team</li><li>SOC tools</li><li>Mobile application security</li><li>Security standards and frameworks</li><li>Practical labs and learning platforms</li></ul><h4><strong>If you have any doubt you can contact me:</strong></h4><ul><li><strong>Buy Me a Coffee:</strong> <a href="https://www.buymeacoffee.com/jaseervk">buymeacoffee.com/jaseervk</a></li><li><strong>GitHub:</strong> <a href="https://github.com/jaseervk">github.com/jaseervk</a></li><li><strong>Portfolio:</strong> <a href="https://www.jaseervk.com/">www.jaseervk.com</a></li><li><strong>Blog:</strong> <a href="https://blog.jaseervk.com/">blog.jaseervk.com</a></li><li><strong>LinkedIn:</strong> <a href="https://linkedin.com/in/jaseer-vk-">linkedin.com/in/jaseer-vk-</a></li><li><strong>Medium:</strong> <a href="https://medium.com/@jaseervk321">https://medium.com/@jaseervk321</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6a28151d3641" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Detecting Malicious Command Execution on Linux with Auditd and Wazuh]]></title>
            <link>https://medium.com/@jaseervk321/detecting-malicious-command-execution-on-linux-with-auditd-and-wazuh-ebc4c01abec4?source=rss-949defe7d91e------2</link>
            <guid isPermaLink="false">https://medium.com/p/ebc4c01abec4</guid>
            <category><![CDATA[wazuh]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[soc]]></category>
            <category><![CDATA[ids-ips]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Jaseer VK]]></dc:creator>
            <pubDate>Wed, 30 Sep 2026 13:08:02 GMT</pubDate>
            <atom:updated>2026-09-30T13:08:02.579Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Introduction</strong></h3><p>Attackers who gain access to a Linux system often use commands such as sudo, su, nmap, nc, curl, wget, python, and perl.</p><p>I built this project to detect selected command executions on Linux using <strong>Auditd and Wazuh SIEM</strong>.</p><p>GitHub:<br><a href="https://github.com/jaseervk/Malicious-Command-Execution-Detection-Linux">https://github.com/jaseervk/Malicious-Command-Execution-Detection-Linux</a></p><h3>How It Works</h3><p>The detection flow is simple:</p><pre>Linux Command<br>     ↓<br>   Auditd<br>     ↓<br>Audit Log<br>     ↓<br>Wazuh Agent<br>     ↓<br>Wazuh Manager<br>     ↓<br>Security Alert</pre><p><strong>Auditd</strong> records the command execution.</p><p><strong>Wazuh Agent</strong> sends the Auditd logs to the Wazuh Manager.</p><p><strong>Wazuh Manager</strong> uses custom rules to detect specific activity and generate alerts.</p><h3>Tools Used</h3><ul><li>Ubuntu/Debian Linux</li><li>Auditd</li><li>Wazuh Agent</li><li>Wazuh Manager</li><li>MITRE ATT&amp;CK</li></ul><h3>1. Install Auditd</h3><p>Install Auditd on the Linux machine:</p><pre>apt install -y auditd</pre><p>Start it:</p><pre>systemctl enable auditd<br>systemctl start auditd</pre><p>Check the status:</p><pre>auditctl -s</pre><h3>2. Add Auditd Rules</h3><p>Create the rules file:</p><pre>nano /etc/audit/rules.d/privilege-escalation.rules</pre><p>Add:</p><pre>-a always,exit -F path=/usr/bin/nc -F perm=x -k netcat_exec<br>-a always,exit -F path=/usr/bin/nmap -F perm=x -k recon_exec<br>-a always,exit -F path=/usr/bin/curl -F perm=x -k data_exfil<br>-a always,exit -F path=/usr/bin/wget -F perm=x -k data_exfil<br>-a always,exit -F path=/usr/bin/python -F perm=x -k script_exec<br>-a always,exit -F path=/usr/bin/perl -F perm=x -k script_exec<br><br>-a always,exit -F path=/usr/bin/sudo -F perm=x -k sudo_exec<br>-a always,exit -F path=/bin/su -F perm=x -k su_exec<br>-a always,exit -F path=/bin/bash -F euid=0 -F perm=x -k root_shell<br>-a always,exit -F path=/bin/sh -F euid=0 -F perm=x -k root_shell<br>-a always,exit -F path=/usr/bin/pkexec -F perm=x -k pkexec_exec</pre><p>Reload the rules:</p><pre>augenrules --load<br>systemctl restart auditd</pre><p>Check them:</p><pre>auditctl -l</pre><p>These rules monitor the execution of selected commands.</p><p>For example:</p><pre>nc      → netcat_exec<br>nmap    → recon_exec<br>curl    → data_exfil<br>wget    → data_exfil<br>python  → script_exec<br>perl    → script_exec<br>su      → su_exec<br>bash    → root_shell</pre><h3>3. Send Auditd Logs to Wazuh</h3><p>Edit the Wazuh Agent configuration:</p><pre>nano /var/ossec/etc/ossec.conf</pre><p>Add:</p><pre>&lt;localfile&gt;<br>  &lt;log_format&gt;audit&lt;/log_format&gt;<br>  &lt;location&gt;/var/log/audit/audit.log&lt;/location&gt;<br>&lt;/localfile&gt;</pre><p>Restart the agent:</p><pre>systemctl restart wazuh-agent</pre><p>Now the Wazuh Agent will read the Auditd log and send the events to the Wazuh Manager.</p><h3>4. Create Wazuh Detection Rules</h3><p>On the Wazuh Manager:</p><pre>nano /var/ossec/etc/rules/local_rules.xml</pre><p>Add:</p><pre>&lt;group name=&quot;malicious_commands&quot;&gt;<br>&lt;rule id=&quot;100200&quot; level=&quot;13&quot;&gt;<br>    &lt;if_sid&gt;80700&lt;/if_sid&gt;<br>    &lt;field name=&quot;audit.key&quot;&gt;netcat_exec&lt;/field&gt;<br>    &lt;description&gt;Netcat execution detected&lt;/description&gt;<br>    &lt;mitre&gt;T1046&lt;/mitre&gt;<br>  &lt;/rule&gt;<br>  &lt;rule id=&quot;100201&quot; level=&quot;12&quot;&gt;<br>    &lt;if_sid&gt;80700&lt;/if_sid&gt;<br>    &lt;field name=&quot;audit.key&quot;&gt;data_exfil&lt;/field&gt;<br>    &lt;description&gt;Potential data exfiltration command executed&lt;/description&gt;<br>    &lt;mitre&gt;T1041&lt;/mitre&gt;<br>  &lt;/rule&gt;<br>  &lt;rule id=&quot;100202&quot; level=&quot;12&quot;&gt;<br>    &lt;if_sid&gt;80700&lt;/if_sid&gt;<br>    &lt;field name=&quot;audit.key&quot;&gt;script_exec&lt;/field&gt;<br>    &lt;description&gt;Scripting language execution detected&lt;/description&gt;<br>    &lt;mitre&gt;T1059&lt;/mitre&gt;<br>  &lt;/rule&gt;<br>&lt;/group&gt;<br>&lt;group name=&quot;privilege_escalation&quot;&gt;<br>  &lt;rule id=&quot;100101&quot; level=&quot;14&quot;&gt;<br>    &lt;if_sid&gt;80700&lt;/if_sid&gt;<br>    &lt;field name=&quot;audit.key&quot;&gt;su_exec&lt;/field&gt;<br>    &lt;description&gt;su command executed – root shell attempt&lt;/description&gt;<br>    &lt;mitre&gt;T1548&lt;/mitre&gt;<br>  &lt;/rule&gt;<br>&lt;/group&gt;</pre><h4><strong><em>Restart the manager:</em></strong></h4><pre>systemctl restart wazuh-manager</pre><h3>5. Test the Detection</h3><p>Now run commands on your Linux test machine.</p><p>For example:</p><pre>nmap 127.0.0.1</pre><pre>curl https://example.com</pre><pre>sudo id</pre><p>You can also check Auditd directly:</p><pre>ausearch -k recon_exec</pre><p>or:</p><pre>ausearch -k data_exfil</pre><p>Wazuh should process these events and generate alerts when the configured rules matchUse this caption:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3mDmxL_0pcRHREnlO8MPOg.png" /><figcaption><strong><em>Wazuh alert generated from Linux command execution detected by Auditd</em></strong></figcaption></figure><h3>What I Learned</h3><p>This project helped me understand how Linux command execution can be monitored using Auditd and converted into useful SIEM alerts with Wazuh.</p><p>The main idea is:</p><pre>Auditd = Collect events<br>Wazuh Agent = Send events<br>Wazuh Manager = Detect activity</pre><p>This can be expanded later by monitoring command arguments, users, parent processes, network connections, and other suspicious behavior.</p><h3>Conclusion</h3><p>Detecting malicious activity does not always require a complicated system.</p><p>With <strong>Auditd + Wazuh</strong>, we can create a simple Linux monitoring pipeline that detects selected command executions and generates security alerts.</p><p>This project is a small example of how endpoint logs can be turned into practical SOC detections.</p><h3>GitHub</h3><p><a href="https://github.com/jaseervk/Malicious-Command-Execution-Detection-Linux">https://github.com/jaseervk/Malicious-Command-Execution-Detection-Linux</a></p><h3><strong>Other Digital presences:</strong></h3><ul><li><strong>Buy Me a Coffee:</strong> <a href="https://www.buymeacoffee.com/jaseervk">buymeacoffee.com/jaseervk</a></li><li><strong>GitHub:</strong> <a href="https://github.com/jaseervk">github.com/jaseervk</a></li><li><strong>Portfolio:</strong> <a href="https://www.jaseervk.com/">www.jaseervk.com</a></li><li><strong>Blog:</strong> <a href="https://blog.jaseervk.com/">blog.jaseervk.com</a></li><li><strong>LinkedIn:</strong> <a href="https://www.linkedin.com/in/jaseer-vk-/">linkedin.com/in/jaseer-vk-</a></li></ul><p>#Cybersecurity #Linux #Wazuh #Auditd #SIEM #SOC #DetectionEngineering</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ebc4c01abec4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Detecting SSH Brute-Force Attacks with Wazuh SIEM: A Step-by-Step Lab Guide]]></title>
            <link>https://medium.com/@jaseervk321/detecting-ssh-brute-force-attacks-with-wazuh-siem-a-step-by-step-lab-guide-513a50416f03?source=rss-949defe7d91e------2</link>
            <guid isPermaLink="false">https://medium.com/p/513a50416f03</guid>
            <category><![CDATA[wazuh]]></category>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[beginners-guide]]></category>
            <category><![CDATA[brute-force]]></category>
            <category><![CDATA[soc]]></category>
            <dc:creator><![CDATA[Jaseer VK]]></dc:creator>
            <pubDate>Sun, 27 Sep 2026 10:57:56 GMT</pubDate>
            <atom:updated>2026-09-27T10:57:56.742Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>In today’s threat landscape, Secure Shell (SSH) is one of the most common entry points for attackers. Threat actors and automated botnets constantly scan the internet for exposed SSH ports, attempting brute-force attacks to gain unauthorized access to critical servers.</p><p>As a cybersecurity professional or SOC analyst, being able to detect and respond to these attacks is a fundamental skill. In this blog post, we will walk through a hands-on lab on how to detect <strong>SSH brute-force attacks</strong> using <strong>Wazuh</strong>, a powerful open-source Security Information and Event Management (SIEM) and Extended Detection and Response (XDR) platform.</p><p>By the end of this guide, you will understand how Wazuh monitors system logs, how to create custom correlation rules, how to simulate an SSH brute-force attack, and how to analyze the resulting security alerts in the Wazuh dashboard.</p><h3>🛠️ Prerequisites</h3><p>To follow along with this lab in your own environment, you will need the following setup:</p><ul><li><strong>Wazuh Server:</strong> A functional Wazuh Manager and Dashboard installed (e.g., on an Ubuntu VM).</li><li><strong>Target Machine (Wazuh Agent):</strong> A Linux virtual machine (Ubuntu/Debian) with the Wazuh agent installed and enrolled in the manager. SSH must be enabled on this machine.</li><li><strong>Attacker Machine:</strong> A Kali Linux VM to simulate the brute-force attack.</li><li><strong>Tools Used:</strong> Hydra (Pre-installed on Kali Linux) and a wordlist (like rockyou.txt).</li></ul><h3>🚀 Step-by-Step Guide</h3><h3>Phase 1: Deploying the Wazuh Agent</h3><p>To detect attacks on our target server, we first need to ensure the Wazuh agent is actively monitoring it.</p><ol><li>Log in to your Wazuh Dashboard.</li><li>Navigate to <strong>Wazuh &gt; Agents &gt; Deploy new agent</strong>.</li><li>Select your target operating system (e.g., Debian/Ubuntu), specify the Wazuh Manager’s IP address, and assign an agent name.</li><li>Run the generated command on your Target Machine to install the agent.</li><li>Start and enable the Wazuh service on the target machine:</li></ol><pre>sudo systemctl daemon-reload<br>sudo systemctl enable wazuh-agent<br>sudo systemctl start wazuh-agent</pre><h3>Phase 2: Configuring Log Collection</h3><p>Wazuh detects SSH anomalies by parsing the Linux authentication logs. We need to verify that the Wazuh agent is configured to monitor these logs.</p><ul><li>On the Target Machine, open the Wazuh agent configuration file:</li></ul><pre>sudo nano /var/ossec/etc/ossec.conf</pre><ul><li>Scroll down to the &lt;localfile&gt; section. Ensure that /var/log/auth.log (or /var/log/secure for RHEL/CentOS) is being actively monitored:</li></ul><pre>&lt;localfile&gt;<br>  &lt;log_format&gt;syslog&lt;/log_format&gt;<br>  &lt;location&gt;/var/log/auth.log&lt;/location&gt;<br>&lt;/localfile&gt;</pre><ul><li>If you made any changes, restart the agent:</li></ul><pre>sudo systemctl restart wazuh-agent</pre><h3>Phase 3: Creating a Custom Correlation Rule</h3><p>While Wazuh has excellent out-of-the-box rules, writing a custom correlation rule allows us to define exactly what constitutes a high-severity brute-force attack in our specific environment. We are going to create a rule that triggers a Level 12 alert if it detects 8 failed logins within 60 seconds from the exact same IP address.</p><ul><li>On your <strong>Wazuh Manager</strong> (not the agent), open the local rules configuration file:</li></ul><pre>sudo nano /var/ossec/etc/rules/local_rules.xml</pre><ul><li>Add the following custom XML block to the file:</li></ul><pre>&lt;group name=&quot;ssh_bruteforce,&quot;&gt;<br>  &lt;!-- Fast brute force: 8 failed logins in 60 seconds from same IP --&gt;<br>  &lt;rule id=&quot;100500&quot; level=&quot;12&quot;&gt;<br>    &lt;if_matched_sid&gt;5710&lt;/if_matched_sid&gt;<br>    &lt;frequency&gt;8&lt;/frequency&gt;<br>    &lt;timeframe&gt;60&lt;/timeframe&gt;<br>    &lt;same_source_ip /&gt;<br>    &lt;description&gt;SSH brute force detected - 8 failures in 60 seconds from same IP&lt;/description&gt;<br>    &lt;mitre&gt;<br>      &lt;id&gt;T1110&lt;/id&gt;<br>      &lt;tactic&gt;Credential Access&lt;/tactic&gt;<br>    &lt;/mitre&gt;<br>  &lt;/rule&gt;<br>&lt;/group&gt;</pre><ul><li>Save the file and restart the Wazuh Manager to apply the new rule:</li></ul><pre>sudo systemctl restart wazuh-manager</pre><h3>Phase 4: Attack Simulation (The Red Team Phase)</h3><p>Now that our defenses and custom rules are active, let’s switch to our Kali Linux machine and simulate a brute-force attack using <strong>Hydra</strong>.</p><p>Hydra is a powerful network logon cracker. We will use a dummy username and a password list to bombard the target’s SSH service.</p><p>Run the following command on your Kali Linux VM:</p><pre>hydra -l admin -P /usr/share/wordlists/rockyou.txt ssh://&lt;TARGET_IP_ADDRESS&gt;</pre><p><em>(Note: Replace </em>&lt;TARGET_IP_ADDRESS&gt;<em> with the IP of your Ubuntu target machine).</em></p><p>Hydra will immediately begin sending multiple login requests to the target server. Because the passwords in the list are incorrect, the target server will register these as rapid, failed login attempts.</p><h3>Phase 5: Threat Detection (The Blue Team Phase)</h3><p>With the attack underway, let’s switch back to our Wazuh Dashboard to see how the SIEM handles this malicious activity.</p><ul><li>Open the Wazuh Dashboard and navigate to the <strong>Security events</strong> module.</li><li>Filter the events by the agent’s name.</li><li>You will immediately notice a spike in alerts.</li></ul><figure><img alt="Wazuh Dashboard showing the spike in security events" src="https://cdn-images-1.medium.com/max/1024/1*uJWzy50vme0IsiUSo73WgQ.png" /></figure><p>Look closely at the logs. You will see the standard rules firing, culminating in our new custom alert:</p><ul><li><strong>Rule 5716 (Level 5):</strong> SSHD: authentication failed. — This triggers for every individual wrong password guess.</li><li><strong>Rule 5710 (Level 5):</strong> Attempt to login using a non-existent user — This triggers if the username we used in Hydra doesn&#39;t exist on the system.</li><li><strong>Rule 100500 (Level 12):</strong> SSH brute force detected - 8 failures in 60 seconds from same IP — <strong>This is our custom rule in action.</strong> Wazuh successfully correlated the rapid succession of failed attempts and mapped it directly to the MITRE ATT&amp;CK framework (T1110 - Credential Access).</li></ul><h3>🎯 Testing &amp; Validation Summary</h3><p>To validate that your detection pipeline works flawlessly:</p><ul><li><strong>Verify Log Ingestion:</strong> Check /var/log/auth.log on the target machine manually using tail -f /var/log/auth.log while running Hydra. You should see the failed SSH attempts flooding the file.</li><li><strong>Verify Correlation:</strong> Ensure that Rule 100500 fires in Wazuh. If you only see isolated 5710 or 5716 rules but no Level 12 alert, verify that there are no typos in your local_rules.xml file and that you restarted the manager.</li><li><strong>Analyze the Payload:</strong> Expand the JSON payload of the alert in Wazuh. You should clearly see the <strong>srcip</strong> (your Kali VM’s IP) and the targeted port (22), giving you the exact intelligence needed to block the attacker in a real-world scenario.</li></ul><p>In this project, we successfully configured Wazuh SIEM to monitor Linux authentication logs, authored a custom correlation rule mapping to the MITRE ATT&amp;CK framework, and validated the system against a real-world SSH brute-force attack using Hydra.</p><p>For SOC analysts, establishing this kind of visibility is step one. The logical next step (and a great follow-up project!) is configuring <strong>Wazuh Active Response</strong> to automatically execute a firewall rule to drop the attacker’s IP address as soon as Rule 100500 is triggered.</p><p><strong>Want to check out the project files or replicate this in your own lab?</strong></p><p>Head over to my GitHub repository for the full details:</p><p>🔗 <a href="https://github.com/jaseervk/SSH-Bruteforce-detection-using-Wazuh-SIEM?utm_source=gemini">SSH Bruteforce Detection Using Wazuh SIEM</a></p><h4><strong>Other Digital Presence</strong></h4><ul><li><strong>Buy Me a Coffee:</strong> <a href="https://www.buymeacoffee.com/jaseervk">buymeacoffee.com/jaseervk</a></li><li><strong>GitHub:</strong> <a href="https://github.com/jaseervk">github.com/jaseervk</a></li><li><strong>Portfolio:</strong> <a href="http://www.jaseervk.com/">www.jaseervk.com</a></li><li><strong>Blog:</strong> <a href="https://blog.jaseervk.com/">blog.jaseervk.com</a></li><li><strong>LinkedIn:</strong> <a href="https://www.linkedin.com/in/jaseer-vk-/">linkedin.com/in/jaseer-vk-</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=513a50416f03" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Build a Powerful Network Intrusion Detection System (NIDS) using Suricata and Wazuh SIEM]]></title>
            <link>https://medium.com/@jaseervk321/how-to-build-a-powerful-network-intrusion-detection-system-nids-using-suricata-and-wazuh-siem-366c586edf7a?source=rss-949defe7d91e------2</link>
            <guid isPermaLink="false">https://medium.com/p/366c586edf7a</guid>
            <category><![CDATA[wazuh]]></category>
            <category><![CDATA[id]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[soc]]></category>
            <category><![CDATA[suricata]]></category>
            <dc:creator><![CDATA[Jaseer VK]]></dc:creator>
            <pubDate>Thu, 24 Sep 2026 17:14:07 GMT</pubDate>
            <atom:updated>2026-09-24T17:19:25.983Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Introduction</strong></h3><p>In today’s highly connected world, keeping your network safe from cyber threats is more important than ever. Whether you are a cybersecurity enthusiast, a student, or an IT professional, understanding how to monitor your network for malicious activity is a must-have skill.</p><p>In this blog, I am going to walk you through my project: <strong>Building a Network Intrusion Detection System (NIDS) using Suricata IDS and Wazuh SIEM.</strong></p><p>By the end of this guide, you will have a working setup that detects suspicious network traffic (like Nmap scans) and instantly reports it to a beautiful security dashboard.</p><p>You can find the complete project files and documentation in my GitHub repository here:</p><p>👉 <a href="https://github.com/jaseervk/Network-Intrusion-Detection-using-Suricata-IDS-Wazuh-SIEM-?utm_source=gemini"><strong>Network Intrusion Detection using Suricata &amp; Wazuh</strong></a></p><h3>What are Suricata and Wazuh?</h3><ul><li><strong>Suricata</strong> is an open-source Intrusion Detection System (IDS). Think of it as a security guard monitoring your network traffic for known bad behavior.</li><li><strong>Wazuh</strong> is a Security Information and Event Management (SIEM) tool. It acts as the central brain, collecting logs from Suricata, analyzing them, and presenting them in an easy-to-read dashboard.</li></ul><h3>Step 1: Forwarding Suricata Logs from the Wazuh Agent</h3><p>Once Suricata is installed on your target machine, it writes its alerts to a log file (usually eve.json). We need to tell the Wazuh Agent to read this file and send it to the Wazuh Manager.</p><p>Open the Wazuh Agent configuration file on your monitored machine:</p><p>Bash</p><pre>nano /var/ossec/etc/ossec.config</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dGlsZIAz5F9CChZyQkqEfQ.png" /></figure><p>Add the following block to monitor the Suricata JSON and fast logs:</p><pre>&lt;!-- ADD SURICATA LOG MONITORING --&gt;<br>&lt;localfile&gt;<br>  &lt;log_format&gt;json&lt;/log_format&gt;<br>  &lt;location&gt;/var/log/suricata/eve.json&lt;/location&gt;<br>&lt;/localfile&gt;<br><br>&lt;localfile&gt;<br>  &lt;log_format&gt;json&lt;/log_format&gt;<br>  &lt;location&gt;/var/log/suricata/fast.log&lt;/location&gt;<br>&lt;/localfile&gt;</pre><p>Save the file, and then restart the Wazuh Agent service to apply the changes</p><pre>systemctl restart wazuh-agent</pre><p><em>Configuring the Wazuh Agent to read Suricata logs.</em></p><h3>Step 2: Adding Custom Rules to the Wazuh Manager</h3><p>Now that the agent is sending logs, the Wazuh Manager needs a custom rule to properly identify and escalate specific attacks, such as an Nmap scan.</p><p>On your Wazuh Manager server, open the local rules file:</p><pre>nano /var/ossec/etc/rules/local_rules.xml</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rTYHWlxPsRTGI5AJ1iSzFA.png" /></figure><p>Add the following custom rule to detect Nmap scans identified by Suricata:</p><pre>&lt;!-- Suricata: Nmap scan detection --&gt;<br>&lt;rule id=&quot;100200&quot; level=&quot;12&quot;&gt;<br>  &lt;if_group&gt;suricata&lt;/if_group&gt;<br>  &lt;field name=&quot;alert.signature&quot;&gt;^ET SCAN.*Nmap&lt;/field&gt;<br>  &lt;description&gt;Nmap scan detected by Suricata: $(alert.signature)&lt;/description&gt;<br>  &lt;group&gt;attack,network_scan,mitre_t1046&lt;/group&gt;<br>&lt;/rule&gt;</pre><p>Make sure the manager’s ossec.config is also set up to parse the incoming logs, then restart the Wazuh Manager[cite: 5]:</p><p>Bash</p><pre>systemctl restart wazuh-manager</pre><p><em>Adding custom rules to the Wazuh Manager to detect Nmap scans.</em></p><h3>Step 3: Simulating an Attack (The Fun Part!)</h3><p>It’s time to see our creation in action. We are going to trigger a fake attack by running a stealth Nmap scan against our monitored machine.</p><p>From an attacker machine (or your terminal), run the following command, replacing the IP with your target’s IP address:</p><pre>nmap -sS &lt;victim_ip&gt;</pre><p><em>Executing a stealth Nmap scan to trigger the IDS.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_qgxKJGxjLbhNY9iEaSQng.png" /></figure><h3>Step 4: Viewing the Alerts in the Wazuh Dashboard</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OAkP51ZUjCm8-C5Mca59dQ.png" /></figure><p>Now, log into your Wazuh Web Dashboard and navigate to the <strong>Security Events</strong> module.</p><p>Because of the rules we configured, you will immediately see high-level alerts popping up. The dashboard will show a <strong>“Nmap Scan Detected”</strong> event with Rule ID 100600[cite: 2]. Suricata detected the scan, generated the log, and the Wazuh Agent pushed it to the SIEM in real-time!</p><p><em>Wazuh dashboard successfully displaying the detected Nmap scan events.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4cvrh3y6fo18u8ujnUo2iA.png" /></figure><p>You can click on these events to see the <strong>Document Details</strong>. This detailed view provides crucial forensic information, such as highlighting the exact source IP (data.flow.src_ip) of the attacker and the specific signature triggered (e.g., &quot;ET SCAN Suspicious inbound to Oracle SQL port 1521&quot;)</p><p><em>Detailed alert document showing the attacker’s source IP and the specific Suricata signature.</em></p><h3>Conclusion</h3><p>Congratulations! You have successfully integrated Suricata IDS with Wazuh SIEM. This setup is incredibly powerful and is used by real-world Security Operations Centers (SOCs) to monitor network traffic, detect reconnaissance scans, and stop intrusions.</p><p>Cybersecurity is all about visibility — you can’t protect what you can’t see. By combining Wazuh and Suricata, you give yourself a pair of x-ray glasses for your network.</p><p>If you found this guide helpful or want to dive deeper into the code, check out the complete project on my GitHub:</p><p>🔗 <a href="https://github.com/jaseervk/Network-Intrusion-Detection-using-Suricata-IDS-Wazuh-SIEM-?utm_source=gemini"><strong>jaseervk / Network-Intrusion-Detection-using-Suricata-IDS-Wazuh-SIEM-</strong></a></p><p>Feel free to star ⭐ the repository if it helps you out, or leave a comment below if you have any questions!</p><p><em>If you love my content and want to support my cybersecurity journey, consider buying me a coffee!</em></p><h4><strong>Other digital presences</strong></h4><p>buymeacoffee.com/jaseervk</p><p>https://github.com/jaseervk</p><p><a href="http://www.jaseervk.com/">www.jaseervk.com</a></p><p>blog.jaseervk.com</p><p><a href="https://www.linkedin.com/in/jaseer-vk-/">https://www.linkedin.com/in/jaseer-vk-/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=366c586edf7a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Real-Time File Integrity Monitoring (FIM) with Wazuh: A Hands-On Guide]]></title>
            <link>https://medium.com/@jaseervk321/real-time-file-integrity-monitoring-fim-with-wazuh-a-hands-on-guide-9f8f216889b0?source=rss-949defe7d91e------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f8f216889b0</guid>
            <category><![CDATA[file-integrity-monitoring]]></category>
            <category><![CDATA[soc]]></category>
            <category><![CDATA[wazuh]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Jaseer VK]]></dc:creator>
            <pubDate>Wed, 23 Sep 2026 14:46:50 GMT</pubDate>
            <atom:updated>2026-09-23T14:46:50.100Z</atom:updated>
            <content:encoded><![CDATA[<p>File Integrity Monitoring (FIM) is an essential security control for detecting unauthorized file alterations, backdoor creation, and privilege escalation attempts. While default detection capabilities flag changes across generic paths, tailoring custom server rules and real-time directory monitoring turns Wazuh into a high-precision intrusion detection engine.</p><p>This step-by-step walkthrough covers configuring custom severity rules on the Wazuh Server, enabling real-time monitoring on an endpoint agent, and verifying detection using a simulated file creation attack.</p><h3>Architecture Overview</h3><p>Before diving into the code, here is a quick look at how the FIM process flows from the endpoint to your dashboard:</p><pre>Linux Endpoint<br>    |<br>    v<br>Wazuh Agent (ossec.conf)<br>    |<br>    | Real-time directory monitoring<br>    v<br>Wazuh Manager (local_rules.xml)<br>    |<br>    | Evaluates file hashes &amp; triggers alerts<br>    v<br>Wazuh Dashboard<br>    |<br>    v<br>SOC Analyst / Admin</pre><p>Wazuh handles this through a two-sided mechanism:</p><ul><li><strong>The Agent (</strong>ossec.conf<strong>):</strong> Scans selected directories using the syscheck engine, generates file hashes, checks attributes, and monitors directories in real-time.</li><li><strong>The Manager (</strong>local_rules.xml<strong>):</strong> Ingests syscheck events from agents and evaluates them against custom rules, elevating alert levels when sensitive directories—such as /root—are touched.</li></ul><h3>Step 1: Configure Custom Server-Side Alert Rules</h3><p>To ensure modifications to critical paths generate high-severity alerts instead of low-level generic notifications, define custom rules on the Wazuh Manager.</p><p>Open the custom rules configuration file on your <strong>Wazuh Manager</strong>:</p><pre>sudo nano /var/ossec/etc/rules/local_rules.xml</pre><p>Add the following rule groups inside the configuration file. You can easily copy the code block below:</p><pre>&lt;group name=&quot;syscheck,&quot;&gt;<br>  &lt;!-- File created --&gt;<br>  &lt;rule id=&quot;100010&quot; level=&quot;10&quot;&gt;<br>    &lt;if_sid&gt;554&lt;/if_sid&gt;<br>    &lt;description&gt;FIM: File created in $(directory) - $(file)&lt;/description&gt;<br>  &lt;/rule&gt;<br><br>&lt;!-- File deleted --&gt;<br>  &lt;rule id=&quot;100011&quot; level=&quot;10&quot;&gt;<br>    &lt;if_sid&gt;553&lt;/if_sid&gt;<br>    &lt;description&gt;FIM: File deleted from $(directory) - $(file)&lt;/description&gt;<br>  &lt;/rule&gt;<br><br>  &lt;!-- File modified --&gt;<br>  &lt;rule id=&quot;100012&quot; level=&quot;8&quot;&gt;<br>    &lt;if_sid&gt;550&lt;/if_sid&gt;<br>    &lt;description&gt;FIM: File modified in $(directory) - $(file)&lt;/description&gt;<br>  &lt;/rule&gt;<br>&lt;/group&gt;<br>&lt;group name=&quot;syscheck,root_monitoring,&quot;&gt;<br><br>  &lt;!-- File created in /root --&gt;<br>  &lt;rule id=&quot;100020&quot; level=&quot;12&quot;&gt;<br>    &lt;if_sid&gt;554&lt;/if_sid&gt;<br>    &lt;match&gt;^/root&lt;/match&gt;<br>    &lt;description&gt;CRITICAL FIM: File created in /root - $(file)&lt;/description&gt;<br>  &lt;/rule&gt;<br><br>  &lt;!-- File deleted from /root --&gt;<br>  &lt;rule id=&quot;100021&quot; level=&quot;12&quot;&gt;<br>    &lt;if_sid&gt;553&lt;/if_sid&gt;<br>    &lt;match&gt;^/root&lt;/match&gt;<br>    &lt;description&gt;CRITICAL FIM: File deleted from /root - $(file)&lt;/description&gt;<br>  &lt;/rule&gt;<br><br>  &lt;!-- File modified in /root --&gt;<br>  &lt;rule id=&quot;100022&quot; level=&quot;10&quot;&gt;<br>    &lt;if_sid&gt;550&lt;/if_sid&gt;<br>    &lt;match&gt;^/root&lt;/match&gt;<br>    &lt;description&gt;CRITICAL FIM: File modified in /root - $(file)&lt;/description&gt;<br>  &lt;/rule&gt;<br>&lt;/group&gt;</pre><blockquote><strong><em>Why this matters:</em></strong><em> Built-in rules map file addition to rule ID </em><em>554, deletion to </em><em>553, and modification to </em><em>550. By setting parent matches (</em><em>if_sid) and targeting the </em><em>/root path regex, operations inside the root home directory immediately jump to severity </em><strong><em>Level 12 (Critical)</em></strong><em>.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S7wfqrkEA75AtZ9GDJq7KQ.png" /></figure><p>Restart the Wazuh Manager to apply the updated ruleset:</p><pre>sudo systemctl restart wazuh-manager</pre><h3>Step 2: Configure Real-Time Monitoring on the Agent</h3><p>Next, configure the endpoint machine to track the /root directory alongside critical system binaries in real-time.</p><p>Log in to the <strong>monitored endpoint agent</strong> and edit its local configuration:</p><pre>sudo nano /var/ossec/etc/ossec.conf</pre><p>Locate the &lt;syscheck&gt; block and ensure the target paths are declared with real-time inspection and change reporting enabled. Copy and paste the directory tags below:</p><p>XML</p><pre>&lt;syscheck&gt;<br>  &lt;frequency&gt;43200&lt;/frequency&gt;<br>  &lt;scan_on_start&gt;yes&lt;/scan_on_start&gt;<br><br>&lt;!-- System directories --&gt;<br>  &lt;directories check_all=&quot;yes&quot; realtime=&quot;yes&quot; change_report=&quot;yes&quot;&gt;/etc&lt;/directories&gt;<br>  &lt;directories check_all=&quot;yes&quot; realtime=&quot;yes&quot; change_report=&quot;yes&quot;&gt;/usr/bin&lt;/directories&gt;<br>  &lt;directories check_all=&quot;yes&quot; realtime=&quot;yes&quot; change_report=&quot;yes&quot;&gt;/usr/sbin&lt;/directories&gt;<br><br>  &lt;!-- Monitored Root Directory --&gt;<br>  &lt;directories check_all=&quot;yes&quot; realtime=&quot;yes&quot; change_report=&quot;yes&quot;&gt;/root&lt;/directories&gt;<br>&lt;/syscheck&gt;</pre><p><strong>Attributes breakdown:</strong></p><ul><li>check_all=&quot;yes&quot;: Checks md5, sha1, sha256 hashes, file size, owner, group, and permissions.</li><li>realtime=&quot;yes&quot;: Uses kernel inotify mechanisms to send immediate alerts without waiting for scheduled scans.</li><li>change_report=&quot;yes&quot;: Records the exact diff of what changed inside text files.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jSRgqOD0F49hFfBwNDBznQ.png" /></figure><p>Save the file and restart the Wazuh Agent daemon:</p><pre>sudo systemctl restart wazuh-agent</pre><h3>Step 3: Simulate Unauthorized File Activity</h3><p>With both sides configured and daemons active, simulate an unauthorized access scenario where an attacker drops a payload or creates files inside /root.</p><p>Execute the following commands sequentially on the monitored agent:</p><pre>cd /<br>cd root<br>touch 1.txt</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a8PsmyTyaDSdPHAAyCnXUw.png" /></figure><h3>Step 4: Verify Alerts in the Wazuh Dashboard</h3><p>Once the file creation command executes:</p><ul><li>Open your browser and access the <strong>Wazuh Dashboard</strong>.</li><li>Navigate to <strong>Modules</strong> &gt; <strong>Integrity Monitoring</strong> &gt; <strong>Events</strong>.</li><li>Filter by your target agent name.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w5jEV6AkS5mL0IZ2hSuSCg.png" /></figure><h3>Expected Alert Output</h3><ul><li><strong>Rule ID:</strong> 100020</li><li><strong>Rule Level:</strong> 12 (Critical)</li><li><strong>Description:</strong> CRITICAL FIM: File created in /root - /root/1.txt</li><li><strong>Path:</strong> /root/1.txt</li><li><strong>Action:</strong> added</li></ul><p>Because realtime=&quot;yes&quot; was set in ossec.conf, the alert populates instantaneously on the dashboard without waiting for the default 12-hour syscheck scan cycle.</p><p>Implementing targeted FIM rules on sensitive locations prevents stealthy credential harvesting, authorized binary tampering, and staging directory misuse. By coupling custom manager rule IDs with real-time directory watches, critical intrusions are caught within seconds.</p><h3>Support My Work!</h3><p>If this tutorial helped you set up File Integrity Monitoring in your home lab or production environment, consider supporting future open-source cybersecurity writeups!</p><p>buymeacoffee.com/jaseervk</p><p><a href="http://www.jaseervk.com/">www.jaseervk.com</a></p><p><a href="https://www.linkedin.com/in/jaseer-vk-/">https://www.linkedin.com/in/jaseer-vk-/</a></p><p><a href="https://github.com/jaseervk">https://github.com/jaseervk</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9f8f216889b0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automating Malware Detection with Wazuh and VirusTotal]]></title>
            <link>https://medium.com/@jaseervk321/automating-malware-detection-with-wazuh-and-virustotal-a04be69f14dc?source=rss-949defe7d91e------2</link>
            <guid isPermaLink="false">https://medium.com/p/a04be69f14dc</guid>
            <category><![CDATA[soc]]></category>
            <category><![CDATA[virustotal]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[siem]]></category>
            <category><![CDATA[wazuh]]></category>
            <dc:creator><![CDATA[Jaseer VK]]></dc:creator>
            <pubDate>Sun, 23 Aug 2026 16:03:41 GMT</pubDate>
            <atom:updated>2026-08-23T16:03:41.087Z</atom:updated>
            <content:encoded><![CDATA[<h3>From File Integrity Monitoring to Automated Threat Intelligence</h3><p>A file appearing on a Linux endpoint is not automatically malicious.</p><p>It could be a legitimate application update, a configuration change, a script created by an administrator, or something much more suspicious.</p><p>The challenge for a SOC analyst is determining which events deserve investigation.</p><p>During one of my SOC projects, I worked on a simple way to automate the first stage of that investigation by integrating <strong>Wazuh SIEM with VirusTotal</strong>.</p><p>The idea was straightforward:</p><blockquote><em>Detect a new file on an endpoint, obtain its hash, check that hash against VirusTotal, and bring the threat-intelligence result back into Wazuh.</em></blockquote><p>The project combines <strong>File Integrity Monitoring (FIM)</strong> with external threat intelligence to make file-related alerts more useful for security monitoring.</p><p>GitHub repository:</p><p><a href="https://github.com/jaseervk/Wazuh-SIEM-VirusTotal-Automated-Malware-Detection">GitHub - jaseervk/Wazuh-SIEM-VirusTotal-Automated-Malware-Detection: Automating malware detection by integrating Wazuh SIEM with the VirusTotal API. Features real-time File Integrity Monitoring (FIM) and automated threat intelligence enrichment.</a></p><h3>What I Wanted to Achieve</h3><p>In a normal SOC workflow, an analyst may receive an alert indicating that a file was created or modified.</p><p>The analyst then has to manually investigate the file:</p><ol><li>Identify the file.</li><li>Calculate its hash.</li><li>Search the hash in VirusTotal.</li><li>Review the detection results.</li><li>Decide whether further investigation is required.</li></ol><p>Doing this manually for every file event is inefficient.</p><p>I wanted to automate the enrichment step.</p><p>The workflow I implemented was:</p><pre>Linux Endpoint<br>      |<br>      v<br>Wazuh Agent<br>      |<br>      | File Integrity Monitoring<br>      v<br>Wazuh Manager<br>      |<br>      | File hash<br>      v<br>VirusTotal API<br>      |<br>      | Threat intelligence<br>      v<br>Wazuh Alert<br>      |<br>      v<br>SOC Analyst</pre><p>The repository describes the same basic workflow: the Wazuh agent detects a new file, the manager extracts the file information and queries VirusTotal, and an alert is generated when the file is flagged.</p><h3>Technologies Used</h3><ul><li>Wazuh SIEM</li><li>Wazuh Agent</li><li>Wazuh Manager</li><li>File Integrity Monitoring (FIM)</li><li>VirusTotal API</li><li>Linux</li><li>XML-based Wazuh configuration</li><li>EICAR test file(Malicious File)</li></ul><h3>Lab Architecture</h3><p>The project uses a Linux endpoint running the Wazuh agent and a Wazuh manager responsible for processing the events.</p><p>The supporting FIM project uses this general architecture:</p><pre>Linux Endpoint<br>      |<br>Wazuh Agent<br>      |<br>Wazuh Manager<br>      |<br>Elasticsearch<br>      |<br>Wazuh Dashboard</pre><p>The FIM repository describes this architecture and uses Wazuh to monitor filesystem changes on Linux systems.</p><p>For this project, the important part is what happens after the FIM event reaches the manager:</p><pre>FIM Event<br>   |<br>   v<br>VirusTotal Integration<br>   |<br>   v<br>Threat Intelligence<br>   |<br>   v<br>Security Alert</pre><h3>Step 1: Configure Wazuh File Integrity Monitoring</h3><p>Before integrating VirusTotal, the Wazuh agent must be able to detect filesystem changes.</p><p>The VirusTotal project explicitly refers to a separate FIM project for this configuration.</p><p>The agent configuration used in the supporting FIM project contains:</p><p>File Location : /var/ossec/etc/ossec.conf</p><pre>&lt;ossec_config&gt;<br>  &lt;client&gt;<br>    &lt;server&gt;<br>      &lt;address&gt;server_ip&lt;/address&gt;<br>      &lt;port&gt;1514&lt;/port&gt;<br>      &lt;protocol&gt;tcp&lt;/protocol&gt;<br>    &lt;/server&gt;<br>  &lt;/client&gt;<br><br>&lt;syscheck&gt; &lt;frequency&gt;43200&lt;/frequency&gt; <br>&lt;scan_on_start&gt;yes&lt;/scan_on_start&gt; <br>&lt;directories check_all=&quot;yes&quot; realtime=&quot;yes&quot; change_report=&quot;yes&quot;&gt;/etc&lt;/directories&gt;<br>&lt;directories check_all=&quot;yes&quot; realtime=&quot;yes&quot; change_report=&quot;yes&quot;&gt;/usr/bin&lt;/directories&gt;<br>&lt;directories check_all=&quot;yes&quot; realtime=&quot;yes&quot; change_report=&quot;yes&quot;&gt;/usr/sbin&lt;/directories&gt; <br>&lt;directories check_all=&quot;yes&quot; realtime=&quot;yes&quot; change_report=&quot;yes&quot;&gt;/root&lt;/directories&gt; <br>&lt;/syscheck&gt;<br><br>&lt;/ossec_config&gt;</pre><p>This configuration monitors several important Linux directories, including /root, using real-time FIM.</p><p>The critical line for this project is:</p><pre>&lt;directories check_all=&quot;yes&quot; realtime=&quot;yes&quot; change_report=&quot;yes&quot;&gt;/root&lt;/directories&gt;</pre><p>This is important because the test file will be created inside /root.</p><p>According to the current Wazuh documentation, realtime=&quot;yes&quot; enables real-time monitoring for directories on Linux.</p><h3>Step 2: Edit the Wazuh Agent Configuration</h3><p>On the Linux endpoint:</p><pre>sudo nano /var/ossec/etc/ossec.conf</pre><p>Add or update the &lt;syscheck&gt; section with the directories you want to monitor.</p><p>For this lab, the important entry is:</p><pre>&lt;syscheck&gt;<br>    &lt;frequency&gt;43200&lt;/frequency&gt;<br>    &lt;scan_on_start&gt;yes&lt;/scan_on_start&gt;<br>    &lt;directories check_all=&quot;yes&quot; realtime=&quot;yes&quot; change_report=&quot;yes&quot;&gt;/root&lt;/directories&gt;<br>&lt;/syscheck&gt;</pre><p>The project used /root because the EICAR test file was later created there.</p><h3>Step 3: Restart the Wazuh Agent</h3><p>After changing the agent configuration, restart the Wazuh agent:</p><pre>sudo systemctl restart wazuh-agent</pre><p>The current Wazuh documentation also recommends restarting the agent after changing FIM configuration.</p><p>You can verify that the service is running with:</p><pre>sudo systemctl status wazuh-agent</pre><h3>Step 4: Obtain a VirusTotal API Key</h3><p>The next component is VirusTotal.</p><p>You need a VirusTotal API key to allow the Wazuh manager to query VirusTotal.</p><p>Important</p><p>Do not publish your real API key to GitHub.</p><p>Use a placeholder such as:</p><pre>YOUR_VIRUSTOTAL_API_KEY</pre><p>when documenting the project.</p><h3>Step 5: Configure VirusTotal on the Wazuh Manager</h3><p>On the Wazuh manager:</p><pre>sudo nano /var/ossec/etc/ossec.conf</pre><p>The configuration used in my project was:</p><pre>&lt;integration&gt;<br>  &lt;name&gt;virustotal&lt;/name&gt;<br>  &lt;api_key&gt;YOUR_VIRUSTOTAL_API_KEY&lt;/api_key&gt;<br>  &lt;group&gt;syscheck&lt;/group&gt;<br>  &lt;alert_format&gt;json&lt;/alert_format&gt;<br>&lt;/integration&gt;</pre><p>The important settings are:</p><pre>&lt;name&gt;virustotal&lt;/name&gt;</pre><p>This tells Wazuh to use the VirusTotal integration.</p><pre>&lt;api_key&gt;YOUR_VIRUSTOTAL_API_KEY&lt;/api_key&gt;</pre><p>This authenticates the request to VirusTotal.</p><pre>&lt;group&gt;syscheck&lt;/group&gt;</pre><p>This associates the integration with File Integrity Monitoring events.</p><pre>&lt;alert_format&gt;json&lt;/alert_format&gt;</pre><p>This makes the event available in JSON format for processing.</p><h3>Step 6: Restart the Wazuh Manager</h3><p>After saving the manager configuration:</p><pre>sudo systemctl restart wazuh-manager</pre><p>Then check the service:</p><pre>sudo systemctl status wazuh-manager</pre><p>At this point, the main integration path is configured:</p><pre>Wazuh Agent<br>     |<br>     | FIM Event<br>     v<br>Wazuh Manager<br>     |<br>     | syscheck<br>     v<br>VirusTotal Integration</pre><h3>Step 7: Create a Test File</h3><p>For safe testing, I used the <strong>EICAR test file</strong> rather than real malware.</p><p>The EICAR file is specifically intended for testing antivirus and security controls without using actual malicious software.</p><pre>curl -Lo /root/eicar.com.txt <a href="https://secure.eicar.org/eicar.com.txt">https://secure.eicar.org/eicar.com.txt</a><br><br>ls -lah /root/eicar.com.txt</pre><p>At this point, a new file has appeared in /root.</p><p>That should trigger the FIM mechanism.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*20-3zh0vtI54QOjfW4M8qA.png" /><figcaption>Creating the EICAR test file on the monitored Wazuh agent.</figcaption></figure><h3>Step 8: Wazuh FIM Detects the File</h3><p>Once the EICAR file is created, Wazuh’s FIM component detects the new file.</p><p>This is the first stage of the automated detection process.</p><p>Conceptually:</p><pre>File Created<br>     |<br>     v<br>Wazuh FIM<br>     |<br>     v<br>syscheck Event</pre><p>This is why the FIM configuration is so important.</p><p>Without the initial FIM event, the VirusTotal enrichment step would never be triggered.</p><h3>Step 9: VirusTotal Enrichment</h3><p>After the syscheck event reaches the Wazuh manager, the VirusTotal integration can process the event.</p><p>The project was designed so that Wazuh can automatically obtain file/hash information and query VirusTotal instead of requiring the analyst to perform the lookup manually.</p><p>The conceptual workflow is:</p><pre>syscheck event<br>      |<br>      v<br>File information<br>      |<br>      v<br>File hash<br>      |<br>      v<br>VirusTotal lookup<br>      |<br>      v<br>Threat intelligence result</pre><p>This is the main value of the integration.</p><p>The original FIM event provides the evidence that a file changed.</p><p>VirusTotal provides additional reputation information.</p><h3>Step 10: View the Enriched Event</h3><p>Once VirusTotal returns information, the resulting event contains additional fields related to the file and its reputation.</p><p>These can include information such as:</p><ul><li>File path</li><li>File hash</li><li>Detection information</li><li>VirusTotal result</li><li>Related event data</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bNduTP2-zeC9-tf-aFal6Q.png" /><figcaption>Wazuh event showing file information, hash data, and VirusTotal enrichment.</figcaption></figure><p>This screenshot demonstrates the transition from a simple FIM event to an event containing additional threat-intelligence context.</p><h3>Step 11: Review the Security Alert</h3><p>The final step is viewing the resulting alert in Wazuh.</p><p>Instead of manually opening VirusTotal and searching for the file hash, the detection result is available as part of the Wazuh workflow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jx-qMacJHxLucpAYzkoK1Q.png" /><figcaption>Wazuh alert showing the VirusTotal detection result for the test file.</figcaption></figure><p>This is the most important screenshot from a SOC perspective because it shows the final outcome of the automation.</p><p>The flow has now become:</p><pre>File Created<br>     ↓<br>FIM Detects File<br>     ↓<br>Wazuh Processes Event<br>     ↓<br>VirusTotal Lookup<br>     ↓<br>Threat Intelligence Result<br>     ↓<br>Wazuh Security Alert</pre><h3>Understanding the Project From a SOC Perspective</h3><p>The most important lesson from this project is that the individual tools are not the main story.</p><p>Wazuh alone can detect file changes.</p><p>VirusTotal alone can provide file reputation.</p><p>The useful part is connecting them.</p><h3>Without automation</h3><pre>Wazuh Alert<br>     ↓<br>Analyst copies hash<br>     ↓<br>Opens VirusTotal<br>     ↓<br>Searches hash<br>     ↓<br>Reviews detections<br>     ↓<br>Makes a decision</pre><h3>With the integration</h3><pre>Wazuh Alert<br>     ↓<br>Hash / File Information<br>     ↓<br>VirusTotal API<br>     ↓<br>Enriched Wazuh Alert<br>     ↓<br>Analyst Investigation</pre><p>The analyst can therefore spend more time on investigation and less time on repetitive enrichment.</p><h3>What I Learned</h3><p>This project helped me connect several SOC concepts together.</p><h4>1. File Integrity Monitoring</h4><p>I learned how filesystem activity can be turned into security events.</p><p>FIM is especially useful for monitoring important directories where unauthorized changes could indicate malware, persistence, or other suspicious activity. Wazuh supports real-time monitoring for configured directories.</p><h4>2. Threat Intelligence</h4><p>VirusTotal adds external reputation data to endpoint events.</p><p>Instead of looking only at the fact that a file was created, the analyst can also consider whether the file is already known to security engines.</p><h4>3. SIEM Integration</h4><p>The project demonstrated how a SIEM can consume external security intelligence and use it to enrich alerts.</p><h4>4. Security Automation</h4><p>One of the most important lessons was that automation does not always require a complicated platform.</p><p>A relatively simple pipeline can provide meaningful value:</p><pre>Detect → Enrich → Alert</pre><h3>Important Security Considerations</h3><p>There are several things I would not copy directly into a production environment.</p><h4>Protect the API Key</h4><p>Never commit this:</p><pre>&lt;api_key&gt;REAL_API_KEY&lt;/api_key&gt;</pre><p>to a public repository.</p><p>Use:</p><pre>&lt;api_key&gt;YOUR_VIRUSTOTAL_API_KEY&lt;/api_key&gt;</pre><p>in documentation and keep the actual credential protected.</p><h4>Monitor Selective Directories</h4><p>Monitoring an entire filesystem can generate unnecessary events and consume resources.</p><p>A better production strategy is to identify directories where malicious file activity would be particularly important.</p><h4>Validate Automated Response</h4><p>A VirusTotal result should not automatically mean that the endpoint must be isolated.</p><p>Automated containment should be based on appropriate confidence and business context.</p><h3>Final Architecture</h3><p>The final implementation can be summarized as:</p><pre>LINUX ENDPOINT<br>                  |<br>                  |<br>             Wazuh Agent<br>                  |<br>            File Integrity<br>             Monitoring<br>                  |<br>                  v<br>            Wazuh Manager<br>                  |<br>                  |<br>            Syscheck Event<br>                  |<br>                  v<br>          VirusTotal Integration<br>                  |<br>                  v<br>            VirusTotal API<br>                  |<br>                  v<br>         Threat Intelligence<br>                  |<br>                  v<br>            Wazuh Alert<br>                  |<br>                  v<br>             SOC Analyst</pre><p>This project started with a simple question:</p><blockquote><em>Can I automatically determine whether a newly created file is suspicious instead of manually checking every file hash?</em></blockquote><p>By combining Wazuh File Integrity Monitoring with VirusTotal, I created a workflow that automatically enriches endpoint file events with external threat intelligence.</p><p>For me, the biggest takeaway was not simply learning how to configure VirusTotal in Wazuh.</p><p>It was understanding the broader SOC principle:</p><blockquote><strong><em>A detection becomes much more useful when it is automatically enriched with the context required for investigation.</em></strong></blockquote><h3>Project Resources</h3><p><strong>GitHub:</strong><br>https://github.com/jaseervk/Wazuh-SIEM-VirusTotal-Automated-Malware-Detection</p><p><strong>FIM Repository:</strong><br>https://github.com/jaseervk/File-Integrity-Monitoring-using-WAZUH</p><p><strong>Main Technologies:</strong></p><p>Wazuh · VirusTotal API · FIM · SIEM · Threat Intelligence · SOC · Linux · Security Automation</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a04be69f14dc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build an Active Directory Lab from Scratch: A Practical Guide to AD DS, GPO, Windows 10 and IIS]]></title>
            <link>https://medium.com/@jaseervk321/build-an-active-directory-lab-from-scratch-a-practical-guide-to-ad-ds-gpo-windows-10-and-iis-aeb45016621a?source=rss-949defe7d91e------2</link>
            <guid isPermaLink="false">https://medium.com/p/aeb45016621a</guid>
            <category><![CDATA[ii]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[windows]]></category>
            <category><![CDATA[active-directory]]></category>
            <category><![CDATA[group-policy-management]]></category>
            <dc:creator><![CDATA[Jaseer VK]]></dc:creator>
            <pubDate>Fri, 21 Aug 2026 15:11:51 GMT</pubDate>
            <atom:updated>2026-08-21T15:11:51.898Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Introduction</strong></p><p>I recently completed a hands-on <strong>Active Directory lab</strong> where I designed and deployed a Windows domain environment from scratch.</p><p>Instead of only learning Active Directory concepts theoretically, I wanted to build a working environment and validate each component practically.</p><p>The lab covered:</p><ul><li>Active Directory Domain Services (AD DS)</li><li>Domain Controller configuration</li><li>DNS</li><li>Organizational Units (OUs)</li><li>Users and Security Groups</li><li>Group Policy Objects (GPOs)</li><li>Windows 10 domain joining</li><li>GPO enforcement</li><li>IIS Web Server</li><li>Client-to-server connectivity</li></ul><p>The domain used in the lab was:</p><p>encrypter.local</p><h3>Lab Environment</h3><p>The basic environment consisted of:</p><p><strong>Windows Server</strong></p><ul><li>Active Directory Domain Services</li><li>DNS</li><li>IIS Web Server</li></ul><p><strong>Windows 10 Client</strong></p><ul><li>Domain joined</li><li>Domain user authentication</li><li>Group Policy enforcement</li></ul><p>The overall architecture was:</p><pre>              Windows Server<br>                     │<br>          ┌──────────┼──────────┐<br>          │          │          │<br>         AD DS      DNS        IIS<br>          │<br>      encrypter.local<br>          │<br>          │<br>    Windows 10 Client<br>          │<br>      Domain Joined<br>          │<br>       GPO Applied</pre><h3>1. Preparing the Windows Server</h3><p>Before installing Active Directory, I prepared the Windows Server that would become the Domain Controller.</p><h3>Configure a Static IP</h3><p>A Domain Controller should have a stable IP address so that clients can reliably locate Active Directory and DNS services.</p><p>Navigate to:</p><p><strong>Network Settings → Network Adapter → IPv4 Properties</strong></p><p>Configure:</p><pre>IP Address:      192.168.1.10<br>Subnet Mask:     255.255.255.0<br>Default Gateway: 192.168.1.1<br>Preferred DNS:   192.168.1.10</pre><p>These are example values. The actual addresses depend on the network used in the lab.</p><p>Then verify the configuration:</p><pre>ipconfig /all</pre><p>Test basic connectivity:</p><pre>ping &lt;gateway-ip&gt;</pre><h3>Rename the Server</h3><p>Before promoting the machine to a Domain Controller, I assigned it a meaningful hostname.</p><p>Example:</p><pre>DC01</pre><p>After changing the hostname, restart the server.</p><h3>2. Installing Active Directory Domain Services</h3><p>The next step was installing the <strong>Active Directory Domain Services (AD DS)</strong> role.</p><p>Open:</p><p><strong>Server Manager → Manage → Add Roles and Features</strong></p><p>Select:</p><p><strong>Role-based or feature-based installation</strong></p><p>Choose the local server.</p><p>Select:</p><p><strong>Active Directory Domain Services</strong></p><p>When prompted, click <strong>Add Features</strong>.</p><p>Continue through the wizard and click <strong>Install</strong>.</p><p>At this stage, AD DS is installed, but the server is not yet a Domain Controller.</p><h3>3. Creating the Active Directory Domain</h3><p>After installing AD DS, I promoted the server to a Domain Controller and created a new Active Directory forest.</p><p>In <strong>Server Manager</strong>, select:</p><p><strong>Promote this server to a domain controller</strong></p><p>Choose:</p><p><strong>Add a new forest</strong></p><p>For the root domain, I used:</p><pre>encrypter.local</pre><p>During the configuration, I enabled:</p><ul><li>DNS Server</li><li>Global Catalog</li></ul><p>I also configured the <strong>Directory Services Restore Mode (DSRM)</strong> password.</p><p>After completing the prerequisite check, I selected <strong>Install</strong>.</p><p>The server restarted automatically.</p><p>After reboot, the server was operating as a Domain Controller for:</p><pre>encrypter.local</pre><h3>4. Verifying Active Directory</h3><p>After the restart, I opened:</p><p><strong>Server Manager → Tools</strong></p><p>Important management consoles include:</p><ul><li>Active Directory Users and Computers</li><li>DNS</li><li>Group Policy Management</li><li>Active Directory Domains and Trusts</li></ul><p>The main console used for user and computer management was <strong>Active Directory Users and Computers (ADUC)</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*wosB2_3slbSn0D4yztRZZw.png" /><figcaption>Active Directory Users and Computers showing the encrypter.local domain and directory objects.</figcaption></figure><h3>5. Creating the Organizational Unit Structure</h3><p>Instead of keeping all users in the default containers, I created a basic department-based OU structure.</p><p>For example:</p><pre>encrypter.local<br>│<br>├── IT<br>├── Sales<br>├── Users<br>└── Computers</pre><p>To create an OU:</p><p><strong>Active Directory Users and Computers → Right-click the domain → New → Organizational Unit</strong></p><p>I created departmental OUs such as:</p><pre>IT<br>Sales</pre><h3>Why use OUs?</h3><p>Organizational Units help with:</p><ul><li>Directory organization</li><li>User and computer management</li><li>Group Policy targeting</li><li>Administrative delegation</li><li>Scalability</li></ul><p>For example, a GPO can be linked only to the <strong>IT OU</strong> instead of affecting every user in the domain.</p><h3>6. Creating Domain Users</h3><p>After creating the OUs, I created domain user accounts.</p><p>Inside the required OU:</p><p><strong>Right-click → New → User</strong></p><p>Then enter:</p><ul><li>First name</li><li>Last name</li><li>Username</li><li>Password</li></ul><p>For example:</p><pre>Username: encrypter-user<br>Department: IT</pre><p>This account can then authenticate against the Active Directory domain.</p><h3>7. Managing Security Groups</h3><p>I also used groups to organize users and simplify permission management.</p><p>Example groups:</p><pre>IT-Users<br>Sales-Users</pre><p>The basic concept is:</p><pre>User<br>   ↓<br>Security Group<br>   ↓<br>Permissions</pre><p>Instead of assigning permissions individually to every user, permissions can be assigned to groups.</p><p>This makes administration easier and supports the <strong>principle of least privilege</strong>.</p><h3>8. Creating a Group Policy to Restrict CMD</h3><p>One of the main security controls implemented in this project was a <strong>Group Policy Object (GPO)</strong> to restrict access to Command Prompt.</p><p>Open:</p><p><strong>Server Manager → Tools → Group Policy Management</strong></p><p>Create a new GPO and give it a descriptive name:</p><pre>Restrict CMD Access</pre><p>Right-click the GPO and select:</p><p><strong>Edit</strong></p><p>Navigate to:</p><pre>User Configuration<br>→ Administrative Templates<br>→ System</pre><p>Locate:</p><p><strong>Prevent access to the command prompt</strong></p><p>Set it to:</p><p><strong>Enabled</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*-XAoT8BVpzP-Qx8Mk-Zz8g.png" /><figcaption><em>Group Policy Management Editor showing the “Prevent access to the command prompt” policy enabled.</em></figcaption></figure><h3>9. Applying and Verifying the GPO</h3><p>After configuring the GPO, I needed to confirm that the policy was actually reaching the client.</p><p>On the Windows 10 client, I used:</p><pre>gpupdate /force</pre><p>To view applied policies:</p><pre>gpresult /r</pre><p>For a detailed HTML report:</p><pre>gpresult /h C:\gp-report.html</pre><p>This helps verify whether the expected Group Policy is being processed.</p><h3>10. Joining the Windows 10 Client to the Domain</h3><p>The next step was joining the Windows 10 machine to:</p><pre>encrypter.local</pre><h3>Configure DNS</h3><p>The Windows 10 client must be able to resolve the Domain Controller through DNS.</p><p>I configured the client’s DNS server to point to the Domain Controller.</p><p>Then tested DNS:</p><pre>nslookup encrypter.local</pre><p>And connectivity:</p><pre>ping &lt;domain-controller-ip&gt;</pre><h3>Join the Domain</h3><p>On Windows 10:</p><p><strong>Settings → System → About → Advanced system settings → Computer Name → Change</strong></p><p>Select:</p><p><strong>Domain</strong></p><p>Enter:</p><pre>encrypter.local</pre><p>Provide valid domain credentials when prompted.</p><p>After successful domain joining, restart the client.</p><p>The computer should then appear in <strong>Active Directory Users and Computers</strong>.</p><h3>11. Testing Group Policy Enforcement</h3><p>After joining the Windows 10 machine to the domain, I logged in using the domain user and tested the configured policy.</p><p>The Command Prompt was successfully blocked.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*4U19wwCh5oiiQnoxSegj_Q.png" /><figcaption><em>Windows 10 domain client showing Command Prompt access being restricted by Group Policy.</em></figcaption></figure><p>This confirmed that:</p><ul><li>The Windows 10 client successfully joined the domain.</li><li>Domain communication was working.</li><li>The user received the GPO.</li><li>The configured restriction was successfully enforced.</li></ul><p>This was an important validation step because creating a GPO does not automatically guarantee that the client is receiving it.</p><h3>12. Installing IIS Web Server</h3><p>After completing the Active Directory configuration, I deployed <strong>Internet Information Services (IIS)</strong> on the Windows Server.</p><p>IIS is Microsoft’s web server platform for hosting websites and web applications on Windows.</p><p>To install IIS:</p><p><strong>Server Manager → Manage → Add Roles and Features</strong></p><p>Select:</p><p><strong>Role-based or feature-based installation</strong></p><p>Choose the local server.</p><p>Enable:</p><p><strong>Web Server (IIS)</strong></p><p>Complete the installation.</p><p>After installation, open:</p><p><strong>Server Manager → Tools → Internet Information Services (IIS) Manager</strong></p><h3>13. Testing IIS</h3><p>To verify the IIS installation, I opened a browser on the server and accessed:</p><pre>http://localhost</pre><p>The default IIS welcome page loaded successfully.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*bK0xJIO1ZPRGV-2f6Ld7dQ.png" /><figcaption><em>IIS default welcome page successfully served by the Windows Server.</em></figcaption></figure><p>This confirmed that IIS was installed and serving HTTP content.</p><h3>14. Accessing IIS from the Domain Client</h3><p>The final step was testing connectivity from the Windows 10 domain client to the IIS server.</p><p>From the client, I accessed the server using its IP address or hostname:</p><pre>http://&lt;server-ip&gt;</pre><p>or:</p><pre>http://&lt;server-hostname&gt;</pre><p>The communication flow was:</p><pre>Windows 10 Client<br>        │<br>        │ HTTP<br>        ▼<br>Windows Server<br>        │<br>        ├── Active Directory<br>        ├── DNS<br>        └── IIS</pre><p>Successful access demonstrated that the domain client could communicate with the Windows Server and reach the IIS service.</p><h3>15. Troubleshooting Commands</h3><p>During an Active Directory lab, multiple services must work together. These commands are useful when troubleshooting.</p><h3>Check IP configuration</h3><pre>ipconfig /all</pre><h3>Test DNS resolution</h3><pre>nslookup encrypter.local</pre><h3>Test connectivity to the Domain Controller</h3><pre>ping &lt;domain-controller-ip&gt;</pre><h3>Refresh Group Policy</h3><pre>gpupdate /force</pre><h3>Check applied policies</h3><pre>gpresult /r</pre><h3>Test IIS locally</h3><pre>http://localhost</pre><h3>Test IIS remotely</h3><pre>http://&lt;server-ip&gt;</pre><p>If something fails, check:</p><ul><li>DNS configuration</li><li>Windows Firewall</li><li>Network connectivity</li><li>IIS service status</li><li>Group Policy scope</li><li>OU placement</li><li>Windows Event Viewer</li></ul><h3>16. Final Lab Result</h3><p>The completed lab demonstrated the following workflow:</p><pre>Active Directory<br>      ↓<br>encrypter.local<br>      ↓<br>Organizational Units<br>      ↓<br>Users + Groups<br>      ↓<br>Group Policy<br>      ↓<br>Windows 10 Domain Client<br>      ↓<br>CMD Restriction<br>      ↓<br>IIS Web Server<br>      ↓<br>Client-to-Server Access</pre><p>The environment successfully provided centralized identity management, policy enforcement, and web server functionality.</p><h3>Security Takeaways</h3><p>This project also helped reinforce several important security concepts.</p><h3>Centralized Identity Management</h3><p>Active Directory provides centralized management of users, computers, and authentication.</p><h3>Least Privilege</h3><p>Groups and role-based organization make it easier to provide only the access users require.</p><h3>Centralized Policy Enforcement</h3><p>GPOs allow administrators to apply security configurations across domain-connected systems.</p><h3>Controlled Administrative Access</h3><p>Restricting Command Prompt demonstrates how unnecessary tools can be limited for standard users.</p><h3>Validation</h3><p>Security configurations should always be tested from the endpoint to confirm that they are actually effective.</p><h3>Next Steps</h3><p>This lab can be expanded into a more security-focused Active Directory environment.</p><p>Some possible improvements are:</p><ul><li>Password and account lockout policies</li><li>Windows Firewall configuration through GPO</li><li>Windows Defender policies</li><li>Dedicated Server and Workstation OUs</li><li>NTFS and shared-folder permissions</li><li>Windows Security auditing</li><li>Sysmon deployment</li><li>Wazuh or Splunk integration</li><li>Active Directory attack simulations in an isolated lab</li><li>MITRE ATT&amp;CK mapping</li><li>Kerberos and LDAP security monitoring</li></ul><p>The next logical step would be turning this infrastructure into a <strong>Windows security monitoring and Active Directory detection lab</strong>.</p><h3>Conclusion</h3><p>This project gave me practical experience building an Active Directory environment from scratch.</p><p>I configured the encrypter.local domain, created Organizational Units, managed users and groups, implemented Group Policy, joined a Windows 10 client to the domain, validated policy enforcement, deployed IIS, and successfully accessed the web server from the domain client.</p><p>The project helped me understand how different Windows infrastructure components work together:</p><p><strong>Domain → DNS → Users → Groups → OUs → GPO → Domain Client → IIS</strong></p><p>It also provides a strong foundation for further learning in <strong>Windows Server Administration, Active Directory Security, SOC Operations, Threat Detection, and Penetration Testing</strong>.</p><h3>Tags</h3><p>Active Directory Windows Server Group Policy Active Directory Security Windows 10 IIS Cybersecurity System Administration Home Lab SOC Threat Detection</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aeb45016621a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build a SIEM Home Lab with Splunk Enterprise, Sysmon & Splunk Universal Forwarder on Ubuntu and…]]></title>
            <link>https://medium.com/@jaseervk321/build-a-siem-home-lab-with-splunk-enterprise-sysmon-splunk-universal-forwarder-on-ubuntu-and-421350d4fbbd?source=rss-949defe7d91e------2</link>
            <guid isPermaLink="false">https://medium.com/p/421350d4fbbd</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[soc]]></category>
            <category><![CDATA[splunk-enterprise]]></category>
            <dc:creator><![CDATA[Jaseer VK]]></dc:creator>
            <pubDate>Fri, 07 Aug 2026 15:24:41 GMT</pubDate>
            <atom:updated>2026-08-07T15:37:40.820Z</atom:updated>
            <content:encoded><![CDATA[<h3>Build a SIEM Home Lab with Splunk Enterprise, Sysmon &amp; Splunk Universal Forwarder on Ubuntu and Windows</h3><h3>Introduction</h3><p>Building a Security Information and Event Management (SIEM) home lab is one of the most effective ways to learn <strong>threat hunting</strong>, <strong>security monitoring</strong>, <strong>incident response</strong>, and <strong>log analysis</strong> in a practical environment. Rather than relying solely on theoretical concepts, a SIEM lab allows you to generate, collect, and analyze real security events from your own systems.</p><p>In this tutorial, you’ll build a simple but powerful SIEM environment by:</p><ul><li>Installing <strong>Splunk Enterprise</strong> on an <strong>Ubuntu Server</strong></li><li>Installing <strong>Sysmon</strong> on a <strong>Windows machine</strong></li><li>Configuring the <strong>Splunk Universal Forwarder</strong> to forward Windows Event Logs to Splunk</li><li>Verifying that Windows logs are successfully ingested into Splunk for analysis</li></ul><p>By the end of this guide, you’ll have a functioning SIEM lab capable of collecting Windows security events, providing a strong foundation for detection engineering, threat hunting, and MITRE ATT&amp;CK-based security research.</p><h3>Lab Architecture</h3><pre>+-----------------------------+<br>|        Windows Machine      |<br>|-----------------------------|<br>| Sysmon                      |<br>| Splunk Universal Forwarder  |<br>+-------------+---------------+<br>              |<br>              | TCP 9997<br>              |<br>              v<br>+-----------------------------+<br>|       Ubuntu Server         |<br>|-----------------------------|<br>| Splunk Enterprise           |<br>| Splunk Web (Port 8000)      |<br>+-----------------------------+</pre><h3>Requirements</h3><p>Before starting, ensure you have the following:</p><ul><li>Ubuntu Server installed</li><li>Windows machine (physical or virtual)</li><li>Internet connectivity</li><li>Administrative/root privileges</li><li>Basic Linux command-line knowledge</li></ul><h3>Step 1 — Install Ubuntu Server</h3><p>Install Ubuntu Server on your virtual machine or physical system.</p><p>After installation, log in and update the operating system.</p><pre>sudo apt update<br>sudo apt upgrade -y</pre><h3>Step 2 — Download Splunk Enterprise</h3><p>Visit the Splunk website and download the latest <strong>Splunk Enterprise (.deb)</strong> package, or download it directly using wget.</p><p>Example:</p><pre>wget -O splunk-10.4.2-33c3bf42cd73-linux-amd64.deb &quot;https://download.splunk.com/products/splunk/releases/10.4.2/linux/splunk-10.4.2-33c3bf42cd73-linux-amd64.deb&quot;</pre><h3>Step 3 — Install Splunk Enterprise</h3><p>Install the downloaded package using dpkg.</p><pre>sudo dpkg -i &lt;filename&gt;.deb</pre><p>Splunk is installed by default in:</p><pre>/opt/splunk</pre><h3>Step 4 — Start Splunk and Enable Automatic Startup</h3><p>Start the Splunk service.</p><pre>sudo /opt/splunk/bin/splunk start</pre><p>During the first startup:</p><ul><li>Accept the license agreement</li><li>Create a Splunk administrator username</li><li>Create a strong password</li></ul><p>Enable Splunk to start automatically when Ubuntu boots.</p><pre>sudo /opt/splunk/bin/splunk enable boot-start</pre><h3>Step 5 — Access Splunk Web</h3><p>Open a web browser from your Windows machine and navigate to:</p><pre>https://&lt;Ubuntu_IP&gt;:8000</pre><p>Log in using the administrator credentials created during installation.</p><p>You should now see the <strong>Splunk Enterprise Dashboard</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ERv3FEfjeBXbDXt90do-Cw.png" /></figure><h3>Step 6 — Prepare the Windows Machine</h3><p>Install Windows on your virtual machine or physical system.</p><p>This Windows machine will generate logs that will later be forwarded to Splunk.</p><h3>Step 7 — Install Sysmon</h3><p>Download <strong>Sysmon</strong> from the Microsoft Sysinternals Suite.</p><pre><a href="https://learn.microsoft.com/en-us/sysinternals/downloads/sysmon">https://learn.microsoft.com/en-us/sysinternals/downloads/sysmon</a></pre><p>Open <strong>Command Prompt</strong> as <strong>Administrator</strong> and navigate to the folder containing Sysmon64.exe.</p><p>Install Sysmon.</p><pre>Sysmon64.exe -i</pre><p>After installation, Sysmon begins logging detailed system activity such as:</p><ul><li>Process creation</li><li>Network connections</li><li>Driver loading</li><li>Registry modifications</li><li>File creation timestamps</li></ul><p>These events greatly improve visibility compared to standard Windows Event Logs.</p><h3>Step 8 — Verify the Sysmon Service</h3><p>Open:</p><pre>services.msc</pre><p>Locate:</p><p><strong>Sysmon64</strong></p><p>Verify that:</p><ul><li>Status = <strong>Running</strong></li></ul><h3>Step 9 — Install Splunk Universal Forwarder</h3><p>Download the <strong>Splunk Universal Forwarder</strong> for Windows.</p><pre>https://www.splunk.com/en_us/download/universal-forwarder.html</pre><p>Run the installer as <strong>Administrator</strong> and complete the installation using the default settings.</p><p>After installation, the default directory is:</p><pre>C:\Program Files\SplunkUniversalForwarder\</pre><h3>Step 10 — Configure inputs.conf</h3><p>Navigate to:</p><pre>C:\Program Files\SplunkUniversalForwarder\etc\system\local\inputs.conf</pre><p>Add the following configuration:</p><pre>[WinEventLog://Security]<br>disabled = 0<br>index = windows<br><br>[WinEventLog://System]<br>disabled = 0<br>index = windows<br><br>[WinEventLog://Application]<br>disabled = 0<br>index = windows<br><br>[WinEventLog://Microsoft-Windows-Kernel-Thermal-Operational]<br>disabled = 0<br>index = windows<br>renderXml = true</pre><p>This configuration enables forwarding for:</p><ul><li>Security Logs</li><li>System Logs</li><li>Application Logs</li><li>Kernel Thermal Events</li></ul><h3>Step 11 — Configure outputs.conf</h3><p>Navigate to:</p><pre>C:\Program Files\SplunkUniversalForwarder\etc\system\local\outputs.conf</pre><p>Add the following configuration:</p><pre>[tcpout]<br>defaultGroup = splunk_group<br><br>[tcpout:splunk_group]<br>server = &lt;Ubuntu_IP&gt;:9997</pre><p>Replace &lt;Ubuntu_IP&gt; with your Ubuntu Server’s IP address.</p><h3>Step 12 — Restart the Splunk Universal Forwarder</h3><p>Open <strong>Command Prompt</strong> as Administrator.</p><p>Stop the service.</p><pre>net stop SplunkForwarder</pre><p>Start the service.</p><pre>net start SplunkForwarder</pre><p>Ensure the Windows Firewall allows outbound communication on TCP Port 9997</p><h3>Step 13 — Verify Log Collection in Splunk</h3><p>Return to the Splunk Web interface.</p><p>Open the <strong>Search &amp; Reporting</strong> application.</p><p>Run the following search:</p><pre>index=windows</pre><p>If everything has been configured correctly, Windows events should begin appearing almost immediately.</p><p>You should now see:</p><ul><li>Security Events</li><li>System Events</li><li>Application Events</li><li>Sysmon Events (if configured to write to the Windows Event Log)</li></ul><h3>Troubleshooting Tips</h3><p>If no events appear in Splunk, verify the following:</p><ul><li>Splunk Enterprise is running.</li><li>Splunk Web is accessible on port <strong>8000</strong>.</li><li>Splunk is configured to receive forwarded data on <strong>TCP port 9997</strong>.</li><li>The Splunk Universal Forwarder service is running.</li><li>inputs.conf and outputs.conf are located in the <strong>local</strong> directory.</li><li>The Windows Firewall allows outbound traffic on <strong>9997</strong>.</li><li>Network connectivity exists between the Windows machine and the Ubuntu Server.</li><li>The correct index name (windows) is being searched.</li></ul><p>Useful commands:</p><p>Check Splunk status:</p><pre>sudo /opt/splunk/bin/splunk status</pre><p>Restart Splunk:</p><pre>sudo /opt/splunk/bin/splunk restart </pre><p>Restart the Universal Forwarder:</p><pre>net stop SplunkForwarder<br>net start SplunkForwarder</pre><h3>What You’ve Accomplished</h3><p>Congratulations! You have successfully built a basic SIEM home lab capable of collecting Windows Event Logs into Splunk Enterprise.</p><p>Your environment now includes:</p><ul><li>Ubuntu Server hosting Splunk Enterprise</li><li>Windows endpoint with Sysmon installed</li><li>Splunk Universal Forwarder collecting Windows Event Logs</li><li>Centralized log collection in Splunk</li><li>A foundation for security monitoring and threat hunting</li></ul><h3>Next Steps</h3><p>Now that your SIEM lab is operational, consider expanding it by exploring:</p><ul><li>Creating custom Splunk dashboards</li><li>Writing Splunk Processing Language (SPL) searches</li><li>Developing detection rules for suspicious activity</li><li>Mapping detections to the MITRE ATT&amp;CK framework</li><li>Building alerting workflows for real-time threat detection</li></ul><p>With this lab in place, you have a practical platform for learning SIEM engineering, detection engineering, incident response, and advanced cybersecurity research.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=421350d4fbbd" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>