ログイン機能があるツールを作るときは必要な個人情報だけを取得・保管するようにしている話

ログイン機能があるツールを作るときは必要な個人情報だけを取得・保管するようにしている話

侵害は対策を重ねても完全には防げません。侵害を防ぐ対策に加えて、侵害されたときの被害を最小化する「ダメージコントロール」の考え方でツールを作っています。データを保管することは、そのデータが流出したときの責任を負うということです。保管しているデータを自分で把握することを、被害を最小化する出発点にしています。
2026.11.17

はじめに

最近、ログイン機能があるツールを 4 本作りました。この 4 本では、保管する利用者の個人情報を最小化しています。侵害されたときに攻撃者が取得できるデータを最小化するため、データが必要なときに必要な分だけ取得するようにしています。 そのための 4 つの手段を、Cloudflare Workers と GitHub OAuth のサンプルとともに紹介します。

ダメージコントロールとは

ダメージコントロールは、被害が発生することを前提に、被害の範囲を最小化する考え方です。この語はもともと、損傷した船の浸水を一部の区画にとどめて沈没を防ぐための対処を指す言葉です。セキュリティの文脈では、侵害された後の被害を最小化するための設計思想という意味で使われることが多いです。

対象読者

  • ログイン機能がある個人開発のツールや社内ツールを作っている方
  • 認証を外部のサービスやライブラリに任せていて保管データを把握しきれていない方

参考

背景

利用者アカウントの乗っ取りや Web サイトの脆弱性を突く攻撃といった侵害は、防ぐ対策を重ねても完全には防げません。侵害が成立したとき、攻撃者が取得できるのはツールが保管しているデータです。保管していないデータを、攻撃者は取得できません。そのため、保管するデータの最小化はダメージコントロールの手段になります。

最小権限の原則は、処理に必要な最小限の権限だけを与えるという、セキュリティ設計の原則です。私はこの原則を、利用者に要求する権限に加えて、ツールが保管するデータにも適用しています。具体的には、データが必要なときに必要な分だけ取得するという形です。

この方針を、私はいくつかの手段で実践しています。データを取得する段階では 「取得しない」 あるいは 「取得しても保管しない」 、データを保管する段階では 「ハッシュ化・暗号化して保管する」「有効期限を設けて削除する」 といった具合です。この後のセクションではそれぞれの手段について詳しく解説していきます。

実践

ここからはサンプルを使って具体的なコードを紹介しながら解説していきます。サンプルは Cloudflare Workers と D1 で動き、GitHub でログインするツールを想定しています。ツールの用途としては、「勉強会の参加者が参加申し込みをするときに、GitHub アカウントを通して本人かどうかを確認するツール」 という感じで想像いただければ幸いです。

データベースには次の 2 つのテーブルだけを作成します。

schema.sql
CREATE TABLE sessions (
  token_hash TEXT PRIMARY KEY,
  github_id INTEGER NOT NULL,
  expires_at INTEGER NOT NULL
);

CREATE TABLE credentials (
  github_id INTEGER NOT NULL,
  purpose TEXT NOT NULL,
  ciphertext TEXT NOT NULL,
  PRIMARY KEY (github_id, purpose)
);

sessions テーブルにはログイン中の利用者を識別するセッションを保管します。

各節にはサンプルの要部だけを載せます。サンプルの全体は次のとおりです。

src/index.ts
src/index.ts
export interface Env {
  DB: D1Database;
  GITHUB_CLIENT_ID: string;
  GITHUB_CLIENT_SECRET: string;
  TOKEN_KEY: string;
}

// ---- 共通 ----
declare function verifyState(request: Request): Promise<boolean>;
declare function exchangeCode(env: Env, code: string): Promise<string>;

const encoder = new TextEncoder();
const toBase64 = (bytes: Uint8Array) => btoa(String.fromCharCode(...bytes));
const fromBase64 = (value: string) => Uint8Array.from(atob(value), (c) => c.charCodeAt(0));
const now = () => Math.floor(Date.now() / 1000);

// ---- 1. 取得しない ----
export function redirectToGitHub(env: Env, state: string): Response {
  const url = new URL("https://github.com/login/oauth/authorize");
  url.searchParams.set("client_id", env.GITHUB_CLIENT_ID);
  url.searchParams.set("state", state);
  // 公開情報の読み取りだけを許可するアクセストークンを要求する
  url.searchParams.set("scope", "");
  return Response.redirect(url.toString(), 302);
}

