# 👿 CSRF (Cross-Site Request Forgery) 攻撃
> **ログイン中の利用者のブラウザに、攻撃者が作ったリクエストを正規サイトへ送らせる攻撃**

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

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

## 📚 攻撃手順
次の 3 つがそろうと成立します。

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

```mermaid
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
```

 - 攻撃者はレスポンスを読めません (同一オリジンポリシーで読めない)。それでも、送金・メールアドレスの変更・投稿・削除といった副作用は起きてしまいます
 - 利用者は罠のページを開いただけで、何もクリックしていなくても被害に遭います

<details><summary>💻 <b>コードで見る: ⑤ はどう送られるか</b></summary>

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

④ で罠サイトが返す 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 が発行されていると、⑤ では次のリクエストが届きます。

```http
Set-Cookie: session=abc123; Secure; HttpOnly; SameSite=None
```

```http
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 の例)

```python
@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 付きで送れる (レスポンスは読めない)

</details>

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

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

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

<details><summary>[MUST] 🍪 <b>SameSite Cookie / 別サイトからのリクエストに Cookie を付けさせない</b></summary>

```ts
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` への攻撃は防げません

</details>

<details><summary>[MUST] 🧭 <b>Origin / Sec-Fetch-Site の確認 / ブラウザが付ける送り元のヘッダーを見て、別サイトからなら拒否する</b></summary>

```python
# 自サイトのオリジン。画面を同じサイトのサブドメイン (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 からは書き換えられません。<br/>
Next.js の Server Action は、Next.js が `Origin` と `Host` (`X-Forwarded-Host`) を比べて、違えば拒否します (`Origin` が無ければ通す)。Route Handler (`route.ts`) の POST などは確かめないので、同じ判定を自分で書きます。

</details>

<details><summary>[MUST] 🚫 <b>GET で状態を変えない / 他の対策の前提</b></summary>

```python
# ❌ 罠サイトの 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 を見ません

</details>

<details><summary>[SHOULD] 📦 <b>JSON や独自ヘッダーを必須にする / 別サイトのフォームからは送れず、fetch ではプリフライトになって CORS で止まる</b></summary>

```python
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 になります。<br/>
fetch から呼ぶ API に使います。HTML のフォーム (Server Action など) は JSON を送れないので、当てはまりません。

 - ⚠️ `FastAPI(strict_content_type=False)` にしないでください。`Content-Type` の無い本文 (プリフライト無しで送れる) も JSON として読むようになり、破られます
 - ⚠️ CORS を緩く設定すると破られます。次のように書くと、Starlette は届いた `Origin` をそのまま許可して返します

```python
# ❌ どのサイトからも Cookie 付きで送らせ、応答も読ませてしまう
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
```

</details>

<details><summary>[SHOULD] 🔑 <b>重要な操作で再認証する / パスワードの再入力や確認画面を挟む</b></summary>

```python
@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 でログインし直してもらいます。

 - ⚠️ 使い勝手とのトレードオフです。メールアドレスの変更・送金など、乗っ取りや被害につながる操作に絞ります

</details>

<details><summary>[WANT] 🎲 <b>CSRF トークン / 攻撃者が知りえないランダムな値をフォームに埋めておき、送信時に照合する</b></summary>

```ts
import { randomBytes } from "node:crypto";

// ログインしたとき: ログインのたびに作り直し、セッションに保存する
await sessions.set(sessionId, { user, csrfToken: randomBytes(32).toString("base64url") });
```

```tsx
// 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>
  );
}
```

```ts
// 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);
}
```

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

 - ⚠️ XSS があると、画面からトークンを読まれて破られます

</details>

<details><summary>[WANT] 🪪 <b>(設計) Cookie で認証しない / Authorization: Bearer は自動で付かないので、CSRF が成立しない</b></summary>

```python
@app.post("/transfer")
def transfer(
    body: TransferJson,
    credentials: Annotated[HTTPAuthorizationCredentials, Depends(HTTPBearer())],
):
    user = users.verify_token(credentials.credentials)
    ...
```

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

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

</details>

詳しくは [OWASP の CSRF Prevention Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html) にまとまっています。
