Web Security for Full-Stack Developers — XSS, CSRF and CORS

Prevent cross-site scripting, cross-site request forgery and injection, configure CORS and security headers, and handle secrets safely.

Est. 40 min Updated Suggest a fix
// Part 01 — Think in trust boundaries

Security Is About Who Can Trust Which Data

A full-stack app moves information through a browser, a server, and a database. Each boundary changes what the application can safely assume. A browser can be modified by its user, an HTTP request can be constructed without your interface, and data already stored may contain old or unexpected values. Treat external input as untrusted until the server has validated it and checked that the caller may perform the requested action.

We will use a study planner to discuss common web risks: cross-site scripting (XSS), cross-site request forgery (CSRF), injection, unsafe cross-origin access, exposed secrets, and missing authorization. The goal is not to memorise acronyms; it is to identify where data came from, what it can influence, and which control belongs at that boundary.

RiskBoundary to examineDefensive habit
XSSUntrusted text rendered as HTML or script-capable contentUse safe text rendering and sanitise only when rich HTML is a product requirement.
CSRFA browser sends an authenticated state-changing requestUse appropriate cookie settings and a deliberate CSRF defence.
InjectionInput is composed into a query or commandUse parameterized interfaces and constrained input.
Authorization failureA signed-in user requests another user’s recordCheck ownership and permissions on every server operation.
Secret exposurePrivate credentials cross into browser-delivered codeKeep secrets in server configuration and restrict their access.
💡 Note
Authentication answers "who is making this request?" Authorization answers "may this identity do this action to this resource?" A secure route generally needs both.
// Part 02 — Cross-site scripting

Render User Content as Text, Not Executable Markup

React renders ordinary string values as text, which avoids treating that string as HTML. Risk increases when an app asks the browser to interpret untrusted content as markup, embeds data in an unsafe context, or uses an unsafe library. Avoid dangerouslySetInnerHTML for user content. If rich text is essential, use a well-maintained HTML sanitizer with an explicit allowlist and review its behavior for the exact output context.

Encoding is context-specific. A value safe as visible text is not automatically safe inside a URL, a script block, CSS, or an HTML attribute. Prefer framework APIs that preserve the intended context, validate URL schemes when accepting links, and avoid constructing executable code from user input.

components/SessionNote.tsx
tsx
type SessionNoteProps = { author: string; note: string; profileUrl: string }

export function SessionNote({ author, note, profileUrl }: SessionNoteProps) {
  const safeProfileUrl = profileUrl.startsWith("/students/") ? profileUrl : "/students"

  return (
    <article>
      <a href={safeProfileUrl}>{author}</a>
      <p>{note}</p>
    </article>
  )
}

The note is rendered as text rather than injected markup. The URL check is intentionally narrow; a real application should parse and validate destinations according to its routing and link policy, not assume a string prefix is a universal URL security check.

⚠️ Important
Do not remove framework escaping to make user content "render correctly". If the product requires formatted text, define the allowed markup and sanitise it before rendering.
// Part 03 — Injection

Keep Data Separate from Query Structure

SQL injection occurs when untrusted input is combined with query syntax. Parameterized queries preserve the distinction between the query and its values. An ORM usually provides parameterized operations for ordinary queries, but raw-query escape hatches still need careful review. The same principle applies to shell commands, template engines, and other interpreters: do not build executable syntax by concatenating input.

server/sessions.ts
typescript
type SessionRow = { id: string; title: string; studentId: string }

type Query = {
  query<T>(sql: string, values: readonly unknown[]): Promise<{ rows: T[] }>
}

export async function findSessionsForStudent(db: Query, studentId: string): Promise<SessionRow[]> {
  const result = await db.query<SessionRow>(
    "SELECT id, title, student_id AS \"studentId\" FROM study_sessions WHERE student_id = $1",
    [studentId],
  )
  return result.rows
}

The placeholder syntax depends on the database driver; follow that driver's parameter API rather than copying the marker from an unrelated library. This example also scopes the query by a server-provided student identity. A safely parameterized query can still disclose data if the authorization condition is missing.

