<?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 Andrei on Medium]]></title>
        <description><![CDATA[Stories by Andrei on Medium]]></description>
        <link>https://medium.com/@g8dlr1dx?source=rss-361629b35e7a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by Andrei on Medium</title>
            <link>https://medium.com/@g8dlr1dx?source=rss-361629b35e7a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 13:20:02 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@g8dlr1dx/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[Mitigating CSRF: How to Stop the Browser from Betraying the User]]></title>
            <link>https://medium.com/@g8dlr1dx/mitigating-csrf-how-to-stop-the-browser-from-betraying-the-user-44909cc2aaa2?source=rss-361629b35e7a------2</link>
            <guid isPermaLink="false">https://medium.com/p/44909cc2aaa2</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[csrf]]></category>
            <category><![CDATA[csrf-attack]]></category>
            <dc:creator><![CDATA[Andrei]]></dc:creator>
            <pubDate>Sat, 25 Jul 2026 15:45:04 GMT</pubDate>
            <atom:updated>2026-07-25T15:45:04.087Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hvmSx_13zbrkaX-S_5We8Q.png" /></figure><p>A user signs in to an administrative dashboard, opens another tab, and visits a seemingly harmless page. Hidden inside it is a form that submits a request to the dashboard: change an email address, add a payment destination, disable multi-factor authentication, or delete a project. The browser automatically attaches the user’s session cookie. The vulnerable application sees a valid session and performs the action.</p><p>The attacker never learned the password or stole the cookie. They persuaded the browser to use an authenticated session for the wrong purpose.</p><p>That is <strong>Cross-Site Request Forgery</strong>, or <strong>CSRF</strong>: an attack in which a hostile site causes a browser to send an unwanted request to an application where the user is already authenticated. The target trusts the session but has not verified the user’s intent. Without specific defenses, it cannot distinguish a legitimate authenticated request from a forged one.</p><p>CSRF exploits “ambient authority”: browsers automatically attach eligible cookies to matching requests. Authentication establishes <strong>who the browser is acting as</strong>, not <strong>who initiated this action</strong>. The server needs another signal proving that the request came from its trusted interface.</p><h3>How a CSRF Attack Works</h3><p>A conventional CSRF attack usually needs three conditions:</p><ol><li>The target exposes a state-changing action, such as updating a profile, transferring funds, or changing permissions.</li><li>The browser sends authentication automatically, commonly through a session cookie.</li><li>The request is predictable, and the server requires no secret, request-specific proof.</li></ol><p>Consider an application that accepts:</p><pre>POST /account/email HTTP/1.1<br>Host: app.example<br>Content-Type: application/x-www-form-urlencoded<br>Cookie: session=VALID_USER_SESSION</pre><pre>email=attacker@example.net</pre><p>An attacker can place an auto-submitting form on another site:</p><pre>&lt;form action=&quot;https://app.example/account/email&quot; method=&quot;post&quot;&gt;<br>  &lt;input type=&quot;hidden&quot; name=&quot;email&quot; value=&quot;attacker@example.net&quot;&gt;<br>&lt;/form&gt;<br>&lt;script&gt;document.forms[0].submit();&lt;/script&gt;</pre><p>When an authenticated user visits the attacker’s page, the browser may send the form and attach eligible cookies. The same-origin policy normally prevents the malicious page from reading the response, but cross-origin form submissions have existed since the early web. Preventing a hostile site from <strong>reading</strong> data is not the same as preventing it from <strong>sending</strong>a state-changing request.</p><p>This is why CORS is not automatically a CSRF defense. CORS governs whether JavaScript can access cross-origin responses and whether certain requests pass a preflight. Traditional HTML forms can still send “simple” requests, while an overly broad credentialed CORS policy can increase exposure.</p><h3>From “Session Riding” to a Standard Threat Model</h3><p>CSRF predates modern single-page applications. The issue was discussed under the CSRF name by 2001 and later became known as <strong>session riding</strong>, <strong>one-click attack</strong>, and <strong>XSRF</strong>. A 2004 paper described session riding as a widespread web application weakness.</p><p>Early applications were especially vulnerable. Many treated any request carrying a valid cookie as authorized, changed data through GET endpoints, and exposed predictable action URLs. An image, iframe, link, or hidden form could trigger a sensitive operation.</p><p>Defenses matured in layers: frameworks added anti-forgery middleware, applications adopted cryptographically unpredictable tokens, browsers introduced SameSite cookies, and servers gained signals such as Fetch Metadata. CSRF did not disappear; the security model became stronger.</p><h3>The Impact of CSRF</h3><p>The impact depends on the victim’s privileges and the operations exposed.</p><p>For an ordinary user, CSRF can modify contact details, create transactions, enroll an attacker-controlled authenticator, publish content, or redirect notifications. It may also disclose data indirectly by adding a webhook or changing where later information is sent.</p><p>For an administrator, the same flaw can become application-wide: a forged request might create a privileged account, alter access rules, approve a payment, rotate secrets, or disable a security feature. OWASP notes that CSRF can compromise both user data and application operations, with greater consequences for privileged victims.</p><p>The attacker may not read the response, but CSRF still attacks integrity by changing what a trusted system stores or does.</p><h3>Start with Correct Request Semantics</h3><p><strong>Never use </strong><strong>GET for state-changing operations.</strong> Safe methods should retrieve information without meaningful side effects. Links, crawlers, image loads, prefetchers, and browser navigation can trigger GET requests. Moving an operation to POST, PUT, PATCH, or DELETE does not stop CSRF by itself, but it removes trivial attack paths and enables stronger validation.</p><p>Inventory every state-changing endpoint, including login, logout, OAuth linking, API-key creation, invitations, and administrative actions. Apply protection centrally through framework middleware. One excluded route can compromise the application.</p><h3>Anti-CSRF Tokens: The Primary Control</h3><p>The standard application-level defense is an <strong>anti-CSRF token</strong>: an unpredictable value that the attacker cannot obtain and that the server requires on state-changing requests.</p><p>In the <strong>synchronizer token pattern</strong>, the server generates a cryptographically strong value, associates it with the user’s session, and embeds it in a trusted page. Forms return it in a hidden field; JavaScript clients commonly send it in a custom header such as X-CSRF-Token. The server validates it before processing the action.</p><p>A secure token should be unpredictable, session-bound, checked on every protected request, and sent in the request body or a custom header — not in a URL where logs, browser history, analytics, or referrer data may expose it.</p><p>Per-request tokens reduce replay opportunities but complicate navigation and parallel requests. Per-session tokens are simpler and effective when implemented correctly. Validation must fail closed: missing, expired, or mismatched tokens should be rejected.</p><p>Stateless systems can use a <strong>signed double-submit cookie</strong>. The server issues related cookie and request values, then verifies a cryptographic signature tied to session-specific data. Avoid a naive unsigned comparison; cookie injection or subdomain control may undermine it. OWASP recommends signing and session-binding the value.</p><p>Prefer the framework’s maintained CSRF implementation. Mature frameworks already handle secure generation, comparison, form helpers, rotation, and edge cases.</p><h3>Validate the Request Origin</h3><p>For HTTPS applications, validate the browser-supplied Origin header on state-changing requests against an explicit allowlist. Where Origin is absent, a carefully checked Referer header can be a fallback.</p><p>Compare the complete origin — scheme, host, and port — not a substring. https://app.example.attacker.net is not a trusted variation of <a href="https://app.example./">https://app.example.</a></p><p>Use origin validation as defense in depth. Some legitimate clients omit these headers, so define and monitor a policy for missing values.</p><h3>Harden Session Cookies</h3><p>The SameSite attribute controls when browsers attach a cookie to cross-site requests:</p><ul><li>SameSite=Strict is strongest but can disrupt legitimate journeys from external sites.</li><li>SameSite=Lax balances security and usability for many applications.</li><li>SameSite=None permits cross-site use and must be paired with Secure.</li></ul><p>A useful first-party baseline is:</p><pre>Set-Cookie: __Host-session=...; Path=/; Secure; HttpOnly; SameSite=Lax</pre><p>Secure restricts transmission to HTTPS, HttpOnly blocks normal JavaScript access, and the __Host- prefix imposes stricter host and path requirements in supporting browsers.</p><p>Do not treat SameSite as a substitute for tokens. “Site” is not identical to “origin,” sibling subdomains can matter, and some integrations require SameSite=None. MDN and current cookie specifications recommend SameSite as defense in depth rather than the entire CSRF strategy.</p><h3>Reject Suspicious Contexts with Fetch Metadata</h3><p>Modern browsers send headers such as Sec-Fetch-Site, Sec-Fetch-Mode, and Sec-Fetch-Dest, describing whether a request is same-origin, same-site, cross-site, a navigation, or a subresource.</p><p>A server can reject Sec-Fetch-Site: cross-site requests to sensitive mutation endpoints unless the endpoint intentionally supports that flow. Fetch Metadata gives the server context about where a request originated and how the resource will be used.</p><p>Deploy gradually: log first, identify legitimate clients, then enforce with explicit exceptions.</p><h3>Strengthen APIs with Custom Headers and Strict CORS</h3><p>JSON APIs can refuse form-compatible content types and require a custom header. A hostile HTML form cannot set arbitrary headers, while JavaScript requests that set them usually require a successful CORS preflight.</p><p>This works only with strict CORS. Do not reflect arbitrary origins, combine credentials with broad access, or trust every subdomain without considering takeover risk. Validate Content-Type and reject unexpected encodings.</p><p>Cookie-authenticated APIs remain CSRF targets because browsers send the credential automatically. Explicit bearer-token clients have a different threat model, although XSS and CORS errors remain serious.</p><h3>Require Fresh Intent for Critical Actions</h3><p>For high-impact operations, require more than a session and CSRF token. Reauthentication, a current password, WebAuthn confirmation, a one-time code, or a transaction-specific approval screen can establish fresh user intent.</p><p>Use step-up controls for changing recovery information, disabling multifactor authentication, adding payment recipients, or granting administrative roles. Show exact transaction details; a generic confirmation dialog provides limited protection.</p><h3>XSS Can Defeat CSRF Defenses</h3><p>Anti-CSRF tokens assume the attacker cannot execute code in the trusted origin. A cross-site scripting flaw can often read tokens or issue same-origin requests directly. OWASP therefore warns that XSS can defeat CSRF mitigations. CSRF protection must sit alongside output encoding, safe DOM handling, Content Security Policy, and dependency security.</p><h3>A Practical Review Checklist</h3><p>During a CSRF review, verify that:</p><ul><li>every state-changing endpoint uses an appropriate method;</li><li>framework CSRF protection is enabled globally;</li><li>tokens are random, session-bound, non-URL values, and checked server-side;</li><li>cookies use Secure, HttpOnly, and an appropriate SameSite policy;</li><li>sensitive routes validate origin and unexpected Fetch Metadata contexts;</li><li>credentialed CORS allowlists are exact and minimal;</li><li>high-risk actions require fresh confirmation or reauthentication;</li><li>tests confirm that missing and invalid tokens are rejected.</li></ul><p>Do not stop at code inspection. Capture a valid request, remove or replace the token, replay it from another session, change the content type, and test delivery from another origin. OWASP’s testing guidance asks whether the application can distinguish an intentional request from one forced through the user’s browser.</p><h3>Make the Browser Prove Intent</h3><p>CSRF exploits the gap between authentication and authorization. A valid session proves that the browser holds a credential. It does not prove that the user intended the current operation.</p><p>Close that gap with layered controls. Begin with framework-supported anti-CSRF tokens on every state-changing request. Reinforce them with correct HTTP semantics, exact origin validation, hardened cookies, Fetch Metadata, strict CORS, and fresh confirmation for critical actions. Then test the controls from another origin using a real authenticated session.</p><p>Review old routes and overlooked workflows now. CSRF defenses are inexpensive compared with the cost of unauthorized actions through trusted accounts. Security requires continued attention as browsers, architectures, and attacks evolve.</p><p>In the next article in this series, we will move from request integrity to operational resilience: <strong>why regular updates and disciplined patch management are essential to a holistic cybersecurity program</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=44909cc2aaa2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Prevent Injection: Keep Data Separate from Commands]]></title>
            <link>https://medium.com/@g8dlr1dx/prevent-injection-keep-data-separate-from-commands-ed673f43611a?source=rss-361629b35e7a------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed673f43611a</guid>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Andrei]]></dc:creator>
            <pubDate>Sat, 25 Jul 2026 15:35:51 GMT</pubDate>
            <atom:updated>2026-07-25T15:35:51.533Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NLKaSGbsMMzyjF8C37ww-w.png" /></figure><p>Injection attacks are among the most damaging application-security failures because they exploit a basic boundary error: a system treats attacker-controlled data as part of a command, query, expression, or instruction. A search term becomes SQL syntax. A filename becomes a shell command. A profile field becomes template code. Once that boundary collapses, an attacker may bypass authentication, expose or alter restricted data, execute commands, or compromise a server.</p><p>The problem extends beyond relational databases. Injection can occur wherever software passes data to an interpreter, including SQL and NoSQL databases, directory services, operating-system shells, template engines, XML processors, spreadsheets, logging systems, and AI agents. OWASP’s current Top 10 places Injection at A05:2025 and identifies the central defense: keep data separate from commands and queries. MITRE’s 2025 CWE Top 25 also includes OS command injection and code injection among the most dangerous software weaknesses.</p><h3>How Injection Attacks Work</h3><p>Most injection flaws follow the same pattern:</p><ol><li>An application receives data from an untrusted or insufficiently trusted source.</li><li>It combines that data with executable syntax.</li><li>An interpreter processes the resulting query, command, or expression.</li><li>The interpreter cannot distinguish intended instructions from hostile input.</li></ol><p>Input may arrive through forms, APIs, headers, uploads, queues, stored records, or internal tools. Data that is harmless in one component may become dangerous when another interprets it, so client-side checks are never sufficient.</p><h3>Major Types of Injection Attacks</h3><h3>SQL Injection</h3><p>SQL injection occurs when input changes the structure or meaning of a relational-database query. Common exposure points include login forms, search filters, reporting tools, account portals, and administrative dashboards.</p><p>A login endpoint that concatenates credentials into SQL may allow crafted input to change the query’s logic. A search filter might expose another customer’s records, while an injectable reporting endpoint could permit unauthorized reading or modification.</p><p>Consequences include authentication bypass, sensitive-data disclosure, and record corruption. Impact often depends on the database account’s permissions.</p><h3>NoSQL Injection</h3><p>NoSQL databases use different query models, but they are not immune. Vulnerabilities arise when user-controlled objects, operators, or expressions enter document, key-value, graph, or search queries.</p><p>A JSON API may expect an email address as a string but accept a structured object. Without schema enforcement, that object could introduce a comparison operator and broaden the match. A search service that accepts raw filter syntax may expose records beyond the user’s authorization scope.</p><p>NoSQL injection often involves unsafe parsing rather than concatenation. Applications must validate values and types, reject unexpected operators, and use safe driver APIs. Payloads may be evaluated in the application or database layer.</p><h3>OS Command Injection</h3><p>OS command injection appears when an application incorporates untrusted data into a command executed by a shell or operating-system process. Risk areas include file conversion, image processing, backup tools, network diagnostics, document generation, and deployment automation.</p><p>A support tool might run a network utility using a user-supplied hostname. If it builds a shell string, crafted input may append another command. A media service that sends an unsafe filename to a command-line converter creates a similar risk.</p><p>Because the attack crosses into the host operating system, it may expose secrets, alter files, or enable lateral movement. Avoid the shell when a library or narrowly scoped API can perform the task; OWASP recommends built-in functions over direct OS commands.</p><h3>LDAP and XPath Injection</h3><p>LDAP injection targets directory queries used by login, identity, and access-control systems. Raw input inserted into a filter may alter a match or select an unintended account. XPath injection applies the same concept to XML queries, where manipulated input can change node selection or bypass a condition. The root cause remains the same: untrusted values become interpreter syntax.</p><h3>Template, Expression, and Code Injection</h3><p>Applications use templates to generate web pages, emails, documents, and configuration files. Server-side template injection occurs when user input is evaluated as template source instead of rendered as ordinary content.</p><p>If a marketing preview or document generator evaluates submitted text as a template, an attacker may access server-side objects or invoke template functions. Depending on the engine and sandbox, impact ranges from information disclosure to remote code execution.</p><p>Expression languages, eval, scripting hooks, and loosely constrained rules engines create the same risk by converting data into executable behavior.</p><h3>Header, Log, and CSV Injection</h3><p>Injection also appears downstream. Untrusted values can corrupt HTTP or email headers, forge log lines, or become spreadsheet formulas in CSV exports. Safety is context-specific: a value harmless in a database may be dangerous in a shell command, header, log, HTML document, or spreadsheet cell.</p><h3>Prompt Injection in AI Systems</h3><p>LLM prompt injection has a distinct cause: AI applications often process instructions and data in the same natural-language channel. A malicious document, web page, email, or message may tell a model to ignore policy, disclose information, or misuse connected tools.</p><p>Risk increases when an agent can access private data or perform actions. Because natural language has no reliable syntax boundary, mitigation requires restricted tool permissions, isolated context, validated outputs, and confirmation for consequential actions.</p><h3>Preventing Injection Attacks</h3><h3>Separate Data from Executable Structure</h3><p>The strongest defense is to use interfaces that preserve the distinction between code and data.</p><p>For SQL, use prepared statements and parameterized queries. Bind values through the database driver instead of assembling query strings. Apply the same principle to NoSQL drivers, LDAP libraries, and structured query builders: define the query structure in code, then supply validated values through supported APIs.</p><p>Structural elements such as table names, sort directions, and operators should come from strict allowlists. Stored procedures are safe only when they avoid dynamic query construction.</p><h3>Avoid Unnecessary Interpreters</h3><p>Every interpreter expands the attack surface. Prefer a filesystem API over a shell command, a native library over a command-line pipeline, a structured serializer over hand-built XML, and a fixed template over runtime evaluation.</p><p>Remove dynamic execution where possible. If scripting is required, use a constrained language and sandbox it with strict resource and access limits. Avoiding direct interpreter access is generally stronger than attempting to sanitize every possible payload.</p><h3>Validate Input Positively</h3><p>Define what is allowed rather than trying to recognize every malicious payload. Check type, length, format, range, character set, and permitted values. Reject objects where a scalar is expected, and normalize input before validation.</p><p>Use allowlists for fields such as sort order, file type, and operation name. Validation is defense in depth, not a replacement for parameterization.</p><h3>Encode for the Exact Destination</h3><p>When parameterization is unavailable, use a maintained escaping or encoding function designed for the target context. LDAP filters and distinguished names require different rules. HTML text, attributes, JavaScript strings, URLs, shell arguments, headers, logs, and spreadsheet cells also require distinct handling.</p><p>A generic “sanitize” function is not enough. Escaping should remain secondary to safe APIs and constrained input.</p><h3>Limit Privileges and Contain Failure</h3><p>Assume a control may fail. Database accounts, application processes, containers, and service identities should have only the permissions and access they require. Least privilege can prevent one injectable endpoint from becoming a full-system compromise.</p><p>A public application may need permission to read and update customer records, for example, but it should not be able to create database administrators or access unrelated datasets. A document-conversion service should not have unrestricted network access or broad access to application secrets.</p><h3>Make Secure Framework Features the Default</h3><p>Modern frameworks provide prepared queries, ORM binding, schema validation, template auto-escaping, and safer process-execution APIs. These protections fail when developers bypass them through raw queries, unsafe rendering, string-built filters, or shell-enabled calls.</p><p>Create secure wrappers, deprecate dangerous APIs, enable security linters, and require review for exceptions. Make the safe implementation the easiest one.</p><p>Teams should also document approved query, templating, process-execution, and serialization patterns. This reduces inconsistency and prevents each developer from inventing a separate security solution.</p><h3>Test Throughout Development</h3><p>Use several testing methods because no single tool sees every data flow:</p><ul><li><strong>Static application security testing:</strong> SAST can identify unsafe string construction near query, command, and evaluation sinks.</li><li><strong>Dynamic application security testing:</strong> DAST can probe running applications for observable injection behavior.</li><li><strong>Unit and integration testing:</strong> Tests should cover malformed types, control characters, boundary values, and interpreter metacharacters.</li><li><strong>Manual review and threat modeling:</strong> Review database execution, process creation, template compilation, directory queries, dynamic evaluation, exports, automation, and AI tool use.</li></ul><p>Scanners may still miss custom query builders, stored injection, and business-specific interpreters. Security reviews should therefore trace data from its original trust boundary to every location where it may be interpreted.</p><h3>Monitor, but Do Not Depend on a WAF</h3><p>Log rejected input, query failures, unusual operators, repeated syntax errors, unexpected process launches, and anomalous data access. Use structured logging so attacker-controlled values remain fields rather than preformatted lines.</p><p>A web application firewall can block known patterns and provide telemetry, but it is not the primary fix. Secure code removes the cause; filtering adds another layer.</p><p>Blocking individual attack strings is inherently fragile. Attackers can change encoding, syntax, data types, or delivery paths. A WAF may reduce exposure while a vulnerability is being remediated, but it should not become a permanent substitute for parameterization, validation, and safe architecture.</p><h3>Engineering Checklist</h3><p>Before releasing a feature that processes external data, confirm that:</p><ul><li>Queries use parameterized APIs rather than concatenated strings.</li><li>Dynamic identifiers and operations come from allowlists.</li><li>Shell invocation is eliminated or avoids a command interpreter.</li><li>Templates render user content as data, not template source.</li><li>Schemas reject unexpected types, fields, and operators.</li><li>Output is encoded for its precise destination.</li><li>Database, service, and operating-system privileges are minimal.</li><li>Tests cover direct, stored, and second-order injection paths.</li><li>Logs can reveal attacks without becoming injectable.</li><li>AI tools have scoped permissions and reviewable actions.</li></ul><p>Injection defenses should also be included in code-review checklists, development standards, automated pipelines, and architecture reviews. Preventing injection is considerably easier when secure boundaries are designed into a system rather than added after deployment.</p><h3>Conclusion</h3><p>Injection is not a single SQL-related bug. It is a family of boundary failures in which untrusted content enters a control plane: database syntax, operating-system commands, directory filters, templates, expressions, document formulas, or AI instructions. The technologies differ, but the engineering lesson is consistent.</p><p>Robust prevention starts by removing unnecessary interpreters and structurally separating commands from data. Parameterized APIs, strict schemas, allowlisted operations, context-specific encoding, least privilege, secure framework defaults, testing, and monitoring provide layered protection. Filtering tools may reduce exposure, but they cannot compensate for unsafe construction at the source.</p><p>Addressing injection early protects more than individual records. It preserves the integrity of authentication, transactions, automation, infrastructure, and the trust users place in systems that manage sensitive data.</p><p>In the next article, we will take a deep dive into <strong>Cross-Site Request Forgery (CSRF)</strong> — how attackers exploit a browser’s authenticated state to trigger unwanted actions, and how anti-CSRF tokens, SameSite cookies, origin validation, and secure interaction design prevent forged requests.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed673f43611a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>