メインコンテンツへスキップ
見出し画像

ソシャゲのサーバーを作る。認証を実装する(4)

    前回は、アカウントをどう作るかの設計をやりました。

    prepareでワンタイムキーを発行して、signupで端末キーと一緒に送ってアカウントを作る。
    前回の図をもとに、今回は実装します。

    コードも巻末に置きました、興味のある方はどうぞ。

    作るもの

    エンドポイントは3つだけです。

    POST /auth/prepare   ワンタイムキーを発行する
    POST /auth/signup    アカウントを作る、または既存のアカウントでログインする
    GET  /user/profile   トークンで認証して、自分の情報を返す

    3つめで動作確認ができるような流れです。
    認証がちゃんと効いているかを見るために作ります。

    テーブルを作る

    前回設計した`user`と`user_auth`に加えて、2つ足しました。

    -- ユーザー本体
    CREATE TABLE IF NOT EXISTS `user` (
      `id` BIGINT NOT NULL AUTO_INCREMENT,
      `name` VARCHAR(32) NOT NULL,
      `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
      `last_login_at` DATETIME NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    
    -- 認証手段。今は端末キーのみ
    CREATE TABLE IF NOT EXISTS `user_auth` (
      `id` BIGINT NOT NULL AUTO_INCREMENT,
      `user_id` BIGINT NOT NULL,
      `auth_type` TINYINT NOT NULL,
      `auth_key_hash` CHAR(64) NOT NULL,
      `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
      PRIMARY KEY (`id`),
      UNIQUE KEY `uk_auth` (`auth_type`, `auth_key_hash`),
      KEY `idx_user_id` (`user_id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    
    -- セッション
    CREATE TABLE IF NOT EXISTS `user_session` (
      `token_hash` CHAR(64) NOT NULL,
      `user_id` BIGINT NOT NULL,
      `expires_at` DATETIME NOT NULL,
      `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
      PRIMARY KEY (`token_hash`),
      KEY `idx_user_id` (`user_id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    
    -- ワンタイムキー
    CREATE TABLE IF NOT EXISTS `auth_onetime` (
      `key_hash` CHAR(64) NOT NULL,
      `expires_at` DATETIME NOT NULL,
      `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
      PRIMARY KEY (`key_hash`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

    `user_session`と`auth_onetime`は、あとで削除します。
    暫定的に利用します。

    どちらも期限付きのデータなので、履歴として永続的には残しません。
    こういうのはRedisのようなメモリ上のキーバリューに置くほうが向いてます。
    しかも有効期限を設定しておけば勝手に消えてくれます。

    ただ今回はMySQLだけで作ります。
    構成を増やす前に、まず動かしてみようということで。

    まずクエリ流してテーブルを作ります。

    docker compose exec -T db mysql -uroot -p**** api_game_user < db/api_game_user/auth.sql

    環境変数をひとつ足す

    ハッシュに使う秘密の文字列を追加します。

        environment:
          ...
          AUTH_HASH_SECRET: ${AUTH_HASH_SECRET}

    値は`.env`に書きます。適当に長いランダム文字列で。

    AUTH_HASH_SECRET=(ランダムな文字列)

    これが漏れると、ハッシュにしている意味が薄くなります。
    本番環境だとシークレットマネージャのような仕組みから読み込むことが多いのではないでしょうか。

    コード

    ファイル構成はこんな感じに。

    src/
      index.ts        起動とルーティング
      constants.ts    定数
      db.ts           コネクションプール
      http.ts         リクエストとレスポンスの共通処理
      auth/
        hash.ts       ハッシュと乱数
        onetime.ts    ワンタイムキー
        session.ts    セッション
      routes/
        auth.ts       prepare / signup
        user.ts       profile

    あとでRedisに差し替えるので`auth/onetime.ts`と`auth/session.ts`を独立させてます。

    定数

    // src/constants.ts
    
    /**
     * 認証手段の種別。将来 引き継ぎコード や SNS連携 が増える想定。
     * enum は型ストリップで動かないので as const のオブジェクトで表現する。
     */
    export const AUTH_TYPE = {
      DEVICE: 1,
    } as const;
    
    export type AuthType = (typeof AUTH_TYPE)[keyof typeof AUTH_TYPE];
    
    /** ワンタイムキー・セッショントークンの元データのバイト数。16進にすると64文字 */
    export const KEY_BYTES = 32;
    
    /** ワンタイムキーの有効期限(秒) */
    export const ONETIME_KEY_TTL_SECONDS = 300;
    
    /**
     * ワンタイムキーの発行からこの秒数が経つ前に使われたら、機械的なアクセスとみなして弾く。
     * created_at が DATETIME(秒単位)なので、判定の分解能も1秒。
     */
    export const ONETIME_KEY_MIN_ELAPSED_SECONDS = 1;
    
    /** セッショントークンの有効期限(秒) */
    export const SESSION_TTL_SECONDS = 60 * 60 * 24;
    
    /** 新規ユーザーの初期名。後ろに user_id を付ける */
    export const DEFAULT_USER_NAME_PREFIX = "プレイヤー";
    
    /** リクエストボディの上限。これを超えたら読まずに捨てる */
    export const REQUEST_BODY_LIMIT_BYTES = 8 * 1024;

    TypeScriptの`enum`を使っていないのは、この環境で動かないからです。

    Node.jsは型注釈を剥がしてそのまま実行しているだけなので、`enum`のように実行時のコードを生成する機能は動きません。
    `as const`のオブジェクトとユニオン型で同じことができるので、こちらで書いています。

    ハッシュ

    // src/auth/hash.ts
    import { createHmac, randomBytes } from "node:crypto";
    import { KEY_BYTES } from "../constants.ts";
    
    // 端末キー・トークン・ワンタイムキーは、生の値をDBに保存しない。
    // 保存するのも照合するのも、必ずここで作ったハッシュ。
    
    function requireSecret(): string {
      const secret = process.env.AUTH_HASH_SECRET;
      if (secret === undefined || secret === "") {
        throw new Error("環境変数 AUTH_HASH_SECRET が設定されていない");
      }
      return secret;
    }
    
    const secret: string = requireSecret();
    
    /** DBに保存する値を作る。sha256 の16進なので必ず64文字 */
    export function hashKey(raw: string): string {
      return createHmac("sha256", secret).update(raw).digest("hex");
    }
    
    /** 生成した値はクライアントにだけ渡す */
    export function generateKey(): string {
      return randomBytes(KEY_BYTES).toString("hex");
    }

    外部ライブラリは使っていません。
    ハッシュも乱数も、Node.jsの標準機能で足ります。

    `randomBytes`を使うのがポイントですね。
    `Math.random()`は予測できてしまうので、認証に使う値の生成には向きません。

    ワンタイムキー

    // src/auth/onetime.ts(抜粋)
    
    /** ワンタイムキーを発行する。DBに入るのはハッシュ、返すのは生のキー */
    export async function issueOnetimeKey(): Promise<OnetimeKey> {
      const key = generateKey();
      await userPool.execute(
        "INSERT INTO `auth_onetime` (`key_hash`, `expires_at`)" +
          " VALUES (?, DATE_ADD(NOW(), INTERVAL ? SECOND))",
        [hashKey(key), ONETIME_KEY_TTL_SECONDS],
      );
      return { key, expiresIn: ONETIME_KEY_TTL_SECONDS };
    }
    
    /**
     * ワンタイムキーを取得すると同時に削除する。
     *
     * 同じキーで並行して叩かれても1回しか成功しないよう、
     * トランザクション内で FOR UPDATE してロックしてから消す。
     */
    export async function consumeOnetimeKey(key: string): Promise<ConsumeResult> {
      const keyHash = hashKey(key);
      const conn = await userPool.getConnection();
      try {
        await conn.beginTransaction();
    
        const [rows] = await conn.execute<RowDataPacket[]>(
          "SELECT `expires_at` < NOW() AS `expired`," +
            " TIMESTAMPDIFF(SECOND, `created_at`, NOW()) < ? AS `too_fast`" +
            " FROM `auth_onetime` WHERE `key_hash` = ? FOR UPDATE",
          [ONETIME_KEY_MIN_ELAPSED_SECONDS, keyHash],
        );
    
        const row = rows[0];
        if (row === undefined) {
          await conn.rollback();
          return { ok: false, reason: "not_found" };
        }
    
        await conn.execute("DELETE FROM `auth_onetime` WHERE `key_hash` = ?", [keyHash]);
        await conn.commit();
    
        if (Number(row.expired) === 1) return { ok: false, reason: "expired" };
        if (Number(row.too_fast) === 1) return { ok: false, reason: "too_fast" };
        return { ok: true };
      } catch (error) {
        await conn.rollback();
        throw error;
      } finally {
        conn.release();
      }
    }

    ここが今回いちばん気をつけておきたいところです。
    取得と削除を、他の処理に割り込まれないようにやる必要があります。

    普通にSELECTしてからDELETEすると、その隙間に同じキーで別のリクエストが入ってきたとき、両方とも「キーがあった」と判断してしまいます。
    1回しか使えないはずのキーで2回通ってしまうわけですね。

    トランザクションの中で`FOR UPDATE`を付けてSELECTすると、その行にロックがかかります。
    片方が処理を終えるまで、もう片方は待たされる。
    待たされた側が見にいったときには、もう行は消えている。
    これで1回しか通りません。

    もうひとつ、時刻の比較を全部データベース側でやっているのも意図があります。

    `expires_at < NOW()`も`TIMESTAMPDIFF`も、判定しているのはMySQLです。
    アプリ側で`new Date()`と比べる書き方もできますが、そうするとアプリのコンテナとDBのコンテナで時計がずれたときに判定が変わってしまいます。
    片方だけ時刻がずれる、というのは実際に起こりますからね。

    セッション

    // src/auth/session.ts(抜粋)
    
    /** トークンから user_id を引く。存在しない・期限切れはどちらも null */
    export async function resolveUserId(token: string): Promise<number | null> {
      const [rows] = await userPool.execute<RowDataPacket[]>(
        "SELECT `user_id` FROM `user_session`" +
          " WHERE `token_hash` = ? AND `expires_at` > NOW()",
        [hashKey(token)],
      );
      const row = rows[0];
      return row === undefined ? null : Number(row.user_id);
    }
    
    /**
     * 全APIが通る認証。Authorization ヘッダから user_id を解決する。
     * 認証が要るハンドラはこの1関数だけを呼ぶ。
     */
    export async function authenticate(req: IncomingMessage): Promise<number | null> {
      const header = req.headers.authorization;
      if (header === undefined) return null;
    
      const matched = /^Bearer\s+(\S+)$/.exec(header);
      if (matched === null) return null;
    
      return resolveUserId(matched[1]);
    }

    `authenticate`は、これから作る全部のAPIが最初に呼ぶ関数です。

    ここを各ハンドラに書き散らすと、いつか書き忘れます。
    書き忘れたAPIは認証なしで叩けてしまう。
    だから1箇所にまとめておきます。

    signup

    // src/routes/auth.ts(抜粋)
    
    /** POST /auth/signup — ワンタイムキーと端末キーで、アカウント作成またはログイン */
    export async function handleSignup(
      req: IncomingMessage,
      res: ServerResponse,
    ): Promise<void> {
      const body = await readJsonBody(req);
      const onetimeKey = readStringField(body, "onetime_key");
      const deviceKey = readStringField(body, "device_key");
      if (onetimeKey === null || deviceKey === null) {
        sendError(res, 400, "INVALID_REQUEST", "onetime_key と device_key は必須");
        return;
      }
    
      const consumed = await consumeOnetimeKey(onetimeKey);
      if (!consumed.ok) {
        sendError(res, 400, "INVALID_ONETIME_KEY", `ワンタイムキーが使えない (${consumed.reason})`);
        return;
      }
    
      const login = await loginOrCreateUser(hashKey(deviceKey));
      const session = await issueToken(login.userId);
    
      sendJson(res, 200, {
        user_id: login.userId,
        token: session.token,
        is_new: login.isNew,
      });
    }
    
    /** 端末キーのハッシュでユーザーを引き、いなければ作る */
    async function loginOrCreateUser(deviceKeyHash: string): Promise<LoginResult> {
      const existing = await findUserIdByDeviceKey(deviceKeyHash);
      if (existing !== null) {
        await touchLastLoginAt(existing);
        return { userId: existing, isNew: false };
      }
    
      try {
        return { userId: await createUser(deviceKeyHash), isNew: true };
      } catch (error) {
        // 同じ device_key で並行して叩かれると、uk_auth に弾かれた側がここに来る。
        // エラーにはせず、先に作られた行を読み直してログイン扱いにする
        if (!isDuplicateEntry(error)) throw error;
    
        const raced = await findUserIdByDeviceKey(deviceKeyHash);
        if (raced === null) throw error;
    
        await touchLastLoginAt(raced);
        return { userId: raced, isNew: false };
      }
    }

    `loginOrCreateUser`が、前回話した
    「signupがログインを兼ねている」の実体です。
    端末キーで探して、いればその人、いなければ作る。

    そして`catch`のところ。

    同じ端末から2回同時にsignupが来ると、両方とも「まだいない」と判断して、両方が作りにいきます。
    先に確認してから作る、という書き方では防げません。
    確認と作成の間に隙間があるので。

    止めているのはuser_authのユニーク制約です。
    「同じ端末キーは1行だけ」とデータベース側で決めてあるので、後から来たほうのINSERTは必ず失敗します。

    MySQLならER_DUP_ENTRYが返ってきますね。
    ただ、これをそのままエラーとして返すのは違います。
    ユーザーからすれば普通に起動しただけなので。

    なのでcatchでER_DUP_ENTRYだけを拾って、もう一度SELECTし直します。
    そのとき既に先行した処理がコミットを終えているので、今度はちゃんと見つかる。
    あとは通常のログインと同じ扱いで返します。
    他のエラーは握りつぶさず、そのまま投げ直すのが大事ですね。

    「無いことを確認してから作る」は、同時に来たら通用しません。
    確認とINSERTの間に必ず隙間があるので。
    ここに限らず、在庫の引き当てとか予約枠の確保とか、同じ形の問題はあちこちに出てきます。

    事前チェックで防ぐのではなく、一意制約で弾かせて、弾かれたら拾う。
    慣れるまでは気持ち悪いんですが、これが確実です。

    ユーザー作成

    /** user と user_auth をまとめて作る。片方だけ残らないよう1トランザクションで行う */
    async function createUser(deviceKeyHash: string): Promise<number> {
      const conn = await userPool.getConnection();
      try {
        await conn.beginTransaction();
    
        // 初期名は user_id が決まらないと作れないので、採番してから入れ直す
        const [inserted] = await conn.execute<ResultSetHeader>(
          "INSERT INTO `user` (`name`) VALUES ('')",
        );
        const userId = inserted.insertId;
    
        await conn.execute("UPDATE `user` SET `name` = ? WHERE `id` = ?", [
          `${DEFAULT_USER_NAME_PREFIX}${userId}`,
          userId,
        ]);
    
        await conn.execute(
          "INSERT INTO `user_auth` (`user_id`, `auth_type`, `auth_key_hash`) VALUES (?, ?, ?)",
          [userId, AUTH_TYPE.DEVICE, deviceKeyHash],
        );
    
        await conn.commit();
        return userId;
      } catch (error) {
        await conn.rollback();
        throw error;
      } finally {
        conn.release();
      }
    }

    `user`と`user_auth`を1トランザクションにしています。

    `user`だけあって`user_auth`が無いと、そのアカウントには二度とログインできません。
    誰のものでもないユーザーが1行、永久に残ります。

    ユーザーデータは消せないので、こういうゴミが後から効いてきます。

    ルーティング

    // src/index.ts
    import { createServer } from "node:http";
    import type { IncomingMessage, ServerResponse } from "node:http";
    import { handlePrepare, handleSignup } from "./routes/auth.ts";
    import { handleProfile } from "./routes/user.ts";
    import { sendError } from "./http.ts";
    
    type Handler = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
    
    // ルーティングは「メソッド + パス」の完全一致で引く。
    const routes: Record<string, Handler> = {
      "POST /auth/prepare": handlePrepare,
      "POST /auth/signup": handleSignup,
      "GET /user/profile": handleProfile,
    };
    
    const port = Number(process.env.PORT ?? 3000);
    
    const server = createServer((req, res) => {
      const path = (req.url ?? "/").split("?")[0];
      const handler = routes[`${req.method} ${path}`];
    
      if (handler === undefined) {
        sendError(res, 404, "NOT_FOUND", `${req.method} ${path} は存在しない`);
        return;
      }
    
      // ハンドラ内で投げられた例外はここで拾う。中身はクライアントに返さない
      handler(req, res).catch((error: unknown) => {
        console.error(error);
        if (res.headersSent) {
          res.end();
          return;
        }
        sendError(res, 500, "INTERNAL_ERROR", "サーバー内部エラー");
      });
    });
    
    server.listen(port, () => {
      console.log(`listening on http://localhost:${port}`);
    });

    フレームワークは使っていません。
    メソッドとパスの組み合わせでハンドラを引くだけです。

    `catch`のところが地味に大事ですね。
    ハンドラの中で例外が出たとき、それをそのままクライアントに返すと
    SQLの中身やファイルパスが漏れます。
    ログには出して、返すのは「内部エラー」だけ。

    動かす

    $ curl -s -X POST http://localhost:3000/auth/prepare
    {"onetime_key":"38227bac990aaa0298eff5a484e6aed...","expires_in":300}

    ワンタイムキーが返ってきました。この瞬間、データベースにはハッシュが1行入っています。

    mysql> select * from auth_onetime;
    +------------------------------------------------------------------+---------------------+---------------------+
    | key_hash                                                         | expires_at          | created_at          |
    +------------------------------------------------------------------+---------------------+---------------------+
    | ac01c5ddfcaf8a89418142804a0f1ccffb9a88884d9cd84e5896f8fdbe97c154 | 2026-08-17 23:37:19 | 2026-08-17 23:32:19 |
    +------------------------------------------------------------------+---------------------+---------------------+

    このキーを使ってアカウントを作ります。

    $ curl -s -X POST http://localhost:3000/auth/signup \
      -H "Content-Type: application/json" \
      -d '{"onetime_key":"38227bac990aaa0298eff5a484e...","device_key":"test-device-001"}'
    {"user_id":4,"token":"fd46a88010c0...","is_new":true}

    できました。`is_new`が`true`なので新規作成ですね。

    トークンで自分の情報を取ってみます。

    $ curl -s http://localhost:3000/user/profile \
      -H "Authorization: Bearer fd46a88010c0..."
    {"user_id":4,"name":"プレイヤー4","created_at":"2026-08-15 00:39:31"}

    でたらめなトークンだと弾かれます。

    $ curl -s http://localhost:3000/user/profile -H "Authorization: Bearer dummy"
    {"error":{"code":"UNAUTHORIZED","message":"トークンが無効か、期限切れ"}}

    同じキーは二度使えない

    さっき使ったワンタイムキーをもう一度送ってみます。

    $ curl -s -X POST http://localhost:3000/auth/signup \
      -H "Content-Type: application/json" \
      -d '{"onetime_key":"38227bac990aaa0298eff5a484e...","device_key":"test-device-001"}'
    {"error":{"code":"INVALID_ONETIME_KEY","message":"ワンタイムキーが使えない (not_found)"}}

    消えているので通りません。

    2回目の起動を再現する

    新しくprepareを叩いて、同じ端末キーでsignupします。
    ゲームを再起動したときと同じ動きですね。

    $ curl -s -X POST http://localhost:3000/auth/prepare
    {"onetime_key":"f6823d08d373...","expires_in":300}
    
    $ curl -s -X POST http://localhost:3000/auth/signup \
      -H "Content-Type: application/json" \
      -d '{"onetime_key":"f6823d08d373...","device_key":"test-device-001"}'
    {"user_id":4,"token":"5c8fe99255b7...","is_new":false}

    `user_id`は4のまま、`is_new`が`false`になりました。

    新しいアカウントは作られず、同じ人としてログインしています。
    トークンだけが新しくなっていますね。
    signupがログインを兼ねている、というのはこういうことです。

    中身を見る

    データベースを覗いてみます。

    mysql> select * from user;
    +----+--------------+---------------------+---------------------+
    | id | name         | created_at          | last_login_at       |
    +----+--------------+---------------------+---------------------+
    |  1 | プレイヤー1  | 2026-08-15 00:18:47 | 2026-08-15 00:18:49 |
    |  2 | プレイヤー2  | 2026-08-15 00:18:51 | 2026-08-15 00:18:51 |
    |  4 | プレイヤー4  | 2026-08-15 00:39:31 | 2026-08-15 00:47:02 |
    +----+--------------+---------------------+---------------------+

    ちなみに日本語が `?????1` のように化けて見えたら、
    データではなく接続時の文字コードの問題です。
    こう入り直すと読めます。

    docker compose exec db mysql --default-character-set=utf8mb4 -ugameuser -p

    化けているのか本当に壊れているのかは、`HEX()` で見れば分かりますね。

    mysql> SELECT id, HEX(name) FROM user WHERE id = 4;
    +----+----------------------------------+
    | id | HEX(name)                        |
    +----+----------------------------------+
    |  4 | E38397E383ACE382A4E383A4E383BC34 |
    +----+----------------------------------+

    `E38397` から始まるのはUTF-8の「プ」なので、
    保存は正しくできています。

    認証のほうを見てみます。

    mysql> select * from user_auth;
    +----+---------+-----------+------------------------------------------------------------------+---------------------+
    | id | user_id | auth_type | auth_key_hash                                                    | created_at          |
    +----+---------+-----------+------------------------------------------------------------------+---------------------+
    |  1 |       1 |         1 | 820e61f32366c240c8878a4921426517141f851eb0986cdde75d9e3224847769 | 2026-08-15 00:18:47 |
    |  2 |       2 |         1 | ddf75ef23b3aa1aad9eee9cffa5e7c6164a3f900d258d9599205b99136176a10 | 2026-08-15 00:18:51 |
    |  4 |       4 |         1 | 36f2cd8be2115dd084a20636b369270c12c678ad523a08b6ec883e04772fe2f0 | 2026-08-15 00:39:31 |
    +----+---------+-----------+------------------------------------------------------------------+---------------------+

    `auth_key_hash`に入っているのは64桁の英数字だけです。
    送った`test-device-001`という文字列は、どこにも入っていません。

    mysql> select * from user_session;
    +------------------------------------------------------------------+---------+---------------------+---------------------+
    | token_hash                                                       | user_id | expires_at          | created_at          |
    +------------------------------------------------------------------+---------+---------------------+---------------------+
    | 316f8258bdfac3a524ea45904b74383ab70a9eaf1a5b9083937b09a3e531a06c |       1 | 2026-08-16 00:18:47 | 2026-08-15 00:18:47 |
    | 5716fcb3afcaa404625c313a733cfcb9e7681b8bbe5d86651cc6a130c294ebbb |       4 | 2026-08-16 00:47:02 | 2026-08-15 00:47:02 |
    | 7f753396b3a94d69e21f27d95f20314f1b5980efc548b517f9500d08fe6a34c3 |       1 | 2026-08-16 00:18:49 | 2026-08-15 00:18:49 |
    | c81a847cddf06d22ef07467b5e76a2c3708a66d960bfabd84c40a04fd9f7e03e |       4 | 2026-08-16 00:39:31 | 2026-08-15 00:39:31 |
    | d83a70112bf32f6994dd4d66339bef47a9e5689758f3935dab06b4cc3c3f8a7e |       2 | 2026-08-16 00:18:51 | 2026-08-15 00:18:51 |
    | e44e528a1791610288fedd9fad30a6bfad39fbff793c9e7927f0477579aad14c |       2 | 2026-08-16 00:18:51 | 2026-08-15 00:18:51 |
    +------------------------------------------------------------------+---------+---------------------+---------------------+
    6 rows in set (0.00 sec)

    トークンも同じですね。
    クライアントに渡した文字列そのものは保存されていません。
    照合するときは、送られてきた値をハッシュ化して比べるだけなので、これで足ります。

    もしデータベースの中身が外に出たとしても、この状態なら成りすましには使えない。
    そういう作りです。

    セッションが溜まっていく

    ところで、さっきの`user_session`は6行ありました。
    ユーザーは3人しかいないのに。

    signupを叩くたびに1行増えて、古いトークンも期限が切れるまで残っているからですね。

    このまま運用すると、テーブルが際限なく膨らみます。
    期限切れのレコードを定期的に消す仕組みが要りますね。
    ワンタイムキーのほうも、signupされずに放置されたキーが残り続けます。

    最初に暫定と書いたのはこのことです。
    Redisなら有効期限を設定できるので、切れたものは勝手に消えます。
    掃除の仕組みを自分で作らなくて済むんですね。

    今回はここまで

    • アカウントが作れるようになった

    • 同じ端末なら同じアカウントに戻る

    • トークンでAPIが叩ける

    • 鍵はすべてハッシュで保存されている

    これでようやく「誰のデータか」が決まりました。
    ユーザーデータを作る準備ができたというところでしょうか。

    次回はセッションまわりをRedisに移そうと思います。

    【最後まで読んでいただきありがとうございます!】
    面白かったと感じた方は、ぜひ「スキ」と「フォロー」をお願いします!

    コード

    今回の記事で作ったコードです、興味のある方はどうぞ。

    src/constants.ts

    // マジックナンバーはここに集約する。各ファイルに散らさない。
    
    /**
     * 認証手段の種別。将来 引き継ぎコード や SNS連携 が増える想定。
     * enum は型ストリップで動かないので as const のオブジェクトで表現する。
     */
    export const AUTH_TYPE = {
      DEVICE: 1,
    } as const;
    
    export type AuthType = (typeof AUTH_TYPE)[keyof typeof AUTH_TYPE];
    
    /** ワンタイムキー・セッショントークンの元データのバイト数。16進にすると64文字 */
    export const KEY_BYTES = 32;
    
    /** ワンタイムキーの有効期限(秒) */
    export const ONETIME_KEY_TTL_SECONDS = 300;
    
    /**
     * ワンタイムキーの発行からこの秒数が経つ前に使われたら、機械的なアクセスとみなして弾く。
     * created_at が DATETIME(秒単位)なので、判定の分解能も1秒。
     */
    export const ONETIME_KEY_MIN_ELAPSED_SECONDS = 1;
    
    /** セッショントークンの有効期限(秒) */
    export const SESSION_TTL_SECONDS = 60 * 60 * 24;
    
    /** 新規ユーザーの初期名。後ろに user_id を付ける。一意である必要はない */
    export const DEFAULT_USER_NAME_PREFIX = "プレイヤー";
    
    /** リクエストボディの上限。これを超えたら読まずに捨てる */
    export const REQUEST_BODY_LIMIT_BYTES = 8 * 1024;

    src/db.ts

    import mysql from "mysql2/promise";
    import type { Pool } from "mysql2/promise";
    
    // DBは用途ごとに分かれている。プールもDBごとに作り、DBをまたぐJOINは書かない。
    
    function requireEnv(name: string): string {
      const value = process.env[name];
      if (value === undefined || value === "") {
        throw new Error(`環境変数 ${name} が設定されていない`);
      }
      return value;
    }
    
    function createPool(database: string): Pool {
      return mysql.createPool({
        host: requireEnv("DB_HOST"),
        port: Number(requireEnv("DB_PORT")),
        user: requireEnv("DB_USER"),
        password: requireEnv("DB_PASSWORD"),
        database,
        connectionLimit: 10,
        // DATETIME は文字列のまま受け取る。Date に変換させるとタイムゾーンでずれる
        dateStrings: true,
      });
    }
    
    /** ユーザーデータ。1行も消せないDB */
    export const userPool = createPool(requireEnv("DB_NAME_USER"));

    src/http.ts

    import type { IncomingMessage, ServerResponse } from "node:http";
    import { REQUEST_BODY_LIMIT_BYTES } from "./constants.ts";
    
    // リクエストとレスポンスの素材。node:http のまま扱うので薄くしておく。
    
    export function sendJson(res: ServerResponse, status: number, body: unknown): void {
      res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
      res.end(JSON.stringify(body));
    }
    
    /**
     * エラーレスポンスの形は全APIで揃える。
     * message は開発時の確認用で、クライアントに見せる文言ではない。
     */
    export function sendError(
      res: ServerResponse,
      status: number,
      code: string,
      message: string,
    ): void {
      sendJson(res, status, { error: { code, message } });
    }
    
    /** JSONボディを読む。壊れている・空・大きすぎる場合は null */
    export function readJsonBody(req: IncomingMessage): Promise<unknown> {
      return new Promise((resolve) => {
        const chunks: Buffer[] = [];
        let size = 0;
        let done = false;
    
        const finish = (value: unknown) => {
          if (done) return;
          done = true;
          resolve(value);
        };
    
        req.on("data", (chunk: Buffer) => {
          size += chunk.length;
          if (size > REQUEST_BODY_LIMIT_BYTES) {
            finish(null);
            return;
          }
          chunks.push(chunk);
        });
    
        req.on("end", () => {
          const raw = Buffer.concat(chunks).toString("utf8");
          if (raw === "") {
            finish(null);
            return;
          }
          try {
            finish(JSON.parse(raw));
          } catch {
            finish(null);
          }
        });
    
        req.on("error", () => finish(null));
      });
    }
    
    /**
     * ボディから文字列のフィールドを取り出す。型が違えば null。
     * クライアントから来た値はそのまま使わず、必ずここを通す。
     */
    export function readStringField(body: unknown, key: string): string | null {
      if (typeof body !== "object" || body === null) return null;
      const value = (body as Record<string, unknown>)[key];
      if (typeof value !== "string" || value === "") return null;
      return value;
    }

    src/auth/hash.ts

    import { createHmac, randomBytes } from "node:crypto";
    import { KEY_BYTES } from "../constants.ts";
    
    // 端末キー・トークン・ワンタイムキーは、生の値をDBに保存しない。
    // 保存するのも照合するのも、必ずここで作ったハッシュ。
    
    function requireSecret(): string {
      const secret = process.env.AUTH_HASH_SECRET;
      if (secret === undefined || secret === "") {
        throw new Error("環境変数 AUTH_HASH_SECRET が設定されていない");
      }
      return secret;
    }
    
    const secret: string = requireSecret();
    
    /** DBに保存する値を作る。sha256 の16進なので必ず64文字(CHAR(64)に収まる) */
    export function hashKey(raw: string): string {
      return createHmac("sha256", secret).update(raw).digest("hex");
    }
    
    /** ワンタイムキー・セッショントークンの生成。返すのは生の値で、これはクライアントにだけ渡す */
    export function generateKey(): string {
      return randomBytes(KEY_BYTES).toString("hex");
    }

    src/auth/onetime.ts

    import type { RowDataPacket } from "mysql2/promise";
    import { userPool } from "../db.ts";
    import { generateKey, hashKey } from "./hash.ts";
    import {
      ONETIME_KEY_MIN_ELAPSED_SECONDS,
      ONETIME_KEY_TTL_SECONDS,
    } from "../constants.ts";
    
    // auth_onetime の読み書きはこのモジュールに閉じる。
    // あとで Redis に移すので、SQL をここから外に漏らさない。
    
    export type OnetimeKey = {
      key: string;
      expiresIn: number;
    };
    
    export type ConsumeResult =
      | { ok: true }
      | { ok: false; reason: "not_found" | "expired" | "too_fast" };
    
    /** ワンタイムキーを発行する。DBに入るのはハッシュ、返すのは生のキー */
    export async function issueOnetimeKey(): Promise<OnetimeKey> {
      const key = generateKey();
      await userPool.execute(
        "INSERT INTO `auth_onetime` (`key_hash`, `expires_at`)" +
          " VALUES (?, DATE_ADD(NOW(), INTERVAL ? SECOND))",
        [hashKey(key), ONETIME_KEY_TTL_SECONDS],
      );
      return { key, expiresIn: ONETIME_KEY_TTL_SECONDS };
    }
    
    /**
     * ワンタイムキーを取得すると同時に削除する。
     *
     * 同じキーで並行して叩かれても1回しか成功しないよう、
     * トランザクション内で FOR UPDATE してロックしてから消す。
     * 期限切れ・発行直後のキーも、見つかった時点で消す(残しても使い道がない)。
     *
     * 時刻の比較はすべてDB側で行う。アプリとDBで時計がずれても判定が変わらないようにするため。
     */
    export async function consumeOnetimeKey(key: string): Promise<ConsumeResult> {
      const keyHash = hashKey(key);
      const conn = await userPool.getConnection();
      try {
        await conn.beginTransaction();
    
        const [rows] = await conn.execute<RowDataPacket[]>(
          "SELECT `expires_at` < NOW() AS `expired`," +
            " TIMESTAMPDIFF(SECOND, `created_at`, NOW()) < ? AS `too_fast`" +
            " FROM `auth_onetime` WHERE `key_hash` = ? FOR UPDATE",
          [ONETIME_KEY_MIN_ELAPSED_SECONDS, keyHash],
        );
    
        const row = rows[0];
        if (row === undefined) {
          await conn.rollback();
          return { ok: false, reason: "not_found" };
        }
    
        await conn.execute("DELETE FROM `auth_onetime` WHERE `key_hash` = ?", [keyHash]);
        await conn.commit();
    
        if (Number(row.expired) === 1) return { ok: false, reason: "expired" };
        if (Number(row.too_fast) === 1) return { ok: false, reason: "too_fast" };
        return { ok: true };
      } catch (error) {
        await conn.rollback();
        throw error;
      } finally {
        conn.release();
      }
    }

    src/auth/session.ts

    import type { IncomingMessage } from "node:http";
    import type { RowDataPacket } from "mysql2/promise";
    import { userPool } from "../db.ts";
    import { generateKey, hashKey } from "./hash.ts";
    import { SESSION_TTL_SECONDS } from "../constants.ts";
    
    // user_session の読み書きはこのモジュールに閉じる。
    // あとで Redis に移すので、SQL をここから外に漏らさない。
    
    export type Session = {
      token: string;
      expiresIn: number;
    };
    
    /** セッショントークンを発行する。DBに入るのはハッシュ、返すのは生のトークン */
    export async function issueToken(userId: number): Promise<Session> {
      const token = generateKey();
      await userPool.execute(
        "INSERT INTO `user_session` (`token_hash`, `user_id`, `expires_at`)" +
          " VALUES (?, ?, DATE_ADD(NOW(), INTERVAL ? SECOND))",
        [hashKey(token), userId, SESSION_TTL_SECONDS],
      );
      return { token, expiresIn: SESSION_TTL_SECONDS };
    }
    
    /** トークンから user_id を引く。存在しない・期限切れはどちらも null */
    export async function resolveUserId(token: string): Promise<number | null> {
      const [rows] = await userPool.execute<RowDataPacket[]>(
        "SELECT `user_id` FROM `user_session`" +
          " WHERE `token_hash` = ? AND `expires_at` > NOW()",
        [hashKey(token)],
      );
      const row = rows[0];
      return row === undefined ? null : Number(row.user_id);
    }
    
    /**
     * 全APIが通る認証。Authorization ヘッダから user_id を解決する。
     * 認証が要るハンドラはこの1関数だけを呼ぶ。
     */
    export async function authenticate(req: IncomingMessage): Promise<number | null> {
      const header = req.headers.authorization;
      if (header === undefined) return null;
    
      const matched = /^Bearer\s+(\S+)$/.exec(header);
      if (matched === null) return null;
    
      return resolveUserId(matched[1]);
    }

    src/routes/auth.ts

    import type { IncomingMessage, ServerResponse } from "node:http";
    import type { ResultSetHeader, RowDataPacket } from "mysql2/promise";
    import { userPool } from "../db.ts";
    import { hashKey } from "../auth/hash.ts";
    import { consumeOnetimeKey, issueOnetimeKey } from "../auth/onetime.ts";
    import { issueToken } from "../auth/session.ts";
    import { AUTH_TYPE, DEFAULT_USER_NAME_PREFIX } from "../constants.ts";
    import { readJsonBody, readStringField, sendError, sendJson } from "../http.ts";
    
    /** POST /auth/prepare — ワンタイムキーを発行する */
    export async function handlePrepare(
      _req: IncomingMessage,
      res: ServerResponse,
    ): Promise<void> {
      // TODO: レート制限はここに差し込む(IP単位で発行回数を絞る)。今回は実装しない
      const onetime = await issueOnetimeKey();
      sendJson(res, 200, {
        onetime_key: onetime.key,
        expires_in: onetime.expiresIn,
      });
    }
    
    /** POST /auth/signup — ワンタイムキーと端末キーで、アカウント作成またはログイン */
    export async function handleSignup(
      req: IncomingMessage,
      res: ServerResponse,
    ): Promise<void> {
      const body = await readJsonBody(req);
      const onetimeKey = readStringField(body, "onetime_key");
      const deviceKey = readStringField(body, "device_key");
      if (onetimeKey === null || deviceKey === null) {
        sendError(res, 400, "INVALID_REQUEST", "onetime_key と device_key は必須");
        return;
      }
    
      const consumed = await consumeOnetimeKey(onetimeKey);
      if (!consumed.ok) {
        sendError(res, 400, "INVALID_ONETIME_KEY", `ワンタイムキーが使えない (${consumed.reason})`);
        return;
      }
    
      const login = await loginOrCreateUser(hashKey(deviceKey));
      const session = await issueToken(login.userId);
    
      sendJson(res, 200, {
        user_id: login.userId,
        token: session.token,
        is_new: login.isNew,
      });
    }
    
    type LoginResult = {
      userId: number;
      isNew: boolean;
    };
    
    /** 端末キーのハッシュでユーザーを引き、いなければ作る */
    async function loginOrCreateUser(deviceKeyHash: string): Promise<LoginResult> {
      const existing = await findUserIdByDeviceKey(deviceKeyHash);
      if (existing !== null) {
        await touchLastLoginAt(existing);
        return { userId: existing, isNew: false };
      }
    
      try {
        return { userId: await createUser(deviceKeyHash), isNew: true };
      } catch (error) {
        // 同じ device_key で並行して叩かれると、uk_auth に弾かれた側がここに来る。
        // エラーにはせず、先に作られた行を読み直してログイン扱いにする
        if (!isDuplicateEntry(error)) throw error;
    
        const raced = await findUserIdByDeviceKey(deviceKeyHash);
        if (raced === null) throw error;
    
        await touchLastLoginAt(raced);
        return { userId: raced, isNew: false };
      }
    }
    
    function isDuplicateEntry(error: unknown): boolean {
      if (typeof error !== "object" || error === null) return false;
      return (error as { code?: string }).code === "ER_DUP_ENTRY";
    }
    
    async function findUserIdByDeviceKey(deviceKeyHash: string): Promise<number | null> {
      const [rows] = await userPool.execute<RowDataPacket[]>(
        "SELECT `user_id` FROM `user_auth` WHERE `auth_type` = ? AND `auth_key_hash` = ?",
        [AUTH_TYPE.DEVICE, deviceKeyHash],
      );
      const row = rows[0];
      return row === undefined ? null : Number(row.user_id);
    }
    
    async function touchLastLoginAt(userId: number): Promise<void> {
      await userPool.execute("UPDATE `user` SET `last_login_at` = NOW() WHERE `id` = ?", [
        userId,
      ]);
    }
    
    /** user と user_auth をまとめて作る。片方だけ残らないよう1トランザクションで行う */
    async function createUser(deviceKeyHash: string): Promise<number> {
      const conn = await userPool.getConnection();
      try {
        await conn.beginTransaction();
    
        // 初期名は user_id が決まらないと作れないので、採番してから入れ直す
        const [inserted] = await conn.execute<ResultSetHeader>(
          "INSERT INTO `user` (`name`) VALUES ('')",
        );
        const userId = inserted.insertId;
    
        await conn.execute("UPDATE `user` SET `name` = ? WHERE `id` = ?", [
          `${DEFAULT_USER_NAME_PREFIX}${userId}`,
          userId,
        ]);
    
        await conn.execute(
          "INSERT INTO `user_auth` (`user_id`, `auth_type`, `auth_key_hash`) VALUES (?, ?, ?)",
          [userId, AUTH_TYPE.DEVICE, deviceKeyHash],
        );
    
        await conn.commit();
        return userId;
      } catch (error) {
        await conn.rollback();
        throw error;
      } finally {
        conn.release();
      }
    }

    src/routes/user.ts

    import type { IncomingMessage, ServerResponse } from "node:http";
    import type { RowDataPacket } from "mysql2/promise";
    import { userPool } from "../db.ts";
    import { authenticate } from "../auth/session.ts";
    import { sendError, sendJson } from "../http.ts";
    
    /** GET /user/profile — トークンで認証して、自分の情報を返す */
    export async function handleProfile(
      req: IncomingMessage,
      res: ServerResponse,
    ): Promise<void> {
      const userId = await authenticate(req);
      if (userId === null) {
        sendError(res, 401, "UNAUTHORIZED", "トークンが無効か、期限切れ");
        return;
      }
    
      const [rows] = await userPool.execute<RowDataPacket[]>(
        "SELECT `id`, `name`, `created_at` FROM `user` WHERE `id` = ?",
        [userId],
      );
      const row = rows[0];
      if (row === undefined) {
        // セッションは生きているのにユーザーがいない。通常は起きない
        sendError(res, 401, "UNAUTHORIZED", "ユーザーが存在しない");
        return;
      }
    
      sendJson(res, 200, {
        user_id: Number(row.id),
        name: row.name,
        created_at: row.created_at,
      });
    }

    src/index.ts

    import { createServer } from "node:http";
    import type { IncomingMessage, ServerResponse } from "node:http";
    import { handlePrepare, handleSignup } from "./routes/auth.ts";
    import { handleProfile } from "./routes/user.ts";
    import { sendError } from "./http.ts";
    
    type Handler = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
    
    // ルーティングは「メソッド + パス」の完全一致で引く。
    // パスにパラメータが必要になるまでは、これで足りる。
    const routes: Record<string, Handler> = {
      "POST /auth/prepare": handlePrepare,
      "POST /auth/signup": handleSignup,
      "GET /user/profile": handleProfile,
    };
    
    const port = Number(process.env.PORT ?? 3000);
    
    const server = createServer((req, res) => {
      const path = (req.url ?? "/").split("?")[0];
      const handler = routes[`${req.method} ${path}`];
    
      if (handler === undefined) {
        sendError(res, 404, "NOT_FOUND", `${req.method} ${path} は存在しない`);
        return;
      }
    
      // ハンドラ内で投げられた例外はここで拾う。中身はクライアントに返さない
      handler(req, res).catch((error: unknown) => {
        console.error(error);
        if (res.headersSent) {
          res.end();
          return;
        }
        sendError(res, 500, "INTERNAL_ERROR", "サーバー内部エラー");
      });
    });
    
    server.listen(port, () => {
      console.log(`listening on http://localhost:${port}`);
    });


     
     
    泥臭い現場のリアルを語る現役エンジニア ゲーム開発歴30年。会社員・フリーランスの両方で修羅場をくぐり抜けてきた50代現役サーバプログラマです

    あなたへのおすすめ