コンテンツにスキップ

👿 CSRF (Cross-Site Request Forgery) 攻撃

ログイン中の利用者のブラウザに、攻撃者が作ったリクエストを正規サイトへ送らせる攻撃

CSRF: 罠サイトの form と JS が、あなたのブラウザから Cookie 付きで送られてしまう。Cookie は送り元ではなく宛先で選ばれる

ブラウザは、どのサイトから出たリクエストにも、宛先のサイトの Cookie を自動で付けます。そのため正規サイトからは、利用者本人の操作と見分けがつきません。

次の 3 つがそろうと成立します。

CSRF が成立する 3 つの条件: 1. ブラウザが自動で付ける情報 (Cookie など) で認証している、2. 状態を変える操作のパラメータが、すべて攻撃者に予想できる、3. 利用者がログインしたまま、攻撃者のページを開く。どれか 1 つでも欠ければ成立しない

sequenceDiagram
    autonumber
    actor User as 🥸 利用者 (被害者)
    participant Bank as 🏦 正規サイト<br/>bank.example
    participant Evil as 👿 罠サイト<br/>evil.example

    rect rgb(150, 150, 150)
        Note over User,Bank: 1. ふだんどおりログインする
        User->>+Bank: ログイン
        Bank-->>-User: 🍪 セッション Cookie を発行
    end

    rect rgb(150, 150, 150)
        Note over User,Evil: 2. 罠サイトを開かされる
        User->>+Evil: メールや SNS のリンクから開く
        Evil-->>-User: 見えないフォームと、それを自動で送信するスクリプトを返す
        Note left of Evil: 送信先: https://bank.example/transfer (POST)<br/>to=攻撃者の口座&amount=100000
    end

    rect rgb(150, 100, 100)
        Note over User,Bank: 3. 偽造されたリクエストが届く
        User->>+Bank: 送金してください (ブラウザが 🍪 Cookie を自動で付ける)
        Note right of User: POST /transfer<br/>Cookie: session=<🍪> ← 送り元 (evil.example) ではなく、宛先 (bank.example) の Cookie<br/>to=攻撃者の口座&amount=100000
        Bank->>Bank: 🍪 Cookie が正しい → 本人の操作とみなす
        Bank-->>-User: 送金しました
    end
  • 攻撃者はレスポンスを読めません (同一オリジンポリシーで読めない)。それでも、送金・メールアドレスの変更・投稿・削除といった副作用は起きてしまいます
  • 利用者は罠のページを開いただけで、何もクリックしていなくても被害に遭います
💻 コードで見る: ⑤ はどう送られるか

⑤ を送るのは攻撃者ではありません。④ で罠サイトが返した HTML を実行した、利用者のブラウザが送ります。

④ で罠サイトが返す HTML

<!-- https://evil.example/ が返すページ -->
<!doctype html>
<html>
<body>
<!-- 送信先は別サイトの bank.example。hidden なので画面には何も出ない -->
<form id="f" action="https://bank.example/transfer" method="POST">
<input type="hidden" name="to" value="attacker-account">
<input type="hidden" name="amount" value="100000">
</form>
<script>
// ページを開いた瞬間に、利用者のクリックなしで送信する
document.getElementById("f").submit();
</script>
</body>
</html>

⑤ でブラウザがしていること

  1. form.submit() が呼ばれ、https://bank.example/transfer への POST を作る。HTML のフォームはどのサイトにでも送れる仕様で、同一オリジンポリシーは送信を止めない (止めるのはレスポンスを読むことだけ)
  2. Cookie の保管庫から、宛先 (bank.example) の Cookie を探して付ける。どのページから送ったか (evil.example) では選ばない
  3. フォームの送信は画面遷移で、CORS の対象外なので、プリフライト無しでそのまま送る

② で次の Cookie が発行されていると、⑤ では次のリクエストが届きます。

Set-Cookie: session=abc123; Secure; HttpOnly; SameSite=None
POST /transfer HTTP/1.1
Host: bank.example
Origin: https://evil.example
Sec-Fetch-Site: cross-site
Content-Type: application/x-www-form-urlencoded
Cookie: session=abc123
to=attacker-account&amount=100000

本物の送金 (bank.example の画面から送る) と比べると、違いはブラウザが付けるヘッダーだけで、主に Origin と Sec-Fetch-Site です。どちらも罠サイトの JS からは書き換えられません。

ヘッダー 本物の送金 ⑤ の偽造リクエスト
Cookie session=abc123 session=abc123 (同じ)
本文 to=...&amount=... to=...&amount=... (同じ形)
Origin https://bank.example https://evil.example
Sec-Fetch-Site same-origin cross-site

⑥ で狙われるサーバーの実装 (FastAPI の例)

@app.post("/transfer")
def transfer(
to: Annotated[str, Form()],
amount: Annotated[int, Form()],
session: Annotated[str | None, Cookie()] = None,
):
user = sessions.get(session) # Cookie だけで利用者を特定している
if user is None:
raise HTTPException(status_code=401)
bank.transfer(from_account=user.account, to=to, amount=amount)
return {"result": "送金しました"}