async function fetchGitHubId(accessToken: string): Promise<number> {
  const res = await fetch("https://api.github.com/user", {
    headers: {
      Authorization: `Bearer ${accessToken}`,
      Accept: "application/vnd.github+json",
      "User-Agent": "sample-app",
    },
  });
  if (!res.ok) throw new Error("GitHub user request failed");
  // 応答には名前やアイコンも含まれるが、id 以外は参照しない
  const { id } = (await res.json()) as { id: number };
  return id;
}

// ---- 2. 取得しても保管しない ----
export async function handleGitHubCallback(request: Request, env: Env): Promise<Response> {
  const code = new URL(request.url).searchParams.get("code");
  if (!code || !(await verifyState(request))) return new Response("Bad Request", { status: 400 });

  const accessToken = await exchangeCode(env, code);
  try {
    const githubId = await fetchGitHubId(accessToken);
    return await startSession(env.DB, githubId);
  } finally {
    // GitHub の利用者 ID を取得したら、アクセストークンは保管せずに失効させる
    await revokeToken(env, accessToken);
  }
}

async function revokeToken(env: Env, accessToken: string): Promise<void> {
  await fetch(`https://api.github.com/applications/${env.GITHUB_CLIENT_ID}/token`, {
    method: "DELETE",
    headers: {
      Authorization: `Basic ${btoa(`${env.GITHUB_CLIENT_ID}:${env.GITHUB_CLIENT_SECRET}`)}`,
      Accept: "application/vnd.github+json",
      "User-Agent": "sample-app",
    },
    body: JSON.stringify({ access_token: accessToken }),
  });
}

// ---- 3. ハッシュ化・暗号化して保管する ----
const SESSION_TTL = 7 * 24 * 60 * 60;

async function sha256(value: string): Promise<string> {
  return toBase64(new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(value))));
}

async function startSession(db: D1Database, githubId: number): Promise<Response> {
  const token = toBase64(crypto.getRandomValues(new Uint8Array(32)));
  await db
    .prepare("INSERT INTO sessions (token_hash, github_id, expires_at) VALUES (?, ?, ?)")
    .bind(await sha256(token), githubId, now() + SESSION_TTL)
    .run();
  return new Response(null, {
    status: 302,
    headers: {
      Location: "/",
      "Set-Cookie": `session=${token}; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=${SESSION_TTL}`,
    },
  });
}

export async function findSession(db: D1Database, token: string): Promise<number | null> {
  const row = await db
    .prepare("SELECT github_id FROM sessions WHERE token_hash = ? AND expires_at > ?")
    .bind(await sha256(token), now())
    .first<{ github_id: number }>();
  return row?.github_id ?? null;
}

async function importKey(env: Env): Promise<CryptoKey> {
  return crypto.subtle.importKey("raw", fromBase64(env.TOKEN_KEY), "AES-GCM", false, ["encrypt", "decrypt"]);
}

export async function encryptToken(env: Env, token: string, githubId: number, purpose: string): Promise<string> {
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const ciphertext = await crypto.subtle.encrypt(
    // GitHub の利用者 ID と用途を復号の条件にする。別の行へ複製すると復号できない
    { name: "AES-GCM", iv, additionalData: encoder.encode(`${githubId}:${purpose}`) },
    await importKey(env),
    encoder.encode(token),
  );
  return `${toBase64(iv)}.${toBase64(new Uint8Array(ciphertext))}`;
}

export async function decryptToken(env: Env, stored: string, githubId: number, purpose: string): Promise<string> {
  const [iv, ciphertext] = stored.split(".");
  const plaintext = await crypto.subtle.decrypt(
    { name: "AES-GCM", iv: fromBase64(iv), additionalData: encoder.encode(`${githubId}:${purpose}`) },
    await importKey(env),
    fromBase64(ciphertext),
  );
  return new TextDecoder().decode(plaintext);
}

// ---- 4. 有効期限を設けて削除する ----
export default {
  async scheduled(_controller, env) {
    const time = now();
    await env.DB.batch([
      env.DB.prepare("DELETE FROM sessions WHERE expires_at <= ?").bind(time),
      // 有効なセッションが残っていない利用者のアクセストークンも削除する
      env.DB.prepare(
        "DELETE FROM credentials WHERE github_id NOT IN (SELECT github_id FROM sessions WHERE expires_at > ?)",
      ).bind(time),
    ]);
  },
} satisfies ExportedHandler<Env>;

取得しない

GitHub OAuth で認可を要求するときは、スコープを空にします。スコープのないアクセストークンに許可されるのは、公開情報の読み取りだけです。

