@takosjp/yurucommu-core 3.0.0

package/src/backend/lib/oauth-providers.ts

@@ -0,0 +1,324 @@
+/**
+ * OAuth Provider Configuration
+ *
+ * 環境変数に設定されたプロバイダーのみ有効になる
+ * 複数のプロバイダーを自由に組み合わせ可能
+ */
+
+import type { Env } from "../types.ts";
+
+export interface OAuthProvider {
+  id: string;
+  name: string;
+  icon: string;
+  authorizeUrl: string;
+  tokenUrl: string;
+  userInfoUrl: string;
+  scopes: string[];
+  // PKCE対応
+  supportsPkce: boolean;
+  // For OIDC providers (Takosumi Accounts): the issuer origin + JWKS endpoint,
+  // used to verify the ID Token signature + claims in the login callback. Absent
+  // for plain OAuth2 providers (e.g. X) that issue no OIDC ID Token.
+  issuer?: string;
+  jwksUrl?: string;
+}
+
+export interface AuthConfig {
+  passwordEnabled: boolean;
+  providers: OAuthProvider[];
+}
+
+function envValue(env: Env, key: keyof Env): string | undefined {
+  const value = env[key];
+  return typeof value === "string" && value.trim() !== ""
+    ? value.trim()
+    : undefined;
+}
+
+export function getOidcIssuerUrl(env: Env): string | null {
+  return (
+    envValue(env, "OIDC_ISSUER_URL") ??
+    envValue(env, "OAUTH_ISSUER_URL") ??
+    envValue(env, "TAKOSUMI_ACCOUNTS_ISSUER_URL") ??
+    null
+  );
+}
+
+export function getOidcClientCredentials(env: Env): {
+  clientId: string;
+  clientSecret: string;
+} {
+  return {
+    clientId:
+      envValue(env, "OIDC_CLIENT_ID") ??
+      envValue(env, "TAKOSUMI_ACCOUNTS_CLIENT_ID") ??
+      "",
+    clientSecret:
+      envValue(env, "OIDC_CLIENT_SECRET") ??
+      envValue(env, "TAKOSUMI_ACCOUNTS_CLIENT_SECRET") ??
+      "",
+  };
+}
+
+export function issuerEndpoint(issuer: string, path: string): string {
+  return `${issuer.replace(/\/$/, "")}${path}`;
+}
+
+/**
+ * 環境変数から有効な認証方法を取得
+ */
+export function getAuthConfig(env: Env): AuthConfig {
+  const providers: OAuthProvider[] = [];
+
+  // Google OAuth
+  if (env.GOOGLE_CLIENT_ID && env.GOOGLE_CLIENT_SECRET) {
+    providers.push({
+      id: "google",
+      name: "Google",
+      icon: "/icons/google.svg",
+      authorizeUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+      tokenUrl: "https://oauth2.googleapis.com/token",
+      userInfoUrl: "https://www.googleapis.com/oauth2/v2/userinfo",
+      scopes: ["openid", "profile", "email"],
+      supportsPkce: true,
+    });
+  }
+
+  // X (Twitter) OAuth 2.0
+  if (env.X_CLIENT_ID && env.X_CLIENT_SECRET) {
+    providers.push({
+      id: "x",
+      name: "X",
+      icon: "/icons/x.svg",
+      authorizeUrl: "https://twitter.com/i/oauth2/authorize",
+      tokenUrl: "https://api.twitter.com/2/oauth2/token",
+      userInfoUrl: "https://api.twitter.com/2/users/me",
+      scopes: ["tweet.read", "users.read", "offline.access"],
+      supportsPkce: true,
+    });
+  }
+
+  // Takosumi Accounts OIDC. The client SECRET is optional: when Takosumi
+  // materializes the OIDC client for an auto-provisioned Capsule it mints a
+  // PUBLIC client (token_endpoint_auth_method "none", PKCE-only, no secret — the
+  // service-graph resolve path can't deliver a confidential secret). A confidential
+  // client (secret set) also works. Either way PKCE-S256 protects the exchange,
+  // so issuer + client_id are sufficient to offer the provider.
+  const oidcIssuer = getOidcIssuerUrl(env);
+  const { clientId: oidcClientId } = getOidcClientCredentials(env);
+  if (oidcIssuer && oidcClientId) {
+    providers.push({
+      id: "takos",
+      name: "Takosumi Accounts",
+      icon: "/icons/takos.svg",
+      authorizeUrl: issuerEndpoint(oidcIssuer, "/oauth/authorize"),
+      tokenUrl: issuerEndpoint(oidcIssuer, "/oauth/token"),
+      userInfoUrl: issuerEndpoint(oidcIssuer, "/oauth/userinfo"),
+      scopes: ["openid", "profile", "email"],
+      supportsPkce: true,
+      issuer: oidcIssuer.replace(/\/+$/, ""),
+      jwksUrl: issuerEndpoint(oidcIssuer, "/oauth/jwks"),
+    });
+  }
+
+  return {
+    // A whitespace-only hash is treated as "disabled" (mirrors the login gate),
+    // never as a one-character password.
+    passwordEnabled: !!env.AUTH_PASSWORD_HASH?.trim(),
+    providers,
+  };
+}
+
+/**
+ * プロバイダーIDからプロバイダー設定を取得
+ */
+export function getProvider(
+  env: Env,
+  providerId: string,
+): OAuthProvider | null {
+  const config = getAuthConfig(env);
+  return config.providers.find((p) => p.id === providerId) || null;
+}
+
+/**
+ * 既知のプロバイダーID 集合。 caller boundary は `string` で受けるが、
+ * switch では narrowed union で exhaustive に分岐する。
+ */
+export type ProviderId = "google" | "x" | "takos";
+
+// Upper bound for the userinfo fetch so a hung provider can't stall login.
+const USERINFO_FETCH_TIMEOUT_MS = 10_000;
+
+const KNOWN_PROVIDER_IDS: ReadonlySet<ProviderId> = new Set<ProviderId>([
+  "google",
+  "x",
+  "takos",
+]);
+
+function isKnownProviderId(value: string): value is ProviderId {
+  return KNOWN_PROVIDER_IDS.has(value as ProviderId);
+}
+
+function assertNeverProvider(x: never): never {
+  throw new Error(`Unhandled provider id: ${JSON.stringify(x)}`);
+}
+
+/**
+ * プロバイダーIDからクライアント認証情報を取得
+ */
+export function getClientCredentials(
+  env: Env,
+  providerId: string,
+): { clientId: string; clientSecret: string } {
+  if (!isKnownProviderId(providerId)) {
+    return { clientId: "", clientSecret: "" };
+  }
+  switch (providerId) {
+    case "google":
+      return {
+        clientId: env.GOOGLE_CLIENT_ID || "",
+        clientSecret: env.GOOGLE_CLIENT_SECRET || "",
+      };
+    case "x":
+      return {
+        clientId: env.X_CLIENT_ID || "",
+        clientSecret: env.X_CLIENT_SECRET || "",
+      };
+    case "takos":
+      return getOidcClientCredentials(env);
+    default:
+      return assertNeverProvider(providerId);
+  }
+}
+
+/**
+ * ユーザー情報を正規化
+ */
+export interface NormalizedUserInfo {
+  id: string;
+  name: string;
+  email?: string;
+  picture?: string;
+  username?: string;
+}
+
+function isJsonObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function getString(
+  record: Record<string, unknown>,
+  key: string,
+): string | undefined {
+  const value = record[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+function getObject(
+  record: Record<string, unknown>,
+  key: string,
+): Record<string, unknown> | undefined {
+  const value = record[key];
+  return isJsonObject(value) ? value : undefined;
+}
+
+function parseGoogleUserInfo(
+  data: Record<string, unknown>,
+): NormalizedUserInfo {
+  const id = getString(data, "id");
+  const name = getString(data, "name");
+  if (!id || !name) {
+    throw new Error("Google userinfo response missing required fields");
+  }
+  return {
+    id,
+    name,
+    email: getString(data, "email"),
+    picture: getString(data, "picture"),
+  };
+}
+
+function parseXUserInfo(data: Record<string, unknown>): NormalizedUserInfo {
+  const inner = getObject(data, "data");
+  if (!inner) {
+    throw new Error("X userinfo response missing data field");
+  }
+  const id = getString(inner, "id");
+  const name = getString(inner, "name");
+  const username = getString(inner, "username");
+  if (!id || !name || !username) {
+    throw new Error("X userinfo response missing required fields");
+  }
+  return {
+    id,
+    name,
+    username,
+    picture: getString(inner, "profile_image_url"),
+  };
+}
+
+function parseTakosUserInfo(data: Record<string, unknown>): NormalizedUserInfo {
+  const user = getObject(data, "user");
+  const id = user ? getString(user, "id") : undefined;
+  const sub = getString(data, "sub");
+  const resolvedId = id ?? sub;
+  const userName = user ? getString(user, "name") : undefined;
+  const topName = getString(data, "name");
+  const resolvedName = userName ?? topName ?? resolvedId;
+  if (!resolvedId || !resolvedName) {
+    throw new Error("Takosumi Accounts userinfo response missing subject");
+  }
+  return {
+    id: resolvedId,
+    name: resolvedName,
+    email:
+      (user ? getString(user, "email") : undefined) ?? getString(data, "email"),
+    picture:
+      (user ? getString(user, "picture") : undefined) ??
+      getString(data, "picture"),
+  };
+}
+
+export async function fetchUserInfo(
+  provider: OAuthProvider,
+  accessToken: string,
+): Promise<NormalizedUserInfo> {
+  const url =
+    provider.id === "x"
+      ? `${provider.userInfoUrl}?user.fields=profile_image_url`
+      : provider.userInfoUrl;
+
+  // Bound the userinfo fetch (and its body read) so a hung provider can't stall
+  // the login request; the timer stays armed through res.json(). Mirrors the
+  // token-exchange and fetchJwks timeouts.
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), USERINFO_FETCH_TIMEOUT_MS);
+  let raw: unknown;
+  try {
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${accessToken}` },
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      throw new Error(`Failed to fetch user info: ${res.status}`);
+    }
+    raw = await res.json();
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!isJsonObject(raw)) {
+    throw new Error(`Invalid userinfo response from provider: ${provider.id}`);
+  }
+
+  switch (provider.id) {
+    case "google":
+      return parseGoogleUserInfo(raw);
+    case "x":
+      return parseXUserInfo(raw);
+    case "takos":
+      return parseTakosUserInfo(raw);
+    default:
+      throw new Error(`Unknown provider: ${provider.id}`);
+  }
+}

package/src/backend/lib/oauth-utils.ts

@@ -0,0 +1,148 @@
+/**
+ * OAuth Utilities -- PKCE, state generation, and KV-backed state storage.
+ *
+ * State tokens use dual-layer expiration:
+ *   1. KV TTL (600 s) -- authoritative, auto-deletes the key.
+ *   2. Manual createdAt check in getOAuthState() -- defense-in-depth
+ *      against KV eventual-consistency delays.
+ */
+
+import type { IKeyValueStore } from "../runtime/types.ts";
+
+const ALPHANUMERIC =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+const PKCE_CHARSET = ALPHANUMERIC + "-._~";
+const OAUTH_KV_PREFIX = "oauth:";
+const STATE_TTL_SECONDS = 600;
+const STATE_TTL_MS = STATE_TTL_SECONDS * 1000;
+
+/**
+ * Generate a cryptographically random string from the given alphabet.
+ */
+function randomString(length: number, alphabet: string): string {
+  const n = alphabet.length;
+  // Rejection sampling: discard bytes in the biased tail (>= 256 - 256%n) so
+  // every character is uniformly distributed. A plain `b % n` slightly favors
+  // the first (256 % n) characters when n does not divide 256 — a minor but
+  // real bias in OAuth state / PKCE / nonce tokens.
+  const limit = 256 - (256 % n);
+  const out: string[] = [];
+  while (out.length < length) {
+    const bytes = new Uint8Array(length - out.length);
+    crypto.getRandomValues(bytes);
+    for (const b of bytes) {
+      if (b < limit) out.push(alphabet[b % n]);
+    }
+  }
+  return out.join("");
+}
+
+export function generateId(length = 21): string {
+  return randomString(length, ALPHANUMERIC);
+}
+
+/**
+ * Generate a PKCE code_verifier (64 characters from the unreserved charset).
+ */
+export function generateCodeVerifier(): string {
+  return randomString(64, PKCE_CHARSET);
+}
+
+/**
+ * Generate a random nonce for OAuth CSRF browser-session binding (32 chars).
+ */
+export function generateNonce(): string {
+  return randomString(32, ALPHANUMERIC);
+}
+
+/**
+ * PKCE code_challenge を生成 (S256)
+ */
+export async function generateCodeChallenge(verifier: string): Promise<string> {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(verifier);
+  const digest = await crypto.subtle.digest("SHA-256", data);
+  return base64UrlEncode(digest);
+}
+
+/**
+ * Base64-URL-encode an ArrayBuffer (RFC 4648 section 5, no padding).
+ * Uses chunked conversion to avoid stack overflow on large buffers.
+ */
+export function base64UrlEncode(
+  buffer: ArrayBuffer | null | undefined,
+): string {
+  if (buffer == null) {
+    throw new Error("base64UrlEncode: buffer cannot be null or undefined");
+  }
+  if (!(buffer instanceof ArrayBuffer)) {
+    throw new Error("base64UrlEncode: buffer must be an ArrayBuffer");
+  }
+  if (buffer.byteLength === 0) {
+    return "";
+  }
+
+  const bytes = new Uint8Array(buffer);
+  const CHUNK_SIZE = 8192;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {
+    const chunk = bytes.subarray(i, Math.min(i + CHUNK_SIZE, bytes.length));
+    binary += String.fromCharCode.apply(null, Array.from(chunk));
+  }
+
+  return btoa(binary)
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/, "");
+}
+
+export interface OAuthState {
+  provider: string;
+  codeVerifier: string;
+  createdAt: number;
+  /**
+   * Browser-session binding nonce for login CSRF protection (Issue 107).
+   * Set as a short-lived HttpOnly cookie on the initiating browser and stored
+   * here so the callback handler can verify both values match.
+   */
+  nonce?: string;
+}
+
+function oauthKey(state: string): string {
+  return `${OAUTH_KV_PREFIX}${state}`;
+}
+
+export async function saveOAuthState(
+  kv: IKeyValueStore,
+  state: string,
+  data: OAuthState,
+): Promise<void> {
+  await kv.put(oauthKey(state), JSON.stringify(data), {
+    expirationTtl: STATE_TTL_SECONDS,
+  });
+}
+
+export async function getOAuthState(
+  kv: IKeyValueStore,
+  state: string,
+): Promise<OAuthState | null> {
+  const stored = await kv.get(oauthKey(state));
+  if (!stored) return null;
+
+  const data = JSON.parse(stored) as OAuthState;
+
+  // Defense-in-depth: reject expired states even if KV TTL hasn't propagated
+  if (Date.now() - data.createdAt > STATE_TTL_MS) {
+    await kv.delete(oauthKey(state));
+    return null;
+  }
+
+  return data;
+}
+
+export async function deleteOAuthState(
+  kv: IKeyValueStore,
+  state: string,
+): Promise<void> {
+  await kv.delete(oauthKey(state));
+}

package/src/backend/lib/oidc-id-token.ts

@@ -0,0 +1,151 @@
+/**
+ * OIDC ID Token verification.
+ *
+ * For the authorization-code flow the ID Token is the issuer's primary identity
+ * assertion. Takosumi Accounts signs it ES256 and exposes its keys at the JWKS
+ * endpoint; its minimal userinfo response omits `name`/`email` (those live on
+ * the ID Token), so the login callback reads identity claims from here.
+ *
+ * We verify the signature (ES256 against the issuer JWKS) and the standard
+ * claims (iss / aud / exp / sub) rather than trusting the token blindly — even
+ * though it arrives over the TLS-authenticated token endpoint — to match the
+ * codebase's fail-closed posture and reject a token from a mis-issuer.
+ */
+
+export type OidcIdTokenClaims = {
+  sub: string;
+  iss?: string;
+  aud?: string | string[];
+  exp?: number;
+  iat?: number;
+  nonce?: string;
+  name?: string;
+  email?: string;
+  email_verified?: boolean;
+  preferred_username?: string;
+};
+
+type Jwk = JsonWebKey & { kid?: string; alg?: string; use?: string };
+
+function b64urlToBytes(segment: string): Uint8Array {
+  const b64 = segment.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = b64 + "=".repeat((4 - (b64.length % 4)) % 4);
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+function b64urlToJson<T>(segment: string): T {
+  return JSON.parse(new TextDecoder().decode(b64urlToBytes(segment))) as T;
+}
+
+async function fetchJwks(jwksUrl: string): Promise<Jwk[]> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 5000);
+  try {
+    const res = await fetch(jwksUrl, {
+      headers: { Accept: "application/json" },
+      signal: controller.signal,
+    });
+    if (!res.ok) throw new Error(`JWKS fetch failed: ${res.status}`);
+    const body = (await res.json()) as { keys?: Jwk[] };
+    if (!Array.isArray(body.keys)) throw new Error("JWKS missing keys array");
+    return body.keys;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function selectEcKey(keys: Jwk[], kid: string | undefined): Jwk | undefined {
+  const ecKeys = keys.filter(
+    (k) => k.kty === "EC" && k.crv === "P-256" && (k.use ?? "sig") === "sig",
+  );
+  if (kid) {
+    const match = ecKeys.find((k) => k.kid === kid);
+    if (match) return match;
+  }
+  // No kid (or no match): only safe to fall back when exactly one candidate.
+  return ecKeys.length === 1 ? ecKeys[0] : undefined;
+}
+
+/**
+ * Verify an OIDC ID Token (ES256) against the issuer's JWKS and validate its
+ * core claims. Returns the decoded claims on success; throws on any failure.
+ */
+export async function verifyOidcIdToken(
+  idToken: string,
+  opts: {
+    issuer: string;
+    clientId: string;
+    jwksUrl: string;
+    expectedNonce?: string;
+  },
+): Promise<OidcIdTokenClaims> {
+  const parts = idToken.split(".");
+  if (parts.length !== 3) throw new Error("malformed id_token");
+
+  const header = b64urlToJson<{ alg?: string; kid?: string }>(parts[0]);
+  // ES256 only — reject `none` and any non-ES256 alg so an attacker can't
+  // downgrade to an unsigned/forgeable token.
+  if (header.alg !== "ES256") {
+    throw new Error(`unexpected id_token alg: ${header.alg ?? "none"}`);
+  }
+
+  const claims = b64urlToJson<OidcIdTokenClaims>(parts[1]);
+
+  const jwks = await fetchJwks(opts.jwksUrl);
+  const jwk = selectEcKey(jwks, header.kid);
+  if (!jwk) throw new Error("no matching JWKS signing key for id_token");
+
+  const key = await crypto.subtle.importKey(
+    "jwk",
+    jwk,
+    { name: "ECDSA", namedCurve: "P-256" },
+    false,
+    ["verify"],
+  );
+  // A JWS ES256 signature is the raw r||s concatenation (IEEE P1363) — exactly
+  // what WebCrypto ECDSA verify expects, no DER unwrap needed.
+  const ok = await crypto.subtle.verify(
+    { name: "ECDSA", hash: "SHA-256" },
+    key,
+    b64urlToBytes(parts[2]).buffer as ArrayBuffer,
+    new TextEncoder().encode(`${parts[0]}.${parts[1]}`).buffer as ArrayBuffer,
+  );
+  if (!ok) throw new Error("id_token signature invalid");
+
+  // Standard claim validation (fail closed).
+  const norm = (s: string) => s.replace(/\/+$/, "");
+  if (!claims.iss || norm(claims.iss) !== norm(opts.issuer)) {
+    throw new Error("id_token iss mismatch");
+  }
+  const auds = Array.isArray(claims.aud)
+    ? claims.aud
+    : claims.aud
+      ? [claims.aud]
+      : [];
+  if (!auds.includes(opts.clientId)) {
+    throw new Error("id_token aud mismatch");
+  }
+  const nowSec = Math.floor(Date.now() / 1000);
+  // `exp` is REQUIRED by OIDC — reject a token that omits it (fail closed) rather
+  // than treating it as eternal. 60s clock-skew slack on the comparison.
+  if (typeof claims.exp !== "number") {
+    throw new Error("id_token missing exp");
+  }
+  if (claims.exp < nowSec - 60) {
+    throw new Error("id_token expired");
+  }
+  if (!claims.sub) throw new Error("id_token missing sub");
+
+  // Optional OIDC nonce binding: when the RP sent a nonce in the authorize
+  // request, the issuer echoes it in the id_token and we MUST match it (replay
+  // protection). When no expected nonce is configured, skip (back-channel
+  // code-flow is already bound by state + PKCE).
+  if (opts.expectedNonce !== undefined && claims.nonce !== opts.expectedNonce) {
+    throw new Error("id_token nonce mismatch");
+  }
+
+  return claims;
+}

package/src/backend/lib/parse-helpers.ts

@@ -0,0 +1,31 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export async function parseJsonObject(c: {
+  req: { json: () => Promise<unknown> };
+}): Promise<Record<string, unknown> | null> {
+  try {
+    const body = await c.req.json();
+    if (!isRecord(body)) return null;
+    return body;
+  } catch {
+    return null;
+  }
+}
+
+export function parseNonEmptyString(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+export function isUniqueConstraintError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "message" in error &&
+    typeof (error as { message: string }).message === "string" &&
+    (error as { message: string }).message.includes("UNIQUE constraint failed")
+  );
+}