Cookie と本文は本物と同じなので、Cookie しか見ないこのハンドラーは本人の送金として処理します。

  • HttpOnly では防げない: 攻撃者は Cookie を読む必要がない。付けるのはブラウザ
  • 攻撃者は Cookie の値を知らない: abc123 を知らないまま、Cookie 付きのリクエストを送らせられる
  • SameSite=Lax なら ⑤ で止まる: 別サイトからの POST には Cookie が付かず、session が None になって 401 で終わる
  • 画面に気づかれないようにする: フォームを送るとページが bank.example の応答に変わるため、見えない iframe の中で送らせることもある。fetch() に credentials: "include" を付けても、同じように Cookie 付きで送れる (レスポンスは読めない)

状態を変える操作なら、何でも本人になりすまして実行されます。

狙われる操作 被害
送金・購入 お金を奪われる
メールアドレスの変更 パスワードリセットのメールが攻撃者に届き、アカウントを乗っ取られる
投稿・書き込み 本人の名前で投稿される (犯行予告など)
削除・設定の変更 データを消される、公開範囲を広げられる
ログイン (ログイン CSRF) 入力したカード情報や履歴が、攻撃者のアカウントに残る

SameSite=Lax を明示し、Origin (または Sec-Fetch-Site) で確かめ、GET で状態を変えない、という多層の組み合わせが基本です。
MUST は必ず、SHOULD は当てはまらない理由が無い限り、WANT は必要なときに実装します。

[MUST] 🍪 SameSite Cookie / 別サイトからのリクエストに Cookie を付けさせない
import { cookies } from "next/headers";
// ログインしたとき (Server Action・Route Handler の中) に発行する
(await cookies()).set("session", sessionId, {
httpOnly: true,
secure: true,
sameSite: "lax",
});

SameSite の値ごとに、別サイトから来たリクエストに Cookie を付けるかが変わります。

SameSite 別サイトのリンクから開く (画面遷移の GET) 別サイトからのフォーム POST・img・fetch
Strict 送らない (リンクから来るとログアウト状態に見える) 送らない
Lax 送る 送らない
None (Secure が必須) 送る 送る
  • ⚠️ 「サイト」は登録可能なドメインの単位 (example.com) で決まり、サブドメインは同じサイト扱いになります。evil.example.com から app.example.com への攻撃は防げません
[MUST] 🧭 Origin / Sec-Fetch-Site の確認 / ブラウザが付ける送り元のヘッダーを見て、別サイトからなら拒否する
# 自サイトのオリジン。画面を同じサイトのサブドメイン (app.bank.example など) に置くなら、画面のオリジンも入れる (fetch で呼ぶなら CORS でも許可する)
ALLOWED_ORIGINS = {"https://bank.example"}
# FastAPI には CSRF を確かめる仕組みが無いので、ミドルウェアで書く
@app.middleware("http")
async def reject_cross_site_requests(request: Request, call_next):
# GET などは確かめないので、GET で状態を変えないことが前提
if request.method not in {"GET", "HEAD", "OPTIONS"}:
site = request.headers.get("sec-fetch-site")
origin = request.headers.get("origin")
if site is not None:
# ALLOWED_ORIGINS に無い same-site (サブドメイン) も拒否するので、SameSite で防げない攻撃も止まる
allowed = site in {"same-origin", "none"} or origin in ALLOWED_ORIGINS
else:
# Sec-Fetch-Site を送らない古いブラウザは Origin で見る。どちらも無いのはブラウザ以外か、どちらも送らない古いブラウザ (通してしまうので、守るなら CSRF トークンを足す)
allowed = origin is None or origin in ALLOWED_ORIGINS
if not allowed:
return Response(status_code=403)
return await call_next(request)

⑤ は Sec-Fetch-Site: cross-site なので 403 になります。どちらのヘッダーも、罠サイトの JS からは書き換えられません。
Next.js の Server Action は、Next.js が Origin と Host (X-Forwarded-Host) を比べて、違えば拒否します (Origin が無ければ通す)。Route Handler (route.ts) の POST などは確かめないので、同じ判定を自分で書きます。

[MUST] 🚫 GET で状態を変えない / 他の対策の前提
# ❌ 罠サイトの location.href = "https://bank.example/transfer?to=attacker-account&amount=100000" で送金される
@app.get("/transfer")
def transfer(to: str, amount: int, session: Annotated[str | None, Cookie()] = None): ...
# ✅
@app.post("/transfer")
def transfer(...): ...
  • ⚠️ 画面遷移 (GET) には SameSite=Lax でも Cookie が付き、Origin / Sec-Fetch-Site の確認も GET を見ません