src/index.ts
export function redirectToGitHub(env: Env, state: string): Response {
  const url = new URL("https://github.com/login/oauth/authorize");
  url.searchParams.set("client_id", env.GITHUB_CLIENT_ID);
  url.searchParams.set("state", state);
  // 公開情報の読み取りだけを許可するアクセストークンを要求する
  url.searchParams.set("scope", "");
  return Response.redirect(url.toString(), 302);
}

async function fetchGitHubId(accessToken: string): Promise<number> {
  const res = await fetch("https://api.github.com/user", {
    headers: {
      Authorization: `Bearer ${accessToken}`,
      Accept: "application/vnd.github+json",
      "User-Agent": "sample-app",
    },
  });
  if (!res.ok) throw new Error("GitHub user request failed");
  // 応答には名前やアイコンも含まれるが、id 以外は参照しない
  const { id } = (await res.json()) as { id: number };
  return id;
}

ログインした利用者の識別に必要なデータは、GitHub の利用者 ID だけです。そのため、/user の応答に名前や公開中のメールアドレスが含まれていても、id 以外は参照しません。

この設定により、アクセストークンが窃取されても、攻撃者は非公開のリポジトリを読み書きできません。また、データベースが流出しても、利用者の名前とメールアドレスは流出しません。ただしデメリットとして、利用者への連絡手段がなくなります。

取得しても保管しない

ログインのために取得したアクセストークンは、GitHub の利用者 ID を取得した時点で失効させ、保管しません。セッションには GitHub の利用者 ID だけを結び付けます。

src/index.ts
export async function handleGitHubCallback(request: Request, env: Env): Promise<Response> {
  const code = new URL(request.url).searchParams.get("code");
  if (!code || !(await verifyState(request))) return new Response("Bad Request", { status: 400 });

  const accessToken = await exchangeCode(env, code);
  try {
    const githubId = await fetchGitHubId(accessToken);
    return await startSession(env.DB, githubId);
  } finally {
    // GitHub の利用者 ID を取得したら、アクセストークンは保管せずに失効させる
    await revokeToken(env, accessToken);
  }
}

async function revokeToken(env: Env, accessToken: string): Promise<void> {
  await fetch(`https://api.github.com/applications/${env.GITHUB_CLIENT_ID}/token`, {
    method: "DELETE",
    headers: {
      Authorization: `Basic ${btoa(`${env.GITHUB_CLIENT_ID}:${env.GITHUB_CLIENT_SECRET}`)}`,
      Accept: "application/vnd.github+json",
      "User-Agent": "sample-app",
    },
    body: JSON.stringify({ access_token: accessToken }),
  });
}

※ verifyState は state を検証する処理で、exchangeCode は認可コードをアクセストークンと交換する処理です。いずれも省略しています。

アクセストークンの失効には GitHub の DELETE /applications/{client_id}/token を使用します。この API は OAuth アプリのクライアント ID とクライアントシークレットを用いた Basic 認証で呼び出します。

この処理により、データベースにも Cookie にも GitHub のアクセストークンが保管されません。ただしデメリットとして、ツールはログイン後に利用者の権限で GitHub の API を呼び出せなくなります。

ハッシュ化・暗号化して保管する

保管が必要なデータは、そのままでは使用できない形で保管します。照合にだけ使う値はハッシュ化し、元の値を使う必要がある値は暗号化します。

セッショントークンは、利用者から送信された値との照合にだけ使用し、元の値は必要ありません。そのため、データベースには SHA-256 のハッシュ値だけを保管します。

src/index.ts
const SESSION_TTL = 7 * 24 * 60 * 60;

async function startSession(db: D1Database, githubId: number): Promise<Response> {
  const token = toBase64(crypto.getRandomValues(new Uint8Array(32)));
  await db
    .prepare("INSERT INTO sessions (token_hash, github_id, expires_at) VALUES (?, ?, ?)")
    .bind(await sha256(token), githubId, now() + SESSION_TTL)
    .run();
  return new Response(null, {
    status: 302,
    headers: {
      Location: "/",
      "Set-Cookie": `session=${token}; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=${SESSION_TTL}`,
    },
  });
}

export async function findSession(db: D1Database, token: string): Promise<number | null> {
  const row = await db
    .prepare("SELECT github_id FROM sessions WHERE token_hash = ? AND expires_at > ?")
    .bind(await sha256(token), now())
    .first<{ github_id: number }>();
  return row?.github_id ?? null;
}

セッショントークンは 32 バイトの乱数です。そのため、データベースが流出しても、攻撃者はハッシュ値からセッショントークンを復元できません。