🎯 Pro Tip
Validation and parameterization solve different problems. Validation checks whether a value is acceptable; parameterization prevents that value from becoming query syntax.
// Part 04 — Request forgery

Protect Cookie-Authenticated State Changes

Browsers automatically attach matching cookies to requests. CSRF takes advantage of that behavior to make a signed-in browser send an unwanted state-changing request. Use secure session-cookie attributes such as HttpOnly, Secure on HTTPS, and an appropriate SameSite policy. These attributes are useful controls, but cookie policy alone is not a complete CSRF design for every application and deployment.

For cookie-authenticated mutations, follow the framework's CSRF protections or implement a well-reviewed token strategy, verify the expected origin where appropriate, and avoid state changes through GET. CORS is not a CSRF defence: it controls whether browser scripts can read certain cross-origin responses, not whether every cross-site request can be sent.

  1. Identify which endpoints accept browser credentials automatically.
  2. Keep read-only requests free of side effects and use explicit mutation methods.
  3. Use secure cookie attributes and the framework’s recommended CSRF mechanism.
  4. Check origin or referer signals as an additional defence when appropriate to the deployment.
  5. Test the actual browser and proxy setup; security depends on the whole request path.
📌 Real World Example
A student clicking a malicious link should not silently change the email address on their account. Require a deliberate authenticated mutation protected by the application’s CSRF strategy.
// Part 05 — Cross-origin access

Configure CORS for Known Browser Clients

Cross-Origin Resource Sharing (CORS) is a browser mechanism that governs whether JavaScript from one origin may access a response from another origin. It is not authentication, authorization, a firewall, or a general block on all cross-site requests. A server should authorize each request independently of its CORS headers.

When an API needs credentialed browser access, list the specific trusted origins and methods that are actually needed. Do not combine credentialed access with a wildcard origin. Keep development and production origin configuration separate, and remember that non-browser clients are not constrained by browser CORS enforcement.

server/cors.ts
typescript
const allowedOrigins = new Set([
  "https://app.example.com",
  "https://preview.example.com",
])

type CorsDecision = { allowOrigin?: string; allowCredentials: boolean }

export function corsDecision(requestOrigin: string | null): CorsDecision {
  if (!requestOrigin || !allowedOrigins.has(requestOrigin)) {
    return { allowCredentials: false }
  }

  return { allowOrigin: requestOrigin, allowCredentials: true }
}

export function applyCorsHeaders(headers: Headers, decision: CorsDecision) {
  if (decision.allowOrigin) {
    headers.set("Access-Control-Allow-Origin", decision.allowOrigin)
    headers.set("Access-Control-Allow-Credentials", "true")
    headers.append("Vary", "Origin")
  }
  return headers
}

This small helper illustrates origin allow-listing; a real server must also answer preflight requests with the required methods and headers and must use its framework's response lifecycle correctly. The example origins are placeholders, not configuration values to copy into a real deployment.

// Part 06 — Headers and secrets

Reduce Exposure with Safe Defaults

Security headers can reduce the impact of some mistakes. A Content Security Policy (CSP) can restrict resource sources and script execution; other headers can prevent content-type guessing or control framing. Start from the framework's current documentation and the resources your application actually needs. An overly broad policy gives little protection, while a policy copied blindly can break the product.

Secrets such as database credentials, signing keys, and third-party API tokens belong in server-side environment configuration or a managed secret store. A variable exposed with a public-client prefix, a value imported into a client component, or a key included in a browser bundle is no longer secret. Restrict permissions, rotate credentials after suspected exposure, and avoid logging them.

next.config.ts
typescript
import type { NextConfig } from "next"

const nextConfig: NextConfig = {
  async headers() {
    return [
      {
        source: "/:path*",
        headers: [
          { key: "X-Content-Type-Options", value: "nosniff" },
          { key: "Referrer-Policy", value: "strict-origin-when-cross-origin" },
          { key: "X-Frame-Options", value: "DENY" },
        ],
      },
    ]
  },
}