[SHOULD] 📦 JSON や独自ヘッダーを必須にする / 別サイトのフォームからは送れず、fetch ではプリフライトになって CORS で止まる
class TransferJson(BaseModel):
to: str
amount: int
# 独自ヘッダーも必須にするなら、付いていないリクエストを拒否する (画面の fetch で X-Requested-With を付ける)
def require_custom_header(x_requested_with: Annotated[str | None, Header()] = None):
if x_requested_with is None:
raise HTTPException(status_code=403)
# 本文は JSON のモデルで受ける。独自ヘッダーを使わないなら dependencies を外す
@app.post("/transfer", dependencies=[Depends(require_custom_header)])
def transfer(body: TransferJson, session: Annotated[str | None, Cookie()] = None): ...

⑤ のフォームは X-Requested-With が無いので 403 になります。dependencies を外しても、FastAPI は application/json 以外の本文を JSON として読まないので 422 になります。
fetch から呼ぶ API に使います。HTML のフォーム (Server Action など) は JSON を送れないので、当てはまりません。

  • ⚠️ FastAPI(strict_content_type=False) にしないでください。Content-Type の無い本文 (プリフライト無しで送れる) も JSON として読むようになり、破られます
  • ⚠️ CORS を緩く設定すると破られます。次のように書くと、Starlette は届いた Origin をそのまま許可して返します
# ❌ どのサイトからも Cookie 付きで送らせ、応答も読ませてしまう
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
[SHOULD] 🔑 重要な操作で再認証する / パスワードの再入力や確認画面を挟む
@app.post("/email")
def change_email(
new_email: Annotated[str, Form()],
password: Annotated[str, Form()],
session: Annotated[str | None, Cookie()] = None,
):
user = sessions.get(session)
if user is None:
raise HTTPException(status_code=401)
if not users.verify_password(user, password):
raise HTTPException(status_code=403)
users.change_email(user, new_email)

攻撃者はパスワードを知らないので、罠のフォームに入れられません。IdP (Google など) でログインするなら、IdP でログインし直してもらいます。

  • ⚠️ 使い勝手とのトレードオフです。メールアドレスの変更・送金など、乗っ取りや被害につながる操作に絞ります
[WANT] 🎲 CSRF トークン / 攻撃者が知りえないランダムな値をフォームに埋めておき、送信時に照合する
import { randomBytes } from "node:crypto";
// ログインしたとき: ログインのたびに作り直し、セッションに保存する
await sessions.set(sessionId, { user, csrfToken: randomBytes(32).toString("base64url") });
// app/transfer/page.tsx: 送金の画面のフォームに埋める
import { redirect } from "next/navigation";
export default async function TransferPage() {
const session = await getSession();
if (!session) redirect("/login");
return (
<form action="/api/transfer" method="POST">
<input type="hidden" name="csrf_token" value={session.csrfToken} />
<input name="to" />
<input name="amount" type="number" />
<button type="submit">送金する</button>
</form>
);
}
// app/api/transfer/route.ts: 送信されたトークンを、セッションの値と比べる
import { timingSafeEqual } from "node:crypto";
import { type NextRequest, NextResponse } from "next/server";
export async function POST(request: NextRequest) {
const session = await getSession();
if (!session) {
return new NextResponse(null, { status: 401 });
}
const formData = await request.formData();
const token = formData.get("csrf_token");
if (typeof token !== "string" || !isSameToken(token, session.csrfToken)) {
return new NextResponse(null, { status: 403 });
}
// ... 送金する
}
// === はかかる時間の差から値を当てられるので、時間が一定の比較を使う。timingSafeEqual は長さが違うと例外を投げるので、先に比べる
function isSameToken(sent: string, expected: string): boolean {
const a = Buffer.from(sent);
const b = Buffer.from(expected);
return a.length === b.length && timingSafeEqual(a, b);
}

攻撃者はトークンを知らないので、罠のフォームに入れられません。
Origin / Sec-Fetch-Site の確認は、どちらのヘッダーも送らない古いブラウザを通してしまいます。そうしたブラウザまで守るときに足します。

  • ⚠️ XSS があると、画面からトークンを読まれて破られます
[WANT] 🪪 (設計) Cookie で認証しない / Authorization: Bearer は自動で付かないので、CSRF が成立しない
@app.post("/transfer")
def transfer(
body: TransferJson,
credentials: Annotated[HTTPAuthorizationCredentials, Depends(HTTPBearer())],
):
user = users.verify_token(credentials.credentials)
...

ブラウザは Authorization を自動で付けないので、罠サイトからは送れません (無ければ HTTPBearer が 401 を返す)。
BFF の形 (ブラウザは Next.js のサーバーだけを Cookie で呼び、API は Next.js のサーバーが Bearer で呼ぶ) なら、API はこの形にし、ブラウザの Cookie を受ける Next.js の側で上の対策をします。

  • ⚠️ トークンを localStorage など JS から読める場所に置くと、XSS で盗まれます

詳しくは OWASP の CSRF Prevention Cheat Sheet にまとまっています。