一方、ログイン後に GitHub の API を呼び出すツールでは、アクセストークンの元の値が必要です。その場合は、アクセストークンを AES-GCM で暗号化して保管します。暗号化の鍵はデータベースではなく Workers の Secrets に保管します。

src/index.ts
export async function encryptToken(env: Env, token: string, githubId: number, purpose: string): Promise<string> {
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const ciphertext = await crypto.subtle.encrypt(
    // GitHub の利用者 ID と用途を復号の条件にする。別の行へ複製すると復号できない
    { name: "AES-GCM", iv, additionalData: encoder.encode(`${githubId}:${purpose}`) },
    await importKey(env),
    encoder.encode(token),
  );
  return `${toBase64(iv)}.${toBase64(new Uint8Array(ciphertext))}`;
}

AES-GCM の復号は、暗号化と復号で additionalData が一致しないと失敗します。そこで、additionalData に GitHub の利用者 ID と用途を指定します。この指定により、攻撃者が暗号文を別の利用者の行へ複製しても、ツールはその暗号文を復号できません。

これらの処理により、データベースだけが流出した場合、攻撃者はセッショントークンもアクセストークンも使用できません。ただしデメリットとして、暗号化の鍵を保管し更新するという手間が発生する形です。

有効期限を設けて削除する

セッションには 7 日の有効期限を設け、利用中でも延長しません。前節の startSession が有効期限を保存し、findSession が有効期限内のセッションだけを有効と判定します。

有効期限を過ぎたセッションは、Cron Triggers で毎日削除します。あわせて、有効なセッションが残っていない利用者のアクセストークンも削除します。

src/index.ts
export default {
  async scheduled(_controller, env) {
    const time = now();
    await env.DB.batch([
      env.DB.prepare("DELETE FROM sessions WHERE expires_at <= ?").bind(time),
      // 有効なセッションが残っていない利用者のアクセストークンも削除する
      env.DB.prepare(
        "DELETE FROM credentials WHERE github_id NOT IN (SELECT github_id FROM sessions WHERE expires_at > ?)",
      ).bind(time),
    ]);
  },
} satisfies ExportedHandler<Env>;
wrangler.jsonc
{
  "triggers": {
    "crons": ["0 3 * * *"]
  }
}

この処理により、窃取されたセッショントークンを使用できる期間は最長 7 日になります。また、ログインしなくなった利用者のアクセストークンもデータベースから削除されます。ただしデメリットとして、利用者は 7 日ごとにログインし直さなければいけなくなります。

4 つの手段の比較

上記 4 つの手段について、攻撃者が取得できなくなるデータと、デメリットを次の表に示します。

手段 侵害されたときに攻撃者が取得できなくなるもの デメリット
取得しない 非公開のリポジトリへのアクセス権限、利用者の名前とメールアドレス 利用者への連絡手段がない
取得しても保管しない GitHub のアクセストークン ログイン後に GitHub の API を呼び出せない
ハッシュ化・暗号化して保管する データベースだけが流出した場合の使用可能なセッショントークンとアクセストークン 暗号化の鍵の保管と更新の手間
有効期限を設けて削除する 有効期限切れのセッション・ログインしなくなった利用者のアクセストークン 7 日ごとの再ログイン

考察

本記事を書くにあたり、4 本のツールのデータベース・Cookie・ログに保管されているデータを一覧にしました。その結果、認証ライブラリの標準のテーブル定義に従って、メールアドレスや表示名を保管しているツールが見つかりました。私はその保管に、一覧にするまで気付いていませんでした。

これらのツールでは実装の多くを AI に任せ、計画を AI にレビューさせる際には「セキュリティ的に最小限か」と確認しています。それでも気付かなかったことから、ライブラリや AI に実装を任せるほど、保管するデータは意図しない箇所で増えるのだと思います。

保管するデータを最小化するには、手段を知っていることに加えて、保管しているデータを自分で把握していることが前提になると考えています。データを保管するということは、そのデータが流出したときの責任を負うということです。 この自覚をもって、データの最小化の出発点にするのが良いと考えています。

まとめ

ログイン機能があるツールを作っている方は、まず自分のツールのデータベース・Cookie・ログに保管されているデータを一覧にするのがよいでしょう。そして次に、一覧の各項目に「取得しない」「取得しても保管しない」「ハッシュ化・暗号化して保管する」「有効期限を設けて削除する」手段の導入を検討してみてください。

ログイン機能があるツールを作る方にとって、本記事が参考になれば幸いです。

この記事をシェアする

関連記事