export default nextConfig

These headers are an illustrative baseline, not a complete security policy. Choose framing behavior based on whether your app must be embedded, and configure CSP using the framework guidance for your rendering and inline-script needs. Avoid inventing a one-size-fits-all policy.

⚠️ Important
Never commit a real key to the repository, even in a private project. If a credential is exposed, revoke or rotate it and investigate logs and access rather than merely deleting the visible line.
// Part 07 — Authorization and review

Check the Caller for Every Resource Operation

Requiring a signed-in user does not prove that the user owns the requested record. Every read, update, and delete must establish the relationship between the authenticated identity and the resource. Apply ownership filters in the database query where practical, and return a response that does not reveal another user's private record.

Security review is a repeating engineering activity. Review dependencies and configuration, keep sensitive operations observable without recording secrets, and test that invalid or unauthorized requests fail closed. Consider abuse limits for expensive or sensitive endpoints and ensure errors reveal enough for the legitimate user without exposing stack traces or credentials.

CheckQuestionExample for a planner
AuthenticationIs the caller identity verified?Does the request have a valid session?
AuthorizationCan this identity access this record?Does the session belong to this student?
ValidationIs the submitted shape acceptable?Does the title satisfy the schema?
Data integrityWill stored relationships remain valid?Does the referenced subject exist?
Abuse controlsCan an endpoint be used excessively?Is expensive report generation bounded?
// Part 08 — Common pitfalls

Avoid Security Theater

Assuming CORS authenticates API callers

Why: CORS is a browser response-access policy, not an identity check.

Fix: Authenticate and authorize every API request on the server.

Trusting a hidden field or route ID as ownership proof

Why: A caller can change any value sent by the browser.

Fix: Derive identity from the server session and check resource ownership.

Putting a secret in a public environment variable

Why: Public client configuration is shipped to the browser.

Fix: Keep credentials in server-only configuration and inspect built output when unsure.

Concatenating user input into SQL or HTML

Why: Input can be interpreted as executable syntax.

Fix: Use parameterized queries and safe text rendering; sanitise only necessary rich content.

// Part 09 — Practice

Review a Study Planner's Security Boundaries

Practice

Harden a session update route and document its trust boundaries

  1. Trace a session note from request body to storage and back to the page; identify every point where it is interpreted.
  2. Replace any raw SQL string composition with the database driver’s parameter interface.
  3. Require an authenticated identity and make an update query match both the session ID and its owner ID.
  4. List the exact trusted origins needed by the browser app and explain why CORS does not replace authorization or CSRF protection.
  5. Move a test credential out of source, configure safe response headers, and write down a rotation step for accidental exposure.

Hint: Use harmless local test data. The goal is to verify defensive behavior and authorization boundaries, not to attack a real system.

🎯 Key Takeaways

  • ✓Treat browser input and stored user content as untrusted at every server boundary.
  • ✓Render text safely, parameterize database values, and validate inputs for the domain.
  • ✓Authentication identifies a caller; authorization must check access to each resource.
  • ✓Protect cookie-authenticated mutations with an appropriate CSRF strategy; CORS is not that strategy.
  • ✓Allow-list required browser origins and keep server authorization independent of CORS.
  • ✓Keep credentials out of browser bundles and repositories; rotate them if exposed.
  • ✓Security headers help reduce risk but must fit the actual app and deployment.

Next

What comes next

Turn security and product requirements into automated tests across components, API routes, and browser workflows.

Lesson 10 · Testing a Full-Stack App — Unit, API and Playwright E2E →

HELP US IMPROVE

How was this lesson?

Your note is shared with the Chaduvuko team for review. Please don’t include personal or sensitive information.

Choose your feedback

Spotted a mistake or something unclear? Suggest a fix on GitHub or email us. Select the text first and it is quoted for you.

Share

Discussion

0

Have a better approach? Found something outdated? Share it — your knowledge helps everyone learning here.

Continue with GitHub
Loading...