<?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 Smruti Ranjan Pradhan on Medium]]></title>
        <description><![CDATA[Stories by Smruti Ranjan Pradhan on Medium]]></description>
        <link>https://medium.com/@sforsmruti?source=rss-2664bdba8504------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*qC9pkhgkhm9tAGFV</url>
            <title>Stories by Smruti Ranjan Pradhan on Medium</title>
            <link>https://medium.com/@sforsmruti?source=rss-2664bdba8504------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 10:51:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sforsmruti/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[How Long Should You Trust an IOC? A Practical OpenCTI Decay Experiment]]></title>
            <link>https://medium.com/@sforsmruti/how-long-should-you-trust-an-ioc-a-practical-opencti-decay-experiment-0bf16c4050cb?source=rss-2664bdba8504------2</link>
            <guid isPermaLink="false">https://medium.com/p/0bf16c4050cb</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[opencti]]></category>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[threat-intelligence]]></category>
            <category><![CDATA[cyber-threat-intelligence]]></category>
            <dc:creator><![CDATA[Smruti Ranjan Pradhan]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 10:54:15 GMT</pubDate>
            <atom:updated>2026-09-28T10:54:15.450Z</atom:updated>
            <content:encoded><![CDATA[<p>Imagine an IP address is reported as malicious today. We add it to our threat intelligence, use it for detection, and treat every future hit as suspicious. A few weeks later, the attacker is gone, the infrastructure has changed, and the same IP may now belong to someone completely different. But if our intelligence never changes, the SOC may continue trusting an IOC that is no longer useful.</p><p>Hi folks, I’m <strong>Smruti Ranjan Pradhan</strong>, and in this practical OpenCTI experiment we are going to answer one simple question. <strong>How long should we actually trust an IOC?</strong> We will follow an indicator through its complete lifecycle, starting from fresh intelligence, then watching its score decay over time, understanding when it becomes less relevant, and finally seeing what happens when OpenCTI revokes it and removes it from active detection.</p><p>The objective is simple. We want to understand when useful threat intelligence slowly turns into noise, and how OpenCTI can help us manage that change before old IOCs start creating unnecessary alerts and false positives.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JbdGdSZFJVRXefm7-CjY9A.png" /><figcaption><strong>Decay Rule</strong> defines how an indicator’s score decreases over time and when OpenCTI should eventually consider that indicator expired or revoked.</figcaption></figure><h4>Why IOC Aging Matters:</h4><p>An IOC may be useful today, but that does not mean it should be trusted forever. IPs can be reassigned, domains can change, and old infrastructure can disappear. If we keep using the same indicator without checking its age or relevance, it can slowly turn into noise.</p><p>So instead of spending too much time on theory, we are going to test this directly in OpenCTI. We will take one test IOC, capture its current state, apply a decay rule, and observe how its score changes over time until it reaches the point where OpenCTI no longer treats it as active intelligence.</p><h4>Establishing the IOC Baseline</h4><p>Before applying any decay rule, we first need to understand the current state of our test indicators. This baseline will help us compare what changes later and whether OpenCTI is actually modifying the IOC lifecycle the way we expect.</p><p>Start the experiment from:</p><p><strong>OpenCTI → Observations → Indicators</strong>, for our first test, we will use the domain: <strong><em>“removed.fwmvbsie.help” . </em></strong>Search for this domain and open the matching Indicator.</p><p>Once the Indicator opens, do not change anything yet. First, we want to understand how OpenCTI currently sees this IOC before the decay experiment begins.</p><p>At this stage, simply observe the current <strong>Score, Valid From, Valid Until, Detection status, Revoked status, Author, and Confidence</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4UzvcRi_u7N9POBlOYhY4A.png" /></figure><p>This screenshot gives us the original state of the IOC. We will come back to the same indicator later and compare these values after the decay rule starts affecting it.</p><h4>Checking How OpenCTI Ages the IOC</h4><p>Now that we have captured the original state of the indicator, the next step is to see how OpenCTI plans to treat it over time.</p><p>On the same Indicator page, click <strong>LIFECYCLE</strong> beside the score. In our test IOC, the Lifecycle view shows three important values.</p><blockquote><strong>Initial score</strong> 72<br><strong>Current stable score</strong> 50<br> <strong>Revoke score</strong> 20</blockquote><p>The graph also shows that the indicator started with a score of 72 and has already dropped to 50. The dotted part of the curve represents how OpenCTI expects the score to continue decreasing over time.</p><p>For this indicator, OpenCTI expects the score to reach the revoke threshold of 20 in approximately <strong>4 months</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7CHBUo095RwXybPMp6b8bg.png" /><figcaption>This gives us the first practical proof that an IOC does not stay equally trusted forever. OpenCTI is already reducing the score over time, and once it reaches the configured revoke score, the indicator can move out of its active lifecycle.</figcaption></figure><p>OpenCTI calculates indicator validity and score using the decay rule that matched the indicator when it was created. The score is updated at configured reaction points, and once the indicator expires, OpenCTI marks it as revoked and automatically sets detection to false.</p><h4>Finding the Decay Rule Behind This IOC</h4><p>Now that we know our domain IOC has moved from an initial score of 72 to a current stable score of 50, the next question is simple. What is controlling this score reduction? To find that, go to <strong>Settings → Customization → Decay Rules</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jD32o6zqlCQBUB9gcRTkpQ.png" /><figcaption>Built-in decay rules available in OpenCTI for different indicator types.</figcaption></figure><p>OpenCTI provides different built-in decay rules for different indicator types. In our case, the test IOC is a domain, so the relevant rule is <strong>Built-in domain name</strong>. We can also see that OpenCTI has separate built-in rules for files and artifacts, IPs and URLs, and a default rule for anything that does not match a more specific rule.</p><p>These rules are applied by priority order, with the highest matching order taking precedence. Now click <strong>Built-in domain name</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NrrjjkcJ9OKEPk5EOR2BJA.png" /><figcaption>Built-in domain rule showing the lifetime, decay factor, reaction points, revoke score, and the expected life curve for domain indicators.</figcaption></figure><blockquote><em>The </em><strong><em>Built-in domain name</em></strong><em> rule applies specifically to indicators whose main observable type is a domain name.</em></blockquote><blockquote><em>The </em><strong><em>Lifetime</em></strong><em> is set to </em><em>300 days. This defines the full duration of the decay curve.</em></blockquote><blockquote><em>The </em><strong><em>Decay factor</em></strong><em> is </em><em>0.7. This controls how quickly the score drops over time.</em></blockquote><blockquote><em>The </em><strong><em>Reaction points</em></strong><em> are </em><em>80 and </em><em>50. These are the score levels where OpenCTI updates the indicator during its lifecycle.</em></blockquote><blockquote><em>The </em><strong><em>Revoke score</em></strong><em> is </em><em>20. Once the indicator reaches this score, OpenCTI can treat it as reaching the end of its active lifecycle.</em></blockquote><h4>Now connect this back to your actual IOC (removed.fwmvbsie.help):</h4><p>Our test domain started with a score of 72. Since that value was already below the first reaction point of 80, the next important score level was 50. That matches exactly what we saw in the Lifecycle view, where the current stable score had already dropped to 50.</p><p>At this point, the lifecycle behavior is no longer just a graph. We can now see which rule is behind it and how the values in that rule directly explain the score change of our IOC.</p><h4>Creating Our Own Decay Rule</h4><p>Until now, we have only observed how OpenCTI’s built-in domain decay rule is affecting our IOC. To make the experiment easier to understand, we will now create a separate test rule with a much shorter lifecycle.</p><p>The purpose is simple. Instead of waiting months to see how the score changes, we will create a controlled 7-day lifecycle and define clear score stages that we can observe.</p><p>Go to Settings → Customization → Decay Rules, Click the + icon to create a new decay rule.</p><p>Now configure the rule as follows.</p><p>Name: SOC Test Domain Decay</p><p>Description: Test decay rule created to observe how a domain indicator score decreases through reaction points and eventually reaches the revoke threshold.</p><p>Apply on indicator observable types Select: Domain name</p><p>This makes sure the rule is intended for domain indicators.</p><p>Lifetime: 7</p><p>We are using 7 days only for the experiment so that the lifecycle is short enough to observe practically.</p><p>Decay factor: 0.7</p><p>This controls how quickly the score decreases across the lifecycle.</p><p>Reaction points Add:</p><p>60<br>40<br>20</p><p>These are the score levels where we want OpenCTI to update the indicator during the test.</p><p>Revoke score: 10</p><p>Once the IOC reaches this score, it reaches the revoke threshold for our experiment.</p><p>Order: 2</p><p>The built-in domain rule has a lower order. By using order 2, this custom rule can take priority when it matches a newly created indicator.</p><p>Active: Keep it OFF for now.</p><p>We do not want the test rule to start affecting newly ingested domain indicators before we are ready.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WtlJivCkEKAY_G_yLnUCzA.png" /><figcaption>Custom domain decay rule prepared with a 7-day lifetime, reaction points at 60, 40 and 20, and a revoke score of 10.</figcaption></figure><p>With this setup, we now have a controlled lifecycle that is much easier to observe than the default 300-day rule. The next step is to create the rule first, then carefully activate it only when we are ready to test a fresh domain indicator.</p><p>Now click <strong>CREATE</strong> while keeping <strong>Active OFF</strong></p><h4>Verifying the Custom Rule</h4><p>Our custom rule has now been created successfully, but it is still <strong>inactive</strong>. This is exactly what we wanted at this stage.</p><p>From the Decay Rules page, we can confirm:</p><ul><li><strong>Rule</strong> SOC Test Domain Decay</li><li><strong>Impacted indicators</strong> 0</li><li><strong>Active</strong> No</li><li><strong>Order</strong> 2</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ko0i5oCFssDWPjbI1ITDug.png" /><figcaption>Custom decay rule created successfully and kept inactive before beginning the controlled experiment.</figcaption></figure><p>The rule is now available in OpenCTI, but it is not affecting any indicators yet. The impacted indicator count is still zero because we deliberately created the rule in an inactive state. This gives us a chance to verify the configuration before allowing it to influence any IOC.</p><h4>Preparing the Controlled Test</h4><p>Our custom rule is ready, but we should not activate it blindly. Because it applies to every newly created Domain name indicator, activating it in a live OpenCTI instance could also affect normal incoming intelligence.</p><p>For the experiment, we will therefore use a fresh test domain and activate the rule only in a controlled test environment or during an approved period where new domain ingestion is paused.</p><p>Use a reserved test value such as: decay-test.example</p><p>The plan is simple, We will Activate the custom rule → create the fresh test domain indicator → confirm the new rule is assigned → deactivate the custom rule again</p><p>This allows us to observe the 7-day lifecycle without unintentionally changing the lifecycle of other incoming domain indicators.</p><h4>Creating a Fresh Test IOC</h4><p>Now that the controlled test is planned, the next step is to create a brand new domain indicator that we can safely use for the decay experiment.</p><p>Settings → Customization → Decay Rules → SOC Test Domain Decay , Turn<strong>Active → ON</strong></p><p>Do not modify the values, Immediately return to Observations → Indicators → + , Then fill the test Indicator like this:</p><blockquote>Name: decay-test.example<br>Indicator types: Leave empty for now unless OpenCTI requires one.<br>Confidence level: Keep the default. This is not what we are testing.<br>Pattern type: STIX<br>Pattern: [domain-name:value = ‘decay-test.example’]<br>Main observable type: Domain name<br>Valid From: Leave empty if OpenCTI allows it.<br>Valid Until: Leave empty.</blockquote><blockquote>This is important because when dates are not supplied, OpenCTI can calculate the validity from the decay lifecycle. The calculated valid_until corresponds to when the indicator reaches its revoke score.</blockquote><blockquote>Score: 80<br>Description: Controlled test indicator created to observe the OpenCTI decay lifecycle.<br>Labels: Optional. If you already have a dedicated test label, add something like “decay-test”<br>Detection: Leave OFF initially<br>Click on create</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A47dqeF6wBYTRsdW7KgIGw.png" /><figcaption>Fresh test domain created with a score of 80 before observing the custom decay lifecycle.</figcaption></figure><h4>Confirming the Custom Decay Lifecycle</h4><p>Creating the IOC was only the first half of the experiment. The next step was to verify whether OpenCTI actually attached our custom 7-day decay rule to the fresh test domain.</p><p>When we opened <strong>Lifecycle</strong>, OpenCTI showed the complete schedule for the IOC.</p><p>From the screenshot we can see:</p><blockquote>Current stable score 80<br>Next stable score 60 in about 9 hours<br>Next stable score 40 in about 2 days<br>Next stable score 20 in about 4 days<br>Revoke score 10 in about 5 days</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-r5VVPpm_0rwmpTqedxhcw.png" /><figcaption>Custom lifecycle applied successfully to the fresh test IOC, showing each planned score stage and the final revoke point.</figcaption></figure><p>This is the key result of our controlled test. The indicator starts at 80 and OpenCTI has already scheduled the score to move through 60, 40, and 20 before reaching the revoke score of 10. This confirms that our custom decay rule is actively controlling the lifecycle of the IOC.</p><p>Now we no longer need to guess how the rule works. OpenCTI has translated our configuration directly into a visible lifecycle that we can monitor step by step.</p><h4>Verifying the First Score Change</h4><p>Our custom lifecycle was configured to move the IOC through the score stages 80, 60, 40, and 20 before reaching the revoke score of 10. When we returned to the indicator after several days, the lifecycle had already progressed beyond the first reaction point.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gzynuleOFWqAYACsDbngdQ.png" /><figcaption><em>The test IOC after completing its configured decay lifecycle and reaching the revoke score of 10.</em></figcaption></figure><p>Instead of finding the IOC at 60, we found that the complete lifecycle had already finished. The score had reached 10, the indicator was marked as revoked, and the validity period had ended.</p><p>We did not capture the intermediate 60, 40, and 20 stages on screen because the experiment continued while we were away, but those values were already defined as reaction points in the custom rule and shown in the lifecycle schedule earlier.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lp1d2SCVyzLF61wQrtOduw.png" /><figcaption>Completed lifecycle showing the IOC reaching the final revoke threshold.</figcaption></figure><p>This confirms that the decay rule was not only predicting future score changes. OpenCTI actually applied the lifecycle and carried the IOC to its configured revoke point.</p><p>At this stage, our controlled decay experiment is complete. The IOC started with a score of 80, moved through the lifecycle defined by our custom rule, and finally reached the revoke threshold of 10.</p><h4>What This Experiment Proved:</h4><p>This experiment answered the question we started with. An IOC should not be trusted forever just because it was once considered malicious. Its value can decrease over time, and OpenCTI gives us a practical way to manage that lifecycle automatically.</p><blockquote><strong>80 → 60 → 40 → 20 → 10 → Revoked</strong></blockquote><p>By using decay rules, reaction points, validity periods, and revocation, we can prevent old indicators from remaining active indefinitely and creating unnecessary noise in detection workflows.</p><blockquote><strong>The real value of threat intelligence is not only knowing when to trust an IOC. It is also knowing when to stop trusting it.</strong></blockquote><p>Thanks for reading. I hope this practical experiment gives you a clearer understanding of how IOC aging works in OpenCTI and why lifecycle management matters in day-to-day threat intelligence operations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0bf16c4050cb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Daily SOC Dashboard in OpenCTI]]></title>
            <link>https://medium.com/@sforsmruti/building-a-daily-soc-dashboard-in-opencti-e8809dde8bee?source=rss-2664bdba8504------2</link>
            <guid isPermaLink="false">https://medium.com/p/e8809dde8bee</guid>
            <category><![CDATA[cyber-threat-intelligence]]></category>
            <category><![CDATA[opencti]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[threat-intelligence]]></category>
            <dc:creator><![CDATA[Smruti Ranjan Pradhan]]></dc:creator>
            <pubDate>Fri, 28 Aug 2026 14:16:14 GMT</pubDate>
            <atom:updated>2026-08-28T14:16:14.787Z</atom:updated>
            <content:encoded><![CDATA[<p>In my previous OpenCTI blog, we explored how scattered threat intelligence can be connected and turned into a meaningful investigation. If you haven’t gone through that one yet, I’d suggest reading it first, because this blog picks up exactly from there. Hi folks, I’m <strong>Smruti Ranjan Pradhan</strong>, and this time we are moving from investigation to daily operations by building a <strong>Daily CSOC Operational Dashboard in OpenCTI from scratch</strong>. The idea is simple: instead of jumping through multiple menus every morning, let’s create one view that quickly tells us <strong>what changed, what matters, and where an analyst should look next</strong>.</p><h4>Why We Need a Daily CSOC Dashboard:</h4><p>As threat intelligence keeps growing inside OpenCTI, analysts can quickly end up moving between indicators, malware, sightings, reports, threat actors, campaigns, and vulnerabilities just to understand what is happening. The goal of a daily SOC dashboard is to bring the most important operational information into one place so an analyst can quickly see <strong>what changed, what needs attention, and where to investigate next</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OzCC0i6ol2fegZo9MzDyVQ.png" /></figure><h4>Creating the Custom Dashboard in OpenCTI:</h4><p>Now we will start the practical part<br>Go to: <em>Dashboards → Custom Dashboards → Create Dashboard, </em>Give the dashboard a name such as: “SOC Operational Dashboard”, Add a short description if required, then click <strong>Create</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*um9wtub4oPhQ1_FiEFTqHQ.png" /><figcaption>Create Dashboard screen</figcaption></figure><p>Once the dashboard is created, open it. A blank dashboard, similar to the one shown in the screenshots above, will appear, allowing you to start adding widgets. Before creating the first widget, set the dashboard time window to: <em>Relative Time → Last 24 Hours</em>. This keeps the dashboard focused on daily operational activity instead of showing all historical intelligence.</p><p><strong>Next Step:<br></strong>Click the <strong>+</strong> icon and choose <strong>Create Widget </strong>Our first widget will be a simple KPI card.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uUqgpuD5pOn61v-jyVshaw.png" /></figure><p>From there we will go: <em>Number → Entities → Entity Type = Indicator → created_at → New Indicators, after that </em>Click on <strong>VALIDATE</strong>. You will move to <strong>Step 4: Parameters</strong>. Set the parameter as <strong>Title:</strong> New Indicators &amp; <strong>Date attribute:</strong> keep created_at (Technical date), Click <strong>CREATE . </strong>That will create your first KPI card showing how many new Indicator entities were added within the selected dashboard time window.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9OxuZhxGKO3xJHX4A3AHCg.png" /><figcaption>Our first KPI is now ready. OpenCTI is showing <strong>7.66K new Indicators within the selected Last 24 Hours</strong>, giving the analyst an immediate view of how much fresh indicator intelligence entered the platform during the current operational window.</figcaption></figure><h4>Building the Second KPI: New Malware</h4><p>Click the <strong>+</strong> icon and create another <strong>Number</strong> widget. This time select <strong>Entities</strong> and apply the filter <strong>Entity Type = Malware</strong>. Keep the date attribute as created_at (Technical date), set the title as <strong>New Malware</strong>, and click <strong>Create</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Nb4-DSCo4HiKBYDwjvXZUw.png" /><figcaption>Number → Entities → Entity Type = Malware → created_at → New Malware</figcaption></figure><h4>Building the Third KPI: IOC Sightings</h4><p>This KPI is slightly different. Indicators and Malware are entities, but a <strong>Sighting represents a relationship</strong> in OpenCTI. So this time, instead of using the Entities perspective, we will work with the <strong>Knowledge Graph.</strong></p><p>Now click the <strong>+</strong> icon and create another <strong>Number</strong> widget. In the <strong>Perspective</strong> step, select <strong>Knowledge Graph</strong>. On the filter screen, OpenCTI gives us three areas: the <strong>relationship filter</strong>, <strong>dynamic source filter</strong>, and <strong>dynamic target filter</strong>. For this KPI, we only want to count Sightings, so under the relationship filter select <strong>Relationship Type → Equals to → Sighting in</strong> and leave the source and target filters empty.</p><p>Click <strong>VALIDATE</strong>, then in <strong>Parameters</strong> set the <strong>Title</strong> as IOC Sightings and keep the <strong>Date attribute</strong> as created_at (Technical date). Finally, click <strong>CREATE</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0aQt0ZdMAeqWXBf0MwYJig.png" /><figcaption>Number → Knowledge Graph → Relationship Type = Sighting in → created_at → IOC Sightings</figcaption></figure><p>With these three KPI cards in place, the dashboard now gives us a quick operational snapshot of newly added Indicators, Malware, and Sighting activity within the selected <strong>Last 24 Hours</strong>.</p><h4>Building the Fourth KPI: New Reports</h4><p>The next thing an analyst would want to know is whether any new threat intelligence reports were added during the same period. For this, we again use a <strong>Number</strong> visualization with the <strong>Entities</strong> perspective.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RCdce1ujYdNHe3QboQN1GQ.png" /><figcaption>Create Widget → Number → Entities → Add Filter → Report Type = Threat Report → Validate → Title: New Reports → Date attribute: created_at (Technical date) → Create</figcaption></figure><p>Some KPIs may show 0 because no matching intelligence object or relationship was created during the selected <strong>Last 24 Hours</strong>, which simply reflects the current data available in OpenCTI for that time window.</p><h4>Building the Fifth KPI: Intelligence Activity Trend</h4><p>Now we move from simple counts to a trend view so the analyst can see when intelligence activity increased or decreased during the selected period.</p><blockquote>KPI cards tell us how much intelligence was added, but they do not show when the activity changed. To understand the pattern across the day, let’s add an Intelligence Activity Trend using a Line visualization.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V6hUPnQaktsXqpKWvGa5aA.png" /><figcaption>Create Widget → Line → Entities → Entity Type = Indicator → Validate</figcaption></figure><p>In <strong>Parameters</strong> set <strong>Title as :</strong> Intelligence Activity Trend, Interval: Day, Date attribute: created_at (Technical date), Display legend: Off &amp; then click CREATE.</p><h4>Building the Sixth KPI: Intelligence Object Distribution</h4><p>We now know how much intelligence is arriving and how that activity changes over time. The next question is: <strong>what kind of intelligence is actually entering the platform?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mpfGmrugaWDqiVSftXxkwg.png" /><figcaption>Create Widget → Donut → Entities → On the <strong>Filters</strong> screen, leave it empty for now → Then click <strong>VALIDATE</strong></figcaption></figure><p>In Parameters set Title as: Intelligence Object Distribution, Number of results: 10, Date attribute: created_at (Technical date), Attribute: Type then click CREATE .</p><blockquote>The <strong>Intelligence Object Distribution</strong> gives us a quick breakdown of what kind of intelligence is being added to OpenCTI — such as Indicators, Reports, Malware, Vulnerabilities, IP addresses, URLs, domains, files, and other object types. This helps the analyst understand the composition of the intelligence flow instead of looking only at total counts.</blockquote><h4>Building the Seventh KPI: Threat Actor Activity</h4><p>Now that we understand the volume and type of intelligence entering the platform, the next question is: <strong>which threat actors are appearing in our intelligence data?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wp1vR_ozLanen-pMwXqG2Q.png" /><figcaption>Create Widget → Horizontal Bar → Entities → Entity Type = Threat Actor Group</figcaption></figure><p>In Parameters set Title as: Threat Actor Overview, Number of results: 10, Date attribute: created_at, Attribute: Name &amp; then create it .</p><p>The <strong>Threat Actor Overview</strong> gives us a quick view of threat actors appearing in the selected time window. This adds context to the dashboard because the analyst is no longer looking only at indicators and malware counts, but also at the actors associated with the intelligence.</p><h4>Building the Eighth KPI: Top Malware Activity</h4><blockquote>After identifying the threat actors, the next useful question is: <strong>which malware families are appearing most frequently in our intelligence data?</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QOcvgWQgzPaFJrnJw5mkRg.png" /><figcaption>Create Widget → Horizontal Bar → Entities → Entity Type = Malware</figcaption></figure><p>In Parameters set Title as: Top Malware, Number of results: 10, Date attribute: created_at, Attribute: Name then Create it.</p><p>The <strong>Top Malware</strong> view helps us quickly identify which malware families are appearing in the selected time window. This gives the analyst more context than a simple malware count, because we can now see which malware names are actually present in the intelligence.</p><h4>Building the Ninth KPI: Active Campaigns</h4><p>Now that we have added Indicators, Malware, Sightings, Reports, trends, distributions, and threat-actor context, the next useful question is: <strong>which campaigns are appearing in our intelligence data?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AHX9WjZkip883YMB8K0hKw.png" /><figcaption>Create Widget → Horizontal Bar → Entities → Entity Type = Campaign</figcaption></figure><p>In Parameters set Title as: Active Campaigns, Number of results: 5, Date attribute: created_at (Technical date), Attribute: Name &amp; then click CREATE.</p><p>The <strong>Active Campaigns</strong> widget gives the analyst a quick view of campaign entities appearing within the selected time window, helping connect individual indicators, malware, and threat actors with broader threat activity.</p><h4>Building the Tenth Widget: Malware Distribution</h4><p>So far, most of our dashboard is based on KPI cards and bar charts. To make the dashboard more visually balanced while still keeping it useful, let’s add a circular visualization for malware. This will help us present malware-related intelligence in a different way and make the overall dashboard easier to read at a glance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mAgozJ8rfnOf9iicR6v6vw.png" /><figcaption>Create Widget → Polar Area → Entities → Entity Type = Malware</figcaption></figure><p>In Parameters set Title as: Malware Distribution, Number of results: 5, Date attribute: created_at, Attribute: Name</p><p>With this circular view added, the dashboard now has better visual balance while still showing useful malware context. Instead of relying only on KPI cards and bar charts, we are gradually building a dashboard that is easier to scan and more effective for daily SOC operations.</p><h4>Building the Eleventh KPI: Latest Threat Reports</h4><p>Numbers and charts are useful, but analysts also need something they can read directly. So, let’s add a simple <strong>Latest Threat Reports</strong> list to quickly surface the most recent intelligence reports available in OpenCTI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5DN02xyD1CQOMHoh_Wk2TQ.png" /><figcaption>Create Widget → List → Entities → Entity Type = Report</figcaption></figure><p>Then in Parameters set Title as: Latest Threat Reports, Number of results: 5, Date attribute: created_at, Displayed field: Name or Title depending on what your UI offers</p><p>With this list in place, the dashboard becomes more actionable by giving analysts direct access to recent threat reports without navigating through multiple menus.</p><h4>Building the Twelfth Widget: Active Vulnerabilities</h4><p>We now have indicators, malware, reports, campaigns, and threat actors in one place. The next thing worth adding is vulnerability intelligence, because it helps analysts connect threat activity with weaknesses that may actually require attention.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iCXnqqYdFH0WjYgcN1JIYA.png" /><figcaption>Create Widget → Vertical Bar → Entities → Entity Type = Vulnerability</figcaption></figure><p>Then in Parameters set Title as: Active Vulnerabilities, Number of results: 5, Date attribute: created_at, Attribute: choose Name or the CVE-related field available in your UI</p><p>This gives the dashboard a quick vulnerability-focused view and helps analysts see which CVEs are appearing in the selected intelligence window.</p><h4>Building the Final Widget: Relationship Activity</h4><p>OpenCTI is not only about storing objects; its real strength is the relationships between them. So, let’s add a view that shows how relationship activity changes over time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fmuv-X5dpqoQV6yIvAmZiA.png" /><figcaption>Create Widget → Area → Knowledge Graph → leave Dynamic Source &amp; Target Filters empty → use overall relationship activity / required Relationship Type → VALIDATE → Title: Relationship Activity → Date Attribute: created_at → Interval: Day → CREATE</figcaption></figure><p>This gives us a clear visual of relationship activity over time and helps highlight periods where intelligence connections increased significantly.</p><p>With the <strong>Relationship Activity</strong> view in place, our dashboard is no longer just showing isolated objects — it is also showing how intelligence is being connected over time. At this point, we have enough operational context to stop adding widgets and look at the dashboard as a complete analyst-facing view.</p><h4>Final Dashboard View</h4><p>What started as a blank custom dashboard now brings together Indicators, Malware, Sightings, Reports, Threat Actors, Campaigns, Vulnerabilities, distributions, trends, and relationship activity in one place. The idea was never to add every visualization available in OpenCTI, but to build a view that helps an analyst understand the current threat-intelligence picture faster and decide where to look next.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Mj0hmowettr7H7ttsZmaXg.png" /><figcaption>Final Dashboard look</figcaption></figure><h4>Final Thoughts</h4><p>A good SOC dashboard is not about having the maximum number of widgets. It is about showing the right information at the right time. By combining operational KPIs with trends, threat context, reports, vulnerabilities, and relationship activity, OpenCTI can become much easier to use as a daily decision-support view rather than just a large intelligence repository. The final question for the analyst remains simple: <strong>what changed, what matters, and where should I investigate next?</strong></p><p>Thanks for reading. I hope this practical walkthrough gives you a clearer idea of how OpenCTI can be shaped into a useful daily operational dashboard for SOC analysts.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e8809dde8bee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The SOC Doesn’t Have a Data Problem. It Has a Connection Problem. This Is Where OpenCTI Comes In]]></title>
            <link>https://medium.com/@sforsmruti/the-soc-doesnt-have-a-data-problem-it-has-a-connection-problem-this-is-where-opencti-comes-in-dc1dd4384d5d?source=rss-2664bdba8504------2</link>
            <guid isPermaLink="false">https://medium.com/p/dc1dd4384d5d</guid>
            <category><![CDATA[threat-intelligence]]></category>
            <category><![CDATA[threat-detection]]></category>
            <category><![CDATA[opencti]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[cyber-threat-intelligence]]></category>
            <dc:creator><![CDATA[Smruti Ranjan Pradhan]]></dc:creator>
            <pubDate>Tue, 18 Aug 2026 13:48:56 GMT</pubDate>
            <atom:updated>2026-08-18T13:48:56.045Z</atom:updated>
            <content:encoded><![CDATA[<p>A modern SOC has no shortage of data. SIEM, firewalls, EDR, threat feeds, vulnerability scanners, and many other security tools are constantly telling us something. But during a real investigation, one question still remains: how are all these pieces connected?</p><p>Hi folks, I’m Smruti Ranjan Pradhan, and in this blog, I want to explore this problem from a practical point of view.</p><p>Instead of only discussing what OpenCTI is, we will actually work through it. We’ll take security information, add observables and indicators, connect threat actors, malware, techniques and infrastructure, explore sightings and relationships, build an investigation, document intelligence through reports, and finally see how that intelligence can move into incident response, RFI and actionable remediation. Your walkthrough already follows this practical progression from relationships and investigations through cases and response.</p><p>Because one tool may tell us what happened, another may provide threat context, and another may show how an attacker operates. The information is already there the challenge is bringing those pieces together.</p><p>And that is where I want to look at OpenCTI differently: not simply as another threat intelligence platform, but as a place where scattered security information can start becoming a connected story.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FVubDJoN4hC56tONF3b2LQ.png" /></figure><h4>Let’s Start with the First Security Event:</h4><p>Rather than starting from a random IOC or alert, I wanted to understand how a known threat actor’s infrastructure, malware, and techniques are connected.</p><p>From the OpenCTI dashboard, I selected one of the most active threat actors available in the intelligence repository: <a href="https://attack.mitre.org/groups/G0032/"><strong>Lazarus Group</strong>.</a></p><p>The goal was simple:</p><blockquote><em>Instead of investigating a single indicator, I wanted to build a complete picture of the threat actor by correlating malware, attack techniques, locations, and indicators within a single investigation.</em></blockquote><p><strong>Step 1: Create a New Investigation</strong></p><p>Navigate to: Investigations → Create Investigation</p><p>Create a new investigation: Named as → Lazarus Group Investigation</p><p>Once the investigation is created, it starts as an empty workspace</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*sV10vjeL5r2N3IJAH8hD6A.png" /></figure><p><strong>Step 2: Add the Core Intelligence Object</strong></p><p>Click the <strong>+</strong> icon and search for: Lazarus Group</p><p>Add the Threat Actor to the investigation</p><p>At this point, we are not looking at malware or indicators yet. We are simply defining the focus of the investigation.</p><p><strong>Step 3: Enrich the Investigation</strong></p><p>Next, I started adding intelligence objects already associated with Lazarus Group: <a href="https://any.run/malware-trends/xworm/"><strong>XWORM</strong></a><strong>, </strong><a href="https://any.run/malware-trends/valleyrat/"><strong>ValleyRAT</strong></a><strong>, </strong><a href="https://infovistar.in/new-pondrat-malware-in-python-packages-targets-developers/"><strong>PondRAT</strong></a><strong>, </strong><a href="https://bazaar.abuse.ch/browse/tag/ThemeForestRAT/"><strong>ThemeForestRAT</strong></a><strong>, </strong><a href="https://www.pcrisk.com/removal-guides/35356-remotepe-rat"><strong>RemotePE</strong></a></p><p>Then I added several MITRE ATT&amp;CK techniques: <strong>T1059, T1566 </strong>and also added: <strong>North Korea </strong>as an associated location.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*aMK9JvLSKpZgEV8ifVuSMA.png" /></figure><p>Within a few clicks, the investigation was no longer centered around a single threat actor. It started evolving into a connected intelligence graph containing malware, techniques, locations, and indicators.</p><p>And that is where OpenCTI starts becoming interesting.</p><p>Instead of manually reading reports and switching between multiple tools, we can begin seeing the relationships directly.</p><h4>Seeing the Relationships:</h4><p>Creating an Investigation is easy. The real value begins when OpenCTI starts connecting the entities we added.</p><p>After adding Lazarus Group, malware families such as <a href="https://any.run/malware-trends/xworm/">XWORM</a>,<a href="https://any.run/malware-trends/valleyrat/"> ValleyRAT</a>, <a href="https://infovistar.in/new-pondrat-malware-in-python-packages-targets-developers/">PondRAT</a>, <a href="https://bazaar.abuse.ch/browse/tag/ThemeForestRAT/">ThemeForestRAT</a>, <a href="https://www.pcrisk.com/removal-guides/35356-remotepe-rat">RemotePE</a>, <a href="https://attack.mitre.org/">MITRE ATT&amp;CK</a> techniques, and North Korea, the investigation graph started to take shape . At first glance, these entities may appear unrelated.</p><p>But once OpenCTI correlates them, we can begin answering questions such as:</p><ul><li>Which malware is associated with Lazarus?</li><li>Which ATT&amp;CK techniques are commonly used?</li><li>What infrastructure or locations are connected to the activity?</li><li>How are different pieces of intelligence related?</li></ul><p>This is where the graph view becomes useful.</p><p>Instead of opening multiple reports and manually connecting information, OpenCTI visualizes the relationships between all intelligence objects in a single view</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*GuhHK4rApnqV7oXzqCZAZw.png" /></figure><p>We are looking at a connected attack story.</p><p>And that leads to an important question:</p><blockquote><strong><em>Where does all this intelligence come from?</em></strong></blockquote><p>To answer that, we need to move beyond the investigation and look at the intelligence source itself.</p><h4>Intelligence Needs a Source:</h4><p>As the investigation grew, one question became important:</p><blockquote><strong><em>Where is all this intelligence coming from?</em></strong></blockquote><p>To answer that, I created a <strong>Threat Intelligence Report</strong> for the Lazarus Group.</p><p>Instead of storing intelligence as plain text, I linked the report with: <strong>Lazarus Group, XWORM, ValleyRAT, MITRE ATT&amp;CK Techniques &amp; Related Indicator</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*OASyThD2_wWW_D2B4X06-w.png" /></figure><p>What started as a simple report quickly became a connected intelligence object. Now, instead of searching multiple places, I could pivot directly from the report to the threat actor, malware, techniques, and indicators associated with it. This is where OpenCTI started feeling less like a repository and more like a relationship engine.</p><p>But intelligence isn’t always validated from day one.</p><p>Sometimes, we have suspicious indicators that still need verification before becoming part of a confirmed investigation.</p><h4>Organizing Unverified Intelligence:</h4><p>Not every indicator is immediately trustworthy.</p><p>During investigations, we often receive suspicious IPs, domains, or hashes from threat feeds, blogs, or external sources. Before linking them to a threat actor or campaign, they need validation.</p><p>For this purpose, I created a <strong>Grouping</strong> called: <strong><em>Suspicious Lazarus Infrastructure Under Review </em></strong>and added related malware, indicators, vulnerabilities, and sectors to it.</p><p>Think of Groupings as a temporary holding area for intelligence that is still under analysis. Once the indicators are validated, they can later be promoted into reports, investigations, or threat campaigns.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*MlD7oJgbD89wNq_2F-BBnA.png" /></figure><h4>Understanding Malware Beyond a Hash:</h4><p>At this point, I had connected a threat actor, reports, indicators, and supporting intelligence. The next question was:</p><blockquote><strong><em>What does the malware actually do?</em></strong></blockquote><p>This is where <strong>Malware Analysis</strong> becomes useful. I created a malware analysis entry for the Lazarus investigation and linked it with: <strong><em>Lazarus Group, Associated malware families, MITRE ATT&amp;CK techniques &amp; Related indicators</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*iYyxxqL79hnSlxj7COOq3w.png" /></figure><p>Instead of treating malware as a file hash or name, OpenCTI allows us to record behavioral findings such as persistence mechanisms, network communication, file activity, and attacker techniques. This transforms malware from a simple indicator into actionable intelligence.</p><h4>Capturing Analyst Knowledge:</h4><p>Threat intelligence isn’t just about indicators and malware. It’s also about preserving analyst findings.</p><p>For this, I used:</p><ul><li><strong>Notes</strong> to document observations and conclusions.</li><li><strong>External References</strong> to link intelligence back to its original source, such as MITRE ATT&amp;CK or vendor reports</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T1oN5XHHhfQKXq0AnMuAbw.png" /></figure><p>This ensures that anyone revisiting the investigation can understand not only <em>what was found</em>, but also <em>why it matters and where it came from</em>. Once the intelligence was documented and validated, the next logical step was <em>Turning intelligence into action.</em></p><h4>Turning Intelligence Into Action:</h4><p>Collecting intelligence is useful. Acting on it is where it creates value.</p><p>Once the investigation was enriched and validated, I moved to the <strong>Cases</strong> section to track operational activities such as: Incident Response (IR), Request for Information (RFI), Request for Takedown (RFT), Tasks and Feedback .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*KSu9hbuwNRyWbN8UrOjq-g.png" /></figure><p>This bridged the gap between intelligence and operations. Instead of keeping actions in emails or spreadsheets, OpenCTI provided a structured workflow to investigate, enrich, remediate, and track progress from a single place.</p><h4>What Changed for Me After Using OpenCTI:</h4><p>Before working with OpenCTI, I used to view threat intelligence as a collection of individual data points.</p><p>An IP address was just an IP address, A malware family was just a name, A threat report was just another PDF sitting in a repository. But while building this Lazarus investigation, something became clear .</p><blockquote>The real value of intelligence is not in the data itself. It’s in the relationships between the data.</blockquote><p>Once indicators, malware, techniques, infrastructure, and threat actors were linked together, they stopped being isolated objects and started telling a story.</p><h4>Conclusion:</h4><p>A modern SOC rarely struggles with a lack of data. It struggles with a lack of context. While building this Lazarus investigation, I realized that the real challenge isn’t collecting indicators, reports, or malware samples. It’s understanding how they relate to one another. That’s where OpenCTI stands out.</p><p>By connecting threat actors, malware, techniques, indicators, infrastructure, and investigations, it transforms scattered information into a meaningful intelligence story.</p><p>In the end, the biggest lesson was simple:</p><blockquote><strong><em>Data tells us what happened. Relationships tell us why it matters.</em></strong></blockquote><p>And that’s exactly what makes OpenCTI such a powerful platform for threat intelligence and investigation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dc1dd4384d5d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I Spend More Time Proving Myself Wrong Than Hunting Threats]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@sforsmruti/why-i-spend-more-time-proving-myself-wrong-than-hunting-threats-a8ce2c843d91?source=rss-2664bdba8504------2"><img src="https://cdn-images-1.medium.com/max/1662/1*Nh5Obgyog_dsxU9W70htPQ.png" width="1662"></a></p><p class="medium-feed-snippet">A few weeks ago, I was deep into an investigation that initially looked like a serious security incident. There was unusual login patterns&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@sforsmruti/why-i-spend-more-time-proving-myself-wrong-than-hunting-threats-a8ce2c843d91?source=rss-2664bdba8504------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@sforsmruti/why-i-spend-more-time-proving-myself-wrong-than-hunting-threats-a8ce2c843d91?source=rss-2664bdba8504------2</link>
            <guid isPermaLink="false">https://medium.com/p/a8ce2c843d91</guid>
            <category><![CDATA[dfir]]></category>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[threat-intelligence]]></category>
            <category><![CDATA[hypothesis-driven-hunting]]></category>
            <category><![CDATA[detection-engineering]]></category>
            <dc:creator><![CDATA[Smruti Ranjan Pradhan]]></dc:creator>
            <pubDate>Wed, 08 Jul 2026 13:48:51 GMT</pubDate>
            <atom:updated>2026-07-08T13:48:51.640Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The OWASP Top 10 Isn’t a List of Bugs — It’s a List of Human Habits]]></title>
            <link>https://medium.com/@sforsmruti/the-owasp-top-10-isnt-a-list-of-bugs-it-s-a-list-of-human-habits-e7d40aaf5735?source=rss-2664bdba8504------2</link>
            <guid isPermaLink="false">https://medium.com/p/e7d40aaf5735</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[owasp-top-10]]></category>
            <category><![CDATA[secure-coding]]></category>
            <category><![CDATA[secure-by-design]]></category>
            <dc:creator><![CDATA[Smruti Ranjan Pradhan]]></dc:creator>
            <pubDate>Fri, 01 May 2026 12:47:46 GMT</pubDate>
            <atom:updated>2026-05-01T12:47:46.214Z</atom:updated>
            <content:encoded><![CDATA[<p>For more than 20 years, the OWASP Top 10 has been guiding the world on the most critical web security risks. It started back in 2003, and since then, it has been updated again and again yet something strange keeps happening. The same types of vulnerabilities keep coming back. Injection, broken authentication, misconfiguration… we have known about them for years. So here’s a question worth pausing for: if we already know the problem, and we already know the solution, why does it still exist today? Why haven’t we completely eliminated these issues after two decades? Hi folks, I am Smruti Ranjan Pradhan, and this is exactly what we’re going to explore. Because the truth is, the OWASP Top 10 is not just a list of technical flaws. It’s a reflection of how we build, how we think, and the habits we fail to change. These vulnerabilities are not surviving because they are unsolvable they are surviving because we keep repeating the same patterns. And once you start looking at it this way, the entire story of application security begins to make a lot more sense.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XiEvq4RdQ4nC6-H9d3uT-A.png" /><figcaption>The real vulnerabilities live in us, not just in code.</figcaption></figure><h4>The Same Problems, Just New Versions:</h4><p>If you go back to the early days of the OWASP Top 10 in 2003 and compare it with today’s list, you’ll notice something surprising the names may change, the technology may evolve, but the core problems remain the same. Injection becomes more advanced, authentication issues take new forms, and misconfigurations grow with cloud environments, but the root cause doesn’t disappear. It simply adapts. This is not because the industry lacks solutions. In fact, we have better tools, better frameworks, and more awareness than ever before. Yet, these vulnerabilities continue to exist because they are tied to how we work. <strong>Deadlines push teams to take shortcuts, assumptions replace validation, and “temporary fixes” quietly become permanent</strong>. Over time, these decisions stack up, and the same weaknesses reappear in different shapes. So what we are really seeing is not the failure of technology it is the repetition of human patterns. The vulnerabilities evolve, but the habits behind them stay the same.</p><h4>Why Do These Problems Keep Coming Back?</h4><p>At some point, almost every team feels confident that a vulnerability has been fixed. The issue is patched, the ticket is closed, and everything looks secure again. But after some time whether in a new release, a new feature, or a different application the same problem appears again. This doesn’t happen because the original fix was wrong. It happens because the fix was applied in one place, while the underlying pattern was never fully addressed. In many cases, security is treated as a one-time task instead of something that needs to be followed consistently across everything we build. If you look closely, it’s easy to see how this happens. One part of an application may validate input properly, while another skips it. One system may enforce strong authentication, while another uses weaker defaults to save time. A server might be securely configured, but a newly deployed one may not receive the same attention. These small gaps are often invisible at first, but over time, they recreate the same risks we thought were already solved.</p><p>The truth is simple: vulnerabilities don’t return because we lack solutions they return because we don’t apply them everywhere, every time. Security rarely fails in one big moment; it slips through small decisions, missed steps, and assumptions that something is “already handled.” And as long as systems are built this way, the same issues will continue to reappear. That’s why the problem never fully disappears. We are not just fixing systems we are constantly building new ones. And every new system is a chance to either follow secure practices or repeat old mistakes. Until security becomes a habit, not just a step, the cycle will continue.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J6tEYSnz3y1MxD5nm55ReQ.png" /><figcaption>Security flaws aren’t lines of code they’re human patterns.</figcaption></figure><h4>What Actually Disappeared (And Why?)</h4><p>Not every vulnerability stayed the same. Some issues that were very common in the early OWASP Top 10 (like 2003–2010) became less visible in later releases not because attackers stopped, but because development practices improved.</p><p>For example, <strong>Buffer Overflow</strong> was a major issue in older applications and appeared in early lists, but it faded as modern languages like Java, Python, and managed runtimes handled memory safely by default. <strong>Insecure Direct Object References (IDOR)</strong> was highlighted separately in 2007 and 2010, but later it got absorbed into broader access control issues as frameworks started enforcing better authorization patterns. <strong>Cross-Site Request Forgery (CSRF)</strong> was a top concern around 2010, but became less common as frameworks began adding built-in CSRF tokens automatically. Similarly, <strong>unvalidated redirects and forwards</strong> were removed after 2013 as secure coding practices and validation checks became more standard.</p><p>But these vulnerabilities didn’t fully disappear they became harder to exploit because the solution became part of the system. Secure defaults, built-in protections, and better frameworks reduced the chance of repeating those mistakes. At the same time, some vulnerabilities didn’t fade they evolved. Injection moved into APIs and complex queries, authentication issues shifted into identity and token problems, and misconfigurations expanded into cloud environments.</p><p>So the real story is simple: vulnerabilities don’t just get fixed they either become part of secure design, or they come back in a new form.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PiciuCw2MMr5EiDv7j6Ang.png" /><figcaption>The story isn’t disappearance — it’s transformation.</figcaption></figure><h4>Why Some Vulnerabilities Never Go Away:</h4><p>If you look at every release of the OWASP Top 10, a few vulnerabilities never really leave. <strong>Injection</strong>, <strong>Broken Access Control</strong>, and <strong>Security Misconfiguration</strong> have been there in different forms for years. Their names may change slightly, but the core problem remains the same.</p><blockquote>These vulnerabilities don’t stay because they are difficult to fix. They stay because they are easy to repeat.</blockquote><p>Injection happens when input is trusted without proper validation. Broken access control appears when permissions are not enforced correctly. Misconfiguration shows up when systems are set up in a hurry or without proper checks. These are not rare or complex situations they are part of everyday development and operations. That’s the key reason they never go away. They depend on people making the right decision every single time. And in real environments where teams are moving fast, handling multiple tasks, and working under pressure those decisions are not always consistent.</p><p>Unlike some older vulnerabilities, these cannot be completely removed by frameworks or tools alone. They require constant attention, awareness, and discipline. And that’s the difference. The vulnerabilities that disappeared were turned into secure defaults. The ones that remain are still dependent on human habits.</p><p>Until those habits change, these vulnerabilities will continue to appear again and again, in every new system we build.</p><h4>How Do We Break This Cycle?</h4><p>If the same vulnerabilities keep coming back, the solution is not just to fix them again it is to change how we build from the start. For years, security has often been treated as something we add later, after development is done. But as we’ve seen, this approach only solves problems temporarily. To truly reduce these risks, security needs to become part of everyday work, not a separate step.</p><p>This starts with small but consistent practices. <strong><em>Validating input should not be optional it should be automatic. Access control should not depend on assumptions it should be clearly defined and tested. System configurations should not rely on memory they should follow standard, repeatable processes.</em></strong> When these actions become part of how we build every system, the chances of repeating old mistakes become much lower.</p><p>It also means using tools and frameworks the right way. Modern technologies already provide many built-in protections, but they only work when they are properly used. Secure defaults, automated checks, and regular reviews help reduce human error and make security more reliable.</p><blockquote><strong>The goal is simple: move from fixing problems one by one to preventing them from happening again.</strong></blockquote><p>Because in the end, security is not just about finding vulnerabilities it’s about building systems in a way where those vulnerabilities don’t get a chance to return. And once that mindset becomes part of the process, the cycle finally starts to break.</p><h4>Conclusion — <em>It Starts With Us:</em></h4><p>After all these years of the OWASP Top 10, the biggest lesson is very simple: the problem is not that we don’t know what to fix we already do. The real problem is that we don’t follow those practices every time we build something new. That’s why the same vulnerabilities keep coming back. Not because they are difficult, but because they are easy to overlook. Some issues disappeared because we made them part of the system. They no longer depend on people remembering what to do. But the ones that are still here depend on us our decisions, our habits, and the way we work under pressure. So, the change we need is not only in tools or technology. It is in how we think while building systems.</p><p>When security becomes something, we do by default not something we add later that’s when things start to improve. Because in the end, vulnerabilities don’t survive because of code alone. They survive because of how we build that code. And once that changes, the story of security starts to change too.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e7d40aaf5735" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automation Isn’t Enough: Why Manual Threat Hunting Still Matters]]></title>
            <link>https://medium.com/@sforsmruti/automation-isnt-enough-why-manual-threat-hunting-still-matters-8f8921e0a924?source=rss-2664bdba8504------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f8921e0a924</guid>
            <category><![CDATA[blue-team]]></category>
            <category><![CDATA[cyber-threat]]></category>
            <category><![CDATA[threat-detection]]></category>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Smruti Ranjan Pradhan]]></dc:creator>
            <pubDate>Thu, 23 Apr 2026 13:57:57 GMT</pubDate>
            <atom:updated>2026-04-23T13:57:57.213Z</atom:updated>
            <content:encoded><![CDATA[<p>It sounds a bit strange, right? In a world where everything is automated alerts popping up, SIEM rules running all the time, and even AI suggesting what to do next, why would anyone still talk about manual threat hunting? Hi folks, <a href="https://smrutiranjanpradhan.co.in/">Smruti Ranjan Pradhan</a> here. And honestly, I used to think the same way. If tools are already doing so much, why should I spend time digging into raw logs myself? But over time, I realized something very simple, <strong><em>automation only works on what it already knows</em></strong>. It follows fixed rules, known patterns, and expected behavior. Anything new, anything slightly different, can quietly pass without raising any alert. That’s where the real problem starts. <strong><em>We begin to trust the tools so much that we stop asking questions on our own</em></strong>. This blog is not about saying automation is bad — it’s actually very useful. But it’s about understanding that it’s not enough on its own. Threat hunting is not about running complex queries or copying use cases from somewhere. It’s about building a way of thinking where you look at logs, understand what’s happening, and question things that don’t feel right. And once you start thinking like that, everything changes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JNOOQV2Dq7ulGaJl7826RA.png" /><figcaption>Machines detect patterns; humans detect intent.</figcaption></figure><h4>The Reality No One Talks About:</h4><p>Here’s the part that most people don’t openly discuss. Automation is powerful but it has limits. Every alert you see is based on something that was already defined, already known, already expected. The system is not thinking on its own; it’s just following logic that someone has written. And because of that, anything new or slightly different can easily go unnoticed. Not because it’s not there but because it doesn’t match any rule.</p><p>This is where the biggest misunderstanding happens. Many people assume that if there is no alert, everything is fine. But in reality:</p><blockquote><strong><em>Absence of alerts does not mean absence of threats.</em></strong></blockquote><p>I realized this when I started looking at raw logs more closely. There were no alerts, nothing flagged as suspicious but still, certain patterns didn’t feel right. Repeated connections, unusual communication flows, behavior that looked normal at first glance but had small differences. These were not things any tool pointed out. I had to notice them myself.</p><p>And that’s when the shift happened. Instead of depending only on alerts, I started observing behavior. Instead of waiting for detection, I started questioning what I was seeing. Because sometimes, the most important signals are not the ones that trigger alerts they are the ones that quietly blend in.</p><h4>Seeing Logs Differently (From Data to Behavior):</h4><p>At the beginning, logs can feel like pure noise just lines of data, random fields, numbers, and events that don’t seem to connect. It’s easy to look at them and think there’s nothing meaningful there. But that changes the <strong><em>moment you stop treating logs as data and start seeing them as behavior.</em></strong> Every log is an action. Every field tells you something about what happened, where it happened, and how it happened. When you look at logs this way, they stop being confusing and start becoming useful.</p><p>But this shift only works when you understand your environment. You need to know how your systems are designed, how they communicate, and what normal activity looks like. That includes your architecture, your data flow, and how different components interact with each other on a daily basis. Without this context, everything can look either normal or suspicious, and you won’t be able to tell the difference.</p><p>That’s why this step is so important. Before hunting for anything, you need to build a clear picture of your environment. Because without understanding what “normal” looks like, you can’t identify what’s “abnormal.” And without that, real threat hunting simply doesn’t exist.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gByKBTBRlamVgUS_-VFumA.png" /><figcaption>Noise becomes narrative when logs reveal behavior.</figcaption></figure><h4>Where Hypothesis is Born (The Core of Hunting):</h4><p>This is where real threat hunting actually begins not with tools, not with queries, but with thinking. Once you start understanding your logs and your environment, you begin to notice small things. Patterns that repeat, behaviors that feel slightly off, activities that don’t fully make sense. And that’s where everything starts with <strong>observation</strong>.</p><p>From observation, a simple question comes up.<br><strong><em> “Why is this happening?”<br> “Is this normal?”</em></strong></p><p>These questions may look basic, but they are powerful. Because the moment you start questioning what you see, you are no longer just monitoring you are analyzing.</p><p>This is how a hypothesis is born. It’s not something complex or predefined. It’s just a structured thought based on what you observe. For example, if a system is communicating with multiple other systems in a way you haven’t seen before, your mind naturally starts asking <strong><em>is this expected behavior, or something else?</em> </strong>That thought itself is your hypothesis.</p><p>This is where curiosity plays a big role. A threat hunter is not someone who waits for alerts they are someone who keeps asking questions, even when everything looks normal on the surface.</p><p>At the same time, you need to think from two sides. As a defender, you ask <strong><em>what visibility do I have, and what can I see in my logs?</em></strong> But as an attacker, you think <strong><em>if I wanted to move inside this environment without getting caught, how would I do it?</em></strong> When you combine these two perspectives, your questions become sharper, and your hypotheses become stronger.</p><p>And that’s the core idea:</p><blockquote><strong><em>Threat hunting starts with a question, not a query.</em></strong></blockquote><p>Because once the question is clear, everything else becomes easier.</p><h4>From Hypothesis to Detection (The Execution Layer):</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bMTnNaCH5ZXA--2gr8NXNA.png" /><figcaption>True threat hunting lives in the shift from IOC to IOA.</figcaption></figure><p>Once your hypothesis is clear, the next step becomes much easier. This is where most people make a mistake they start with queries. But in reality, a query is not the starting point, it’s just a way to validate what you are already thinking. First comes observation, then your thought process, then the logic and only after that comes the query.</p><p>When your thinking is clear, your queries don’t need to be complicated. Even a simple condition can give you meaningful results because it is backed by intent. You are no longer guessing or copying something you are testing your own understanding of the environment.</p><p>This is also where the shift from IOC to IOA becomes important. Earlier, detection mostly relied on indicators specific IPs, domains, or signatures. But these things change quickly. Attackers can easily modify them. Behavior, on the other hand, is much harder to hide. The way something operates, communicates, or interacts within a system often leaves patterns. That’s why focusing on behavior IOA is much more powerful than relying only on indicators.</p><p>Now, coming to AI and automation. Yes, they can help. They can suggest queries, highlight patterns, and speed up analysis. But they don’t understand your environment the way you do. They don’t know what is normal in your network, what is expected, or what has changed recently. They work on general knowledge, not your specific context. And that’s a big gap.</p><p>So while automation can generate alerts and AI can assist in analysis, they cannot replace your thinking.</p><blockquote><strong><em>Automation can alert, but it can’t think.</em></strong></blockquote><p>And that’s exactly why your role as a threat hunter matters.</p><h4>Conclusion: The Mindset Shift :</h4><p>At the end of the day, the biggest change is not in the tools you use it’s in the way you think. Instead of chasing new queries or depending completely on automation, start focusing on understanding what is happening in your environment. Start asking simple questions. Start noticing patterns.</p><p>Automation is helpful, no doubt. But it should support your thinking, not replace it. The real strength of a threat hunter comes from curiosity, from observing small details, and from connecting things that don’t look obvious at first.</p><p>So don’t just wait for alerts. Don’t just run queries. Start thinking.</p><p>Because in the end:</p><p><strong><em>Threat hunting is not something someone gives you it’s something you build within yourself.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f8921e0a924" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Evidence Attackers Can’t Erase: A Practical Approach to Post-Incident Investigation]]></title>
            <link>https://medium.com/@sforsmruti/the-evidence-attackers-cant-erase-a-practical-approach-to-post-incident-investigation-c96adef92fbb?source=rss-2664bdba8504------2</link>
            <guid isPermaLink="false">https://medium.com/p/c96adef92fbb</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[incident-response]]></category>
            <category><![CDATA[digital-forensics]]></category>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[dfir]]></category>
            <dc:creator><![CDATA[Smruti Ranjan Pradhan]]></dc:creator>
            <pubDate>Fri, 27 Mar 2026 07:13:57 GMT</pubDate>
            <atom:updated>2026-03-27T07:13:57.001Z</atom:updated>
            <content:encoded><![CDATA[<p>Most attacks start quietly — a small change in behavior, a login that feels unusual, or a system doing something slightly out of place. Individually, these signs don’t mean much. But together, they can point to something serious happening in the background.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MBOvNYhhbqoU8XafGLjtxQ.png" /><figcaption>What appears normal on the surface can hide deeper activity underneath</figcaption></figure><p>I’m <a href="https://smrutiranjanpradhan.co.in/">Smruti Ranjan Pradhan</a>, and one thing I’ve learned from real investigations is this: <strong>attackers don’t get caught because of what they show they get caught because of what they leave behind.</strong> They may delete files, clear logs, and try to disappear, but they can never fully erase their behavior. That evidence stays, scattered across endpoints, identities, and network activity.</p><p>This is where post-incident investigation truly begins. Not with alerts, but with understanding. The goal is to take these small, disconnected traces and connect them into a clear story how the attack started, how it moved, and how far it went.</p><p>This blog is about that practical approach. Turning raw data into real evidence. Connecting the dots across systems. And uncovering the truth hidden behind what looks like normal activity.</p><blockquote><strong>Because attackers may try to stay invisible <br>but the evidence they leave behind never lies.</strong></blockquote><h4>Where to Start After Detection:</h4><p>The moment something unusual is detected, the biggest mistake is rushing into conclusions. An alert or anomaly is only a signal, not the full picture. The first step is to slow down and understand what you are looking at. Instead of reacting immediately, the focus should be on defining the scope what system is involved, what type of activity is observed, and whether it is isolated or part of something larger.</p><p>At this stage, preserving evidence is more important than fixing the issue. It is natural to want to stop the activity quickly, but acting too fast can destroy valuable traces that explain how the attack happened. The priority should be to secure the current state, ensure logs are retained, and avoid making changes that could overwrite or remove critical data.</p><p>This step sets the foundation for the entire investigation. If handled correctly, it ensures that the evidence remains intact and reliable. If rushed, it can lead to gaps that make the rest of the analysis incomplete.</p><p><strong>The goal here is simple understand before you act and preserve before you change.</strong></p><h4>Collect the Right Evidence:</h4><p>Once the situation is understood, the next step is to collect evidence but not everything blindly. The focus should be on collecting what is relevant before it disappears. Useful evidence usually comes from three main areas: <strong>endpoints, identity systems, and network activity</strong>. Each of these holds a different part of the story.</p><p>The key here is prioritization. <em>Endpoint data can show what was executed</em>, <em>identity logs can reveal who accessed what</em>, and <em>network data can indicate where communication happened</em>. Collecting these early ensures that important traces are not lost due to log rotation or system changes. At this stage, the goal is not deep analysis, but making sure the right data is available for later investigation.</p><h4>Understanding the Evidence Lifecycle:</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*30u93q3GJs-SBu99TcnlMQ.png" /><figcaption>Raw data only becomes evidence when it is examined, connected, and understood in context</figcaption></figure><p>This lifecycle explains how investigation actually works in practice. It starts with collecting raw data from systems, then examining it to filter what is useful. After that, the data is analyzed by connecting events and understanding behavior. Finally, everything is reported in a clear way. This process shows that raw data alone is not enough it only becomes evidence when it is properly examined and connected into a meaningful explanation.</p><h4>Analyze Endpoint Activity:</h4><p>Once evidence is collected, the endpoint is the best place to begin analysis. This is where most attacks start, even if nothing was visibly noticed at the time. The focus here should be on understanding execution behavior what ran, how it ran, and what followed after.</p><p><em>Unusual process activity, unexpected command execution, or applications triggering scripts </em>can reveal how the attacker gained initial access. These are often small deviations from normal behavior, but they provide the first clear indication of compromise. Endpoint analysis helps answer the most important early question how did it start?</p><h4>Track Identity Usage:</h4><p>After understanding execution, the next step is to track identity usage. Attackers rarely stay limited to one system. Instead, they begin using valid accounts to move across the environment. This makes their activity appear normal at first glance.</p><p>By reviewing login patterns, access behavior, and movement between systems, it becomes possible to identify where the attacker went next. Unusual access patterns, logins at unexpected times, or usage of accounts beyond their normal scope can reveal how far the attack has spread. This step helps shift the investigation from a single system to a broader environment view.</p><h4>Review Network Behavior:</h4><p>Network activity provides another critical layer of visibility. Even if attackers try to clean systems, they still need to communicate, and that communication leaves patterns behind. These patterns may not look suspicious immediately, but over time they become clear.</p><p>Repeated connections, consistent intervals, or communication with unfamiliar destinations can indicate command and control activity or data movement. Network analysis helps confirm whether the attacker was interacting with external systems and adds another layer to the overall understanding of the attack.</p><h4>Correlate the Evidence:</h4><p>At this stage, individual findings start to make sense only when they are connected. Endpoint activity explains how the attack started, identity logs show how access was used, and network data reveals communication. When these pieces are combined, they form a complete sequence.</p><p>This is where investigation moves from observation to understanding. Instead of looking at isolated events, the focus shifts to building a timeline. Each action leads to the next, forming a clear path of the attacker’s movement. Correlation is what transforms data into actual evidence.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/788/1*RBWI6uNnh3ccGnoZ9wEGzA.png" /><figcaption>Evidence is not a single event it is a combination of connected actions</figcaption></figure><h4>Practical Scenario Walkthrough:</h4><p>To understand this better, consider a simple scenario. A user opens a document received through email, and nothing unusual appears on the screen. In the background, a command executes silently. Shortly after, the same user account is used to access another system, and then multiple systems in sequence.</p><p>At the same time, one of those systems begins making repeated outbound connections. Individually, these actions may not seem critical. But when viewed together, they reveal a complete attack path — initial execution on the endpoint, movement through identity usage, and communication through the network. This is how scattered traces become a clear story.</p><h4>Maintain Evidence Integrity:</h4><p>Collecting evidence is not enough it must also be preserved correctly. Any unnecessary changes to systems or data can affect the reliability of the findings. This makes it important to handle evidence carefully and avoid actions that may alter it.</p><p>Maintaining integrity ensures that the investigation remains trustworthy. It allows findings to be validated and confidently used for decision-making. Without this, even correct analysis can lose its value.</p><h4>What Makes This Approach Effective:</h4><p>This approach works because it focuses on behavior rather than isolated alerts. Instead of reacting to single events, it looks at how actions are connected across systems. This makes it easier to identify patterns that would otherwise go unnoticed.</p><p>By following a structured flow from collection to correlation the investigation becomes clearer and more reliable. It reduces guesswork and provides a logical way to understand complex situations.</p><h4>Final Thought:</h4><p>Attackers may try to hide their presence, but they cannot completely remove the traces of their actions. Those traces remain across different systems, waiting to be connected.</p><p>The goal of investigation is not just to find one indicator, but to bring all the pieces together into a clear and accurate story.</p><blockquote><strong>Because in the end, data shows activity, <br> but evidence reveals the truth.</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c96adef92fbb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[If DNS Lies, Everything Lies: Breaking and Securing the Internet’s Trust Layer]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@sforsmruti/if-dns-lies-everything-lies-breaking-and-securing-the-internets-trust-layer-9f176fb67d73?source=rss-2664bdba8504------2"><img src="https://cdn-images-1.medium.com/max/891/1*ECox4tDKtwYqOW7kd_DTyQ.png" width="891"></a></p><p class="medium-feed-snippet">Before any website loads, something silently decides where you&#x2019;re about to go and you trust it without even thinking. No alerts, no&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@sforsmruti/if-dns-lies-everything-lies-breaking-and-securing-the-internets-trust-layer-9f176fb67d73?source=rss-2664bdba8504------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@sforsmruti/if-dns-lies-everything-lies-breaking-and-securing-the-internets-trust-layer-9f176fb67d73?source=rss-2664bdba8504------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f176fb67d73</guid>
            <category><![CDATA[dns]]></category>
            <category><![CDATA[dns-servers]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[dnssec]]></category>
            <dc:creator><![CDATA[Smruti Ranjan Pradhan]]></dc:creator>
            <pubDate>Wed, 18 Mar 2026 14:10:08 GMT</pubDate>
            <atom:updated>2026-03-18T14:10:08.934Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The Invisible Enemy How I Built an Automated Hunter to Catch Malware That EDRs Miss]]></title>
            <link>https://medium.com/@sforsmruti/the-invisible-enemy-how-i-built-an-automated-hunter-to-catch-malware-that-edrs-miss-8603e4b0b6ce?source=rss-2664bdba8504------2</link>
            <guid isPermaLink="false">https://medium.com/p/8603e4b0b6ce</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[memory-forensics]]></category>
            <category><![CDATA[malware-analysis]]></category>
            <category><![CDATA[digital-forensics]]></category>
            <dc:creator><![CDATA[Smruti Ranjan Pradhan]]></dc:creator>
            <pubDate>Thu, 05 Feb 2026 14:02:43 GMT</pubDate>
            <atom:updated>2026-02-05T14:02:43.785Z</atom:updated>
            <content:encoded><![CDATA[<p>For years, cybersecurity has been built on a simple belief malware exists as a file on disk. Traditional defenses like antivirus scan files, EDR tools monitor processes, and security teams depend on logs to detect suspicious activity. The assumption has always been that if something malicious is present, it will leave a visible trace such as a suspicious executable, an unusual registry entry, or a compromised application. However, modern attackers have completely changed this approach. Instead of planting malware on a victim’s computer, they now operate directly in memory (RAM), using legitimate tools like PowerShell, Windows Management Instrumentation (WMI), or exploitation frameworks to run malicious code without ever touching the disk. To conventional security tools, this activity often appears normal and harmless.</p><p>As a result, your antivirus sees nothing unusual, your EDR reports everything as “clean,” and your system looks secure yet an attacker could already be inside, silently stealing credentials, logging keystrokes, or moving across your network. This is the reality of fileless attacks: a stealthy and advanced form of threat that lives entirely in memory, making it extremely difficult for traditional defenses to detect.</p><p>I am <a href="https://smrutiranjanpradhan.co.in/">Smruti Ranjan Pradhan</a>, a Threat Intelligence analyst, and my understanding of security changed when I investigated a real incident in which an attacker remained hidden inside a corporate network for 18 days without triggering a single alert. There were no malicious files, no obvious malware, and no clear warning signs in the logs only faint evidence in volatile memory that went unnoticed. That experience made it clear to me that if defenders continue to rely only on diskbased detection, attackers will always stay one step ahead. To truly protect systems, we must shift our focus from files to memory. This realization ultimately led me to build an automated memory hunting system designed to detect invisible threats even when nothing is written to disk.</p><h4>Inside the Invisible Intrusion:</h4><p>The attack didn’t look dangerous at all. There were no alerts, no malware files, and no obvious signs of compromise. Employees only complained that their computers were getting slow. When we checked our security tools, everything looked perfect the EDR dashboard was green, antivirus scans were clean, and logs showed nothing unusual. It felt safe, but something still didn’t seem right.</p><p>During a routine check, one of our analyst noticed a <strong>PowerShell process</strong> using unusually high memory in Task Manager. That small detail raised suspicion and pushed us to investigate deeper.</p><p>We later discovered that the attacker never used traditional malware. Instead, they used legitimate Windows tools like <strong>PowerShell</strong>, <strong>WMI</strong>, and <strong>rundll32</strong> to stay hidden. They loaded a Cobalt Strike beacon directly into memory using a technique called reflective <strong>DLL injection</strong> meaning no malicious file was ever saved on the computer. Their communication with the attacker’s server happened over normal-looking HTTPS traffic, so nothing appeared suspicious on the network.</p><p>Traditional security tools failed because they were designed to look at files, not memory. Antivirus found nothing because there were no bad files. EDR saw PowerShell running but missed the malicious code inside it. Logs only showed that PowerShell executed, not what it was actually doing. In simple terms we were watching the hard drive, but the attacker was hiding in RAM.</p><p>The real breakthrough came when we finally took a memory dump. We found a PowerShell process without a parent, a suspicious DLL injected into a normal Windows process, and a strange network connection from a system process to an unknown IP address. That’s when it became clear the evidence was always there; we just weren’t looking in the right place.</p><p>That experience changed the way I approach security. I realized that waiting days to analyze memory was not an option defenders need speed, automation, and visibility into RAM. That’s why I set out to build an automated system that could capture memory, analyze it instantly, and alert me within minutes.</p><h4>My Automated Memory Hunting Pipeline:</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*asiNUfu-zkBOSQ1_YmkawQ.png" /><figcaption>The Automated Memory Forensics Pipeline.</figcaption></figure><p>This is the five-stage pipeline I use to turn a raw memory (RAM) snapshot into a clear security alert automatically, without manually running every tool.</p><p><strong>Memory Capture — Freeze the system</strong>.</p><p>I take a snapshot of RAM so everything running at that moment is preserved for investigation.</p><p><strong>Volatility Parsing — Understand what was running.</strong></p><p>The memory dump is analyzed to see active processes, their relationships, and network connections.</p><p><strong>YARA Analysis — Look for known threats.</strong></p><p>The system scans memory for patterns that match known malware or attacker tools.</p><p><strong>Python Orchestration — Automate the workflow.</strong></p><p>Python runs all tools in the right order and connects their outputs together.</p><p><strong>Alerting &amp; Reporting — Deliver results fast.</strong></p><p>The findings are turned into a simple report and an alert so analysts can act quickly.</p><p>In simple terms, the pipeline moves from <strong>capture → analyze → detect → alert</strong>, giving visibility into threats hiding in memory.</p><h4>Phase 1: Capturing the Crime Scene (Memory Capture)</h4><p>When investigating a fileless attack, capturing RAM is the most critical first step. I like to describe this as “freezing the crime scene.” Just like in a real investigation, once evidence is disturbed or lost, you can never fully recover it. In the same way, if a compromised machine is restarted or powered off, all in-memory evidence disappears instantly. That is why memory capture must happen quickly and carefully as soon as suspicious activity is observed.</p><p>For this purpose, I use <a href="https://github.com/Velocidex/WinPmem"><strong>WinPmem</strong></a>, a lightweight and trusted forensic tool for Windows. I chose WinPmem because it is reliable, minimally invasive, and widely accepted in digital forensics. It allows me to extract a full memory image while preserving as much original data as possible.</p><p>To create the memory dump, I run the following command from an elevated command prompt:</p><blockquote>winpmem.exe -o C:\forensics\memory_dump.raw</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GO_NIYWc8Izf79u-GcBwUQ.png" /><figcaption>Capturing a forensic memory image using WinPmem</figcaption></figure><p>This command captures the full contents of RAM and saves it as <strong>memory_dump.raw</strong>. The file represents a snapshot of everything running on the system at that moment processes, injected code, and active network connections forming the foundation for all later analysis.</p><h4>Phase 2: Volatility Parsing Reconstructing What Was Running</h4><p>Once the memory dump is captured, the next step is to make sense of it using <a href="https://github.com/volatilityfoundation/volatility3">Volatility3</a>. Instead of reading raw bytes, Volatility reconstructs what was actually running on the system processes, their relationships, and active network connections directly from the memory image.</p><p>I start with <strong>windows.pslist</strong> to get a complete process list and look for anomalies such as suspicious <strong>powershell.exe</strong>, <strong>wscript.exe</strong>, or <strong>rundll32.exe</strong> with unusual parents or unusually long runtimes. This quickly highlights processes that need deeper scrutiny.</p><p>Next, I run <strong>windows.netscan</strong> to map network connections back to their owning processes. If a suspicious process is communicating over HTTPS (port 443) with an unknown IP, it becomes a high-priority candidate for further analysis. By the end of this phase, I know which process is likely compromised and how it is communicating, which prepares me for focused YARA hunting in the next step.</p><h4>YARA Analysis: Hunting for Malicious Patterns in Memory</h4><p>Once I had a suspicious process from Volatility, I moved to YARA to determine whether real attacker artifacts were present in memory. YARA works like a precise pattern-matching engine: instead of scanning blindly, it searches for specific text and byte sequences that are known to appear in beacons, loaders, or in-memory implants used by modern attackers.</p><p>A YARA rule is structured in three parts:</p><p><strong>meta:</strong> describes what the rule is meant to detect</p><p><strong>strings:</strong> the exact patterns to hunt for in memory</p><p><strong>condition:</strong> the logic that defines when a true match occurs</p><p>Here is the rule I deployed in this investigation:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/706/1*eMCLxUC0A3ltUuXZKiaWZA.png" /><figcaption>A YARA rule designed to hunt for malicious artifacts living only in memory</figcaption></figure><p>The rule matched inside RAM, confirming that the artifact existed only in memory and was never written to disk. This proved that the activity was truly fileless the kind of threat traditional security tools often fail to detect.</p><blockquote>Now that we could confirm something suspicious was living in the dump, the next question became: which process owned it, and what else was it doing? That’s where Volatility3 came back into play.</blockquote><h4>Phase 4: Volatility Parsing Turning Raw RAM into a Process Story</h4><p>After confirming with YARA that something malicious existed in memory, my next step was to understand where it was living and how it was behaving. This is where <a href="https://github.com/volatilityfoundation/volatility3">Volatility3</a> became my main investigative tool.</p><p>Volatility3 does not scan the live system. Instead, it reconstructs what the system looked like at the exact moment the memory dump was taken. In simple terms, it lets me rewind time and see what was really running inside the machine even if the attacker later cleaned their tracks.</p><p>I began with windows.pslist, which is like opening a frozen version of Task Manager from the past. This gave me a full list of running processes along with their process IDs, parent processes, and start times. Here, I looked for common attacker tools such as <strong>powershell.exe</strong>, <strong>rundll32.exe</strong>, or <strong>wscript.exe</strong>, especially if they were launched by unusual parents like Word or Excel. If a process looked out of place, it became my primary suspect.</p><p>Once I found a suspicious process, I moved to <strong>windows.netscan</strong>. This plugin helped me see whether that process had been talking to the outside world. If the same PowerShell process was making outbound connections to an unfamiliar IP over port 443, that was a strong indicator of command-and-control activity.</p><p>In some cases, I also checked cmdline to see how the process was started and dlllist to look for injected modules inside it. These details helped me separate normal admin activity from real malicious behavior.</p><p>This is where everything connected: YARA showed that beacon code existed in RAM, and Volatility showed exactly which process was carrying it and where it was communicating. The threat was no longer abstract it was tied to a real process and a real network destination.</p><p>I have not included real Volatility screenshots here because memory dumps frequently contain sensitive internal details that could expose organizational systems and detection methods.</p><blockquote><strong>I have not included real Volatility screenshots here because memory dumps frequently contain sensitive internal details that could expose organizational systems and detection methods.</strong></blockquote><h4>Phase 5: Python Orchestration One Command, Full Memory Hunt</h4><p>After manually chasing artifacts across YARA and Volatility, I realized that speed mattered more than perfect forensic purity. In a real incident, every extra minute spent juggling tools increases risk. So I built a lightweight Python orchestrator that ties everything together in a single workflow. Instead of running separate commands, copying outputs, and correlating results by hand, the script automatically scans the memory dump with YARA, runs key Volatility3 plugins, and fuses all findings into a structured investigation package.</p><p>The power of this approach isn’t just automation it’s correlation. YARA alone tells me something bad exists in RAM. Volatility alone tells me what processes were running and talking to the network. The script connects those dots: when a YARA match falls inside the memory space of a specific process, that process is automatically flagged as high-risk in the final report. What used to take hours now happens in minutes.</p><p>Every analysis produces two outputs: machine-readable JSON for tooling and a clean Markdown report for human review. This means I can quickly share findings with my team, attach evidence to an incident ticket, or preserve a structured record for later investigation without rewriting anything.</p><p>If you’re interested in how this works under the hood, I’ve made the project public here:</p><blockquote><a href="https://github.com/jarvishdinocent/fileless-hunter">https://github.com/jarvishdinocent/fileless-hunter</a></blockquote><p>With this pipeline in place, a single execution gives me a complete memory triage pack YARA detections, suspicious processes, and network indicators ready for rapid response.</p><h4>Conclusion: Lessons from the Hunt</h4><p>Fileless attacks changed how I think about detection. They taught me that the absence of malware does not mean the absence of compromise. Attackers no longer need files to win they only need memory, patience, and stealth.</p><p>By shifting my focus from disk to RAM, I moved from reacting to evidence to actively hunting for it. The automated memory pipeline I built is not just a tool; it is a mindset a reminder that defenders must evolve as fast as adversaries.</p><p>This journey reinforced a simple truth that now guides every investigation I handle:</p><blockquote>“If you only look where it’s easy to see, you’ll miss where the real danger lives.”</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8603e4b0b6ce" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hidden Doors of the Web: Pentesting and Hunting API Exploits]]></title>
            <link>https://medium.com/@sforsmruti/the-hidden-doors-of-the-web-pentesting-and-hunting-api-exploits-aa7f83d63765?source=rss-2664bdba8504------2</link>
            <guid isPermaLink="false">https://medium.com/p/aa7f83d63765</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[pentesting]]></category>
            <dc:creator><![CDATA[Smruti Ranjan Pradhan]]></dc:creator>
            <pubDate>Tue, 16 Dec 2025 07:53:59 GMT</pubDate>
            <atom:updated>2025-12-17T00:18:13.267Z</atom:updated>
            <content:encoded><![CDATA[<p>Hey folks, <a href="https://smrutiranjanpradhan.co.in/">Smruti Ranjan Pradhan</a> here. Imagine walking through a building where most doors are obvious the main entrance, the office cabins, the conference hall. But hidden in the walls are secret doors that few notice. They don’t look dangerous, yet they connect rooms, carry messages, and sometimes lead straight into the vault. On the web, those hidden doors are APIs. They quietly power apps, move data, and connect systems. For a pentester, they are entry points to probe and exploit. For a threat hunter, they are trails of activity to detect and defend. In this blog, I’ll take you on a guided tour through these doors REST, SOAP, GraphQL, gRPC, and WebSockets. I’ll break them down in simple terms, show how attackers abuse them, and explain how defenders can spot the footprints. The objective is simple: make APIs understandable for everyone and reveal why they are now one of the most critical battlegrounds in cybersecurity. By the end, you’ll see APIs not just as code, but as invisible doors that decide whether attackers walk in, or defenders keep them out.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/984/1*V88keHMNiX8fywCD6y04Ww.png" /></figure><h4>API: The Hidden Language of Applications</h4><p>Think of APIs as the hidden language that applications use to talk to each other. You don’t see it, but it’s happening every time you log in with Google, check your bank balance on a mobile app, or refresh the weather forecast. Behind the scenes, <strong>APIs</strong> are quietly carrying requests and responses, making sure systems exchange the right information at the right time. The easiest way to picture it is through a restaurant analogy. You don’t walk into the kitchen to cook your own food. Instead, you tell the waiter what you want, the waiter delivers your request to the chef, and then brings the dish back to you. That waiter is the API a messenger that connects you (the client) with the kitchen (the server).</p><p>But APIs are more than just messengers. They are doors into the system:</p><p>For a <strong>pentester</strong>, APIs are entry points to probe. can you take more data than allowed or reach something hidden?</p><p>For a <strong>threat hunter</strong>, APIs are trails of activity to monitor. can you see when someone is asking for too much, too quickly, or for things they shouldn’t access?</p><p>This is why <strong>API</strong>s are called the hidden language of applications. They make modern apps possible, but they also expand the attack surface. Every API call is a potential doorway and not all doors are locked properly.</p><h4>The Different Doors of APIs:</h4><ol><li><strong>REST (Representational State Transfer)</strong></li></ol><p>REST (Representational State Transfer) is the most widely used style of API communication. It relies on simple HTTP methods like GET, POST, PUT, DELETE to interact with resources identified by URLs. Each request is stateless, meaning the server doesn’t remember past interactions, and responses are usually delivered in formats like JSON or XML. This simplicity and consistency make REST the backbone of modern web and mobile applications.</p><p><strong>Pentester’s view</strong>: REST endpoints are tested for broken access controls and IDORs: can you modify a resource identifier (like a user ID in the URL) to access another user’s data without proper authorization?</p><p><strong>Threat hunter’s view</strong>: REST activity is monitored for anomalies: repeated sequential requests, high call volumes, or access to sensitive endpoints can indicate enumeration or abuse.</p><p>2. <strong>SOAP (Simple Object Access Protocol):</strong></p><p>SOAP uses <a href="https://developer.mozilla.org/en-US/docs/Web/XML/Guides/XML_introduction">XML</a> based messaging to exchange information between systems. Each request and response is wrapped in a strict envelope format, often with built-in standards for security, authentication, and error handling. Because of its rigid structure, SOAP is common in enterprise applications and systems that require strong reliability and formal contracts.</p><p><strong>Pentester’s view: </strong>SOAP endpoints are tested for XML weaknesses: can you inject or manipulate the structured message to bypass rules or access restricted data?</p><p><strong>Threat hunter’s view: </strong>SOAP traffic is monitored for anomalies: oversized, malformed, or unusual XML requests may indicate exploitation attempts or abuse.</p><p>3. <strong>GraphQL:</strong></p><p>GraphQL is an API query language that lets clients ask for exactly the data they need through a single endpoint. It reduces extra or missing data compared to REST, but poorly controlled queries can expose risks.</p><p><strong>Pentester’s view: </strong>GraphQL endpoints are tested for query abuse: can you craft overly broad or deep queries to pull sensitive or hidden data?</p><p><strong>Threat hunter’s view: </strong>GraphQL traffic is monitored for anomalies: unusually complex queries, excessive nesting, or large data requests may signal enumeration or exploitation attempts</p><p>4. <strong>gRPC (Google Remote Procedure Call):</strong></p><p>gRPC is a high performance, open‑source framework that uses <a href="https://www.geeksforgeeks.org/computer-networks/what-is-http-2/"><strong>HTTP/2</strong></a> and <a href="https://protobuf.dev/"><strong>Protocol Buffers (Protobuf)</strong></a> to enable fast, efficient communication between services. Unlike REST or SOAP, gRPC supports <a href="https://docs.cloud.google.com/apigee/docs/api-platform/develop/enabling-streaming"><strong>streaming requests and responses</strong></a>, making it ideal for microservices and real‑time systems. Its binary format improves speed and bandwidth usage but also makes traffic harder to inspect and secure.</p><p><strong>Pentester’s view: </strong>gRPC endpoints are tested for weak authentication and crafted Protobuf messages: can you send or manipulate binary requests to access functions or data you shouldn’t?</p><p><strong>Threat hunter’s view: </strong>gRPC traffic is monitored for anomalies: unusual message sequences, abnormal stream patterns, or unexpected binary payloads may indicate misuse or exploitation attempts.</p><p>5. <strong>WebSockets:</strong></p><p>It provide a persistent, <a href="https://www.techtarget.com/searchnetworking/definition/full-duplex">full‑duplex communication channel</a> between client and server over a single TCP connection. Unlike REST or SOAP, which require a new request for each interaction, WebSockets keep the connection open, enabling real‑time, bidirectional data exchange. This makes them ideal for chat apps, live dashboards, and streaming services, but the always on nature also introduces monitoring and security challenges.</p><p><strong>Pentester’s view: </strong>WebSocket endpoints are tested for injection and misuse: can you hijack the connection, flood it with messages, or send unauthorized data through the open channel?</p><p><strong>Threat hunter’s view: </strong>WebSocket traffic is monitored for anomalies: excessive message volume, unusual timing, or suspicious payloads can reveal abuse or compromise.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/929/1*Sun3mm634Z95TYW2MZ1tug.png" /></figure><h4>Closing Thoughts:</h4><p>APIs are more than just technical interfaces they are the doors through which modern applications live and breathe. For the <strong>pentester,</strong> each door is a lock to test, a boundary to push, and a chance to uncover hidden paths. For the <strong>threat hunter</strong>, each door is a trail to follow, a footprint to analyze, and a signal to catch before damage is done.</p><blockquote>Together, these perspectives remind us that <strong>security is not just about building strong doors, but also about watching who walks through them and how</strong>. The attacker’s creativity and the defender’s vigilance form two sides of the same coin one probing for weakness, the other scanning for trails.</blockquote><p><strong>“APIs are the hidden doors of the web secure them well, or someone else will walk through.”</strong></p><p>If you want to move beyond theory into real practical stuff, just drop a comment we’ll take this journey together and explore hands‑on examples.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aa7f83d63765" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>