@things-factory/auth-base 10.1.4 → 10.1.6

package/tests/compiled.ts

@@ -0,0 +1,41 @@
+/**
+ * 게이트 시험이 **컴파일된 산출물**(`dist-server`)을 드는 이유.
+ *
+ * 이 패키지의 엔티티는 `@Field({ nullable: true })` 처럼 **명시 타입이 없는** type-graphql
+ * 데코레이터를 쓴다. 그것을 읽으려면 `emitDecoratorMetadata` 가 필요한데 jest 의 변환기는
+ * babel 이고, babel 은 tsc 의 그 기능을 대체하지 못한다. 그래서 소스에서 `user.ts` 를 들면
+ * import 시점에 죽는다:
+ *
+ *   Unable to infer GraphQL type from TypeScript reflection system.
+ *     at privilege.ts:15  ← role.ts → user.ts 를 타고 올라온다
+ *
+ * legacy 데코레이터로 바꾸는 길은 이미 시도했고 되돌렸다(루트 `jest.config.js` 주석).
+ * 그래서 **엔티티 그래프에 닿는 시험은 tsc 산출물을 든다.** 루트 `pretest` 가 `yarn build` 이므로
+ * `yarn test` 경로에서는 산출물이 항상 갱신되어 있다.
+ *
+ * **대가**: 산출물은 낡을 수 있고, 타입 검사가 이 경계를 넘지 않는다 — `yarn _test` 로 빌드를
+ * 건너뛰고 돌리면 옛 시그니처를 시험하게 된다. 그래서 아래 로더가 산출물이 없으면
+ * **무엇을 해야 하는지 말하고** 죽는다(조용한 초록보다 낫다).
+ *
+ * 순수 함수(`checkin-domain-rule` · `privilege-rejection` · `privilege-deprecation`)는
+ * 엔티티에 닿지 않으므로 소스에서 그대로 든다. 이 로더는 그 밖의 것에만 쓴다.
+ */
+
+import { existsSync } from 'fs'
+import { join } from 'path'
+
+const DIST = join(__dirname, '..', 'dist-server')
+
+export function loadCompiled<T = any>(modulePath: string): T {
+  const resolved = join(DIST, `${modulePath}.js`)
+
+  if (!existsSync(resolved)) {
+    throw new Error(
+      `auth-base 산출물이 없다: ${resolved}\n` +
+        `이 시험은 tsc 산출물을 든다(이유는 tests/compiled.ts). 먼저 빌드할 것:\n` +
+        `  yarn workspace @things-factory/auth-base build:server`
+    )
+  }
+
+  return require(resolved)
+}

package/tests/has-privilege-db.test.ts

@@ -0,0 +1,198 @@
+/**
+ * `User.hasPrivilege` — **질의**를 실 DB 로 태운다.
+ *
+ * 이 함수가 이름 있는 권한 판정의 마지막 자리다(`checkPermission` 이 소유권 우회를 지나면 여기로
+ * 온다). `permission-gate.test.ts` 는 그 앞의 규칙만 보고 이 함수는 목으로 대신했다 — 즉
+ * **역할·권한·도메인 상속이 실제로 어떻게 이어지는지는 시험된 적이 없었다.**
+ *
+ * 열린 방 509개를 닫는 일이 이 질의 위에 선다. 지시자를 다 달아 놓고 질의가 틀리면, 닫은 것이
+ * 아니라 **아무도 못 들어오게 만든 것**이 된다.
+ *
+ * ── 상속 규약 ───────────────────────────────────────────────────────────────
+ * 역할은 도메인에 정의되고 자식 도메인이 **부모 1단**을 상속한다
+ * (`applyDomainInheritanceFilter` 가 단일 소스: `domain IN (자기, 부모)`).
+ * 그래서 판정은 「어느 도메인에 정의된 역할인가」를 보고, 「어느 도메인에서 부여받았나」는
+ * 체크인 게이트(`checkin-domain-rule`)가 본다 — 그쪽은 순수 시험이 따로 있다.
+ *
+ * ⚠ `parentId` 는 `@RelationId` 라 **저장소로 읽은 도메인에만** 실린다. 손으로 만든 객체를
+ *   넘기면 상속 경로가 조용히 성립하지 않는다. 그래서 아래는 전부 다시 읽어서 넘긴다.
+ */
+
+import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
+import { loadCompiled } from './compiled'
+
+const { User } = loadCompiled('service/user/user')
+const { Role } = loadCompiled('service/role/role')
+const { Privilege } = loadCompiled('service/privilege/privilege')
+
+let parent: any
+let child: any
+let sibling: any
+let grandchild: any
+let boardMutation: any
+
+/** `parentId` 가 실리도록 저장소로 다시 읽는다. */
+async function loadDomain(id: string) {
+  return await getRepository(Domain).findOneBy({ id })
+}
+
+async function makeRole(name: string, domain: any, privileges: any[]) {
+  return await getRepository(Role).save({ name, domain, privileges })
+}
+
+async function makeUser(memberOf: any[], roles: any[]) {
+  const salt = User.generateSalt()
+
+  return await getRepository(User).save({
+    username: `kim-${Math.random().toString(36).slice(2, 8)}`,
+    email: `kim-${Math.random().toString(36).slice(2, 8)}@example.com`,
+    name: 'Kim',
+    salt,
+    status: 'activated',
+    domains: memberOf,
+    roles
+  })
+}
+
+beforeAll(async () => {
+  await openAuthDatabase()
+})
+
+beforeEach(async () => {
+  await resetAuthDatabase()
+
+  const p = await getRepository(Domain).save({ name: 'group', subdomain: 'group' })
+  parent = await loadDomain(p.id)
+
+  const c = await getRepository(Domain).save({ name: 'plant-a', subdomain: 'plant-a', parent })
+  child = await loadDomain(c.id)
+
+  const s = await getRepository(Domain).save({ name: 'plant-b', subdomain: 'plant-b', parent })
+  sibling = await loadDomain(s.id)
+
+  const g = await getRepository(Domain).save({ name: 'line-1', subdomain: 'line-1', parent: child })
+  grandchild = await loadDomain(g.id)
+
+  boardMutation = await getRepository(Privilege).save({ name: 'mutation', category: 'board' })
+})
+
+afterAll(async () => {
+  await closeAuthDatabase()
+})
+
+describe('자기 도메인의 역할', () => {
+  it('그 도메인에서 통과한다', async () => {
+    const role = await makeRole('editor', child, [boardMutation])
+    const user = await makeUser([child], [role])
+
+    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(true)
+  })
+
+  it('권한이 다르면 통과하지 못한다', async () => {
+    const role = await makeRole('editor', child, [boardMutation])
+    const user = await makeUser([child], [role])
+
+    expect(await User.hasPrivilege('query', 'board', child, user)).toBe(false)
+    expect(await User.hasPrivilege('mutation', 'twin', child, user)).toBe(false)
+  })
+
+  it('역할이 없으면 통과하지 못한다', async () => {
+    const user = await makeUser([child], [])
+
+    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(false)
+  })
+
+  it('역할은 있는데 권한이 안 붙어 있으면 통과하지 못한다', async () => {
+    const role = await makeRole('viewer', child, [])
+    const user = await makeUser([child], [role])
+
+    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(false)
+  })
+})
+
+describe('부모 도메인의 역할 — 1단 상속', () => {
+  it('부모에 정의된 역할이 자식 도메인에서 통과한다', async () => {
+    const role = await makeRole('group-editor', parent, [boardMutation])
+    const user = await makeUser([child], [role])
+
+    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(true)
+  })
+
+  it('할아버지 도메인의 역할은 손자에서 통과하지 못한다 — 상속은 1단이다', async () => {
+    const role = await makeRole('group-editor', parent, [boardMutation])
+    const user = await makeUser([grandchild], [role])
+
+    expect(await User.hasPrivilege('mutation', 'board', grandchild, user)).toBe(false)
+  })
+
+  it('형제 도메인의 역할은 통과하지 못한다', async () => {
+    const role = await makeRole('b-editor', sibling, [boardMutation])
+    const user = await makeUser([child], [role])
+
+    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(false)
+  })
+})
+
+describe('⚠ 이 질의가 멤버십을 보지 않는다', () => {
+  it('그 도메인의 멤버가 아니어도 역할만 있으면 통과한다', async () => {
+    /*
+     * 결함이 아니다 — 나누어 맡긴 것이다. 멤버십은 체크인 게이트가 강제하고
+     * (`checkin-domain-rule` 이 `memberDomainIds` 를 AND 조건으로 건다), 여기까지 온 요청은
+     * 이미 그 문을 지났다.
+     *
+     * 다만 **이 함수를 그 문 밖에서 부르면 격리가 성립하지 않는다.** 미들웨어를 타지 않는
+     * 경로(주기 작업·내부 호출)에서 쓸 때 그 사실을 알고 있어야 한다.
+     */
+    const role = await makeRole('editor', child, [boardMutation])
+    const user = await makeUser([sibling], [role])
+
+    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(true)
+  })
+})
+
+describe('parentId 가 안 실린 도메인 객체', () => {
+  it('손으로 만든 객체를 넘기면 상속이 성립하지 않는다', async () => {
+    /*
+     * `parentId` 는 `@RelationId` 라 저장소로 읽은 엔티티에만 실린다. 그래서 `{ id }` 만 담은
+     * 객체를 넘기면 상속 경로가 **조용히** 사라진다 — 부모 역할로 들어오던 사람이 거절된다.
+     * 부르는 쪽이 온전히 적재된 도메인을 넘겨야 한다는 뜻이고, 그것을 시험으로 못 박아 둔다.
+     */
+    const role = await makeRole('group-editor', parent, [boardMutation])
+    const user = await makeUser([child], [role])
+
+    expect(await User.hasPrivilege('mutation', 'board', child, user)).toBe(true)
+    expect(await User.hasPrivilege('mutation', 'board', { id: child.id } as any, user)).toBe(false)
+  })
+})
+
+describe('getPrivilegesByDomain', () => {
+  it('자기 도메인과 부모 도메인의 권한을 함께 돌려준다', async () => {
+    const boardQuery = await getRepository(Privilege).save({ name: 'query', category: 'board' })
+    const twinMutation = await getRepository(Privilege).save({ name: 'mutation', category: 'twin' })
+
+    const parentRole = await makeRole('group-editor', parent, [twinMutation])
+    const childRole = await makeRole('editor', child, [boardMutation, boardQuery])
+    const user = await makeUser([child], [parentRole, childRole])
+
+    const granted = await User.getPrivilegesByDomain(user, child)
+
+    expect(granted).toEqual(
+      expect.arrayContaining([
+        { category: 'board', privilege: 'mutation' },
+        { category: 'board', privilege: 'query' },
+        { category: 'twin', privilege: 'mutation' }
+      ])
+    )
+    expect(granted).toHaveLength(3)
+  })
+
+  it('같은 권한을 두 역할로 받아도 한 번만 돌려준다', async () => {
+    const one = await makeRole('editor-1', child, [boardMutation])
+    const two = await makeRole('editor-2', child, [boardMutation])
+    const user = await makeUser([child], [one, two])
+
+    const granted = await User.getPrivilegesByDomain(user, child)
+
+    expect(granted).toEqual([{ category: 'board', privilege: 'mutation' }])
+  })
+})

package/tests/lock-recovery.test.ts

@@ -0,0 +1,204 @@
+/**
+ * 잠긴 계정이 **어떤 경로로 풀리나** — 두 메일이 서로 다른 곳으로 간다.
+ *
+ * 계정이 잠기면 두 종류의 메일이 있을 수 있고, 템플릿이 거의 같아 눈으로는 잘 안 갈린다
+ * (둘 다 `<title>reset password</title>` · 같은 레이아웃 · 본문 한 줄만 다르다). 구별되는 것은
+ * 메일 **제목**뿐이다 — `Reset your password` 와 `Your account is locked`.
+ *
+ * 그런데 **결과가 다르다.** 비슷하게 보이면 안 되는 짝이라는 것을 여기서 못 박는다.
+ * 템플릿 자체의 개선은 따로 대기 중이다.
+ *
+ * (관리자 경로 `activateUser` 는 `failCount` 를 0 으로 두고 `ACTIVATED` 로 되돌린다 —
+ *  type-graphql 리졸버라 jest 에서 들 수 없어 여기서는 시험하지 않는다. 그 자리가 정식 경로다.)
+ */
+
+import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
+import { loadCompiled } from './compiled'
+
+const { User } = loadCompiled('service/user/user')
+const { signin } = loadCompiled('controllers/signin')
+const { resetPassword } = loadCompiled('controllers/reset-password')
+const { unlockUser } = loadCompiled('controllers/unlock-user')
+const { VerificationToken, VerificationTokenType } = loadCompiled('service/verification-token/verification-token')
+
+const OLD = 'Passw0rd!'
+const NEW = 'N3wPassw0rd!'
+
+let domain: any
+
+async function lockedUser() {
+  const salt = User.generateSalt()
+
+  return await getRepository(User).save({
+    username: 'kim',
+    email: 'kim@example.com',
+    name: 'Kim',
+    salt,
+    password: User.encode(OLD, salt),
+    status: 'locked',
+    failCount: 5,
+    domains: [domain]
+  })
+}
+
+async function giveToken(userId: string, token: string, type: string) {
+  await getRepository(VerificationToken).save({ userId, token, type })
+}
+
+/** `resetPassword` 가 컨텍스트에서 읽는 것만 담는다. */
+const context = { t: (key: string) => key, lng: 'en-US' }
+
+beforeAll(async () => {
+  await openAuthDatabase()
+})
+
+beforeEach(async () => {
+  await resetAuthDatabase()
+  domain = await getRepository(Domain).save({ name: 'plant-a', subdomain: 'plant-a' })
+})
+
+afterAll(async () => {
+  await closeAuthDatabase()
+})
+
+describe('재설정 메일 경로 (PASSWORD_RESET)', () => {
+  it('비밀번호는 바뀌지만 **잠금은 그대로다**', async () => {
+    /* `resetPassword` 는 `status` 를 건드리지 않는다 — 그 파일의 INACTIVE 검사도 주석 처리되어
+       있다. 그래서 이 메일은 「비밀번호를 잊었다」를 위한 것이고 「잠겼다」의 답이 아니다. */
+    const user = await lockedUser()
+    await giveToken(user.id, 'tok', VerificationTokenType.PASSWORD_RESET)
+
+    await resetPassword('tok', NEW, context)
+
+    const after = await getRepository(User).findOneBy({ id: user.id })
+    expect(User.verify(after.password, NEW, after.salt)).toBe(true)
+    expect(after.status).toBe('locked')
+    expect(after.failCount).toBe(5)
+  })
+
+  it('그래서 새 비밀번호로도 들어갈 수 없다', async () => {
+    /* `signin` 의 잠금 검사가 비밀번호 대조보다 먼저다. 사용자가 겪는 것은
+       「메일로 비밀번호를 바꿨는데 여전히 못 들어간다」다. */
+    const user = await lockedUser()
+    await giveToken(user.id, 'tok', VerificationTokenType.PASSWORD_RESET)
+
+    await resetPassword('tok', NEW, context)
+
+    await expect(signin({ username: 'kim', password: NEW })).rejects.toThrow()
+  })
+})
+
+describe('잠금 해제 메일 경로 (UNLOCK)', () => {
+  it('비밀번호를 바꾸고 잠금까지 되돌린다', async () => {
+    const user = await lockedUser()
+    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
+
+    expect(await unlockUser('tok', NEW)).toBe(true)
+
+    const after = await getRepository(User).findOneBy({ id: user.id })
+    expect(after.status).toBe('activated')
+    expect(after.failCount).toBe(0)
+    expect(User.verify(after.password, NEW, after.salt)).toBe(true)
+  })
+
+  it('풀린 뒤에는 새 비밀번호로 들어간다', async () => {
+    const user = await lockedUser()
+    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
+
+    await unlockUser('tok', NEW)
+
+    const result = await signin({ username: 'kim', password: NEW })
+    expect(result.token).toBeTruthy()
+  })
+
+  it('토큰을 한 번만 쓸 수 있다 — 두 번째는 거절한다(던지지 않는다)', async () => {
+    const user = await lockedUser()
+    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
+
+    await unlockUser('tok', NEW)
+
+    /* 예전에는 토큰 행이 사라진 뒤 `findOne` 의 `null` 을 구조 분해해서 던졌고, 화면은 이유가
+       아니라 500 을 봤다. 지금은 거절로 돌아온다. */
+    expect(await unlockUser('tok', NEW)).toBe(false)
+  })
+
+  it('잠기지 않은 계정에는 아무 일도 하지 않는다', async () => {
+    const user = await lockedUser()
+    await getRepository(User).update({ id: user.id }, { status: 'activated', failCount: 0 })
+    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
+
+    /* `status != LOCKED` 이면 `false` 를 돌려준다(unlock-user.ts:48) — 비밀번호도 안 바뀐다. */
+    expect(await unlockUser('tok', NEW)).toBe(false)
+
+    const after = await getRepository(User).findOneBy({ id: user.id })
+    expect(User.verify(after.password, OLD, after.salt)).toBe(true)
+  })
+})
+
+describe('토큰 없는 요청 — 계정 탈취 회귀', () => {
+  /*
+   * ── 무엇이 가능했나 (2026-09-09, 고침) ──────────────────────────────────────
+   * `unlockUser` 가 `findOne({ where: { token, type: UNLOCK } })` 로 찾았는데, TypeORM 은
+   * `where` 에서 **`undefined` 조건을 떨어뜨린다.** 그래서 `token` 이 없으면 조건이
+   * `{ type: UNLOCK }` 만 남아 **누구의 해제 토큰이든** 맞았고, 그 계정의 비밀번호를 부르는
+   * 쪽이 준 값으로 바꿨다.
+   *
+   * 두 조각 다 자격 없이 손에 넣을 수 있었다. 남의 계정을 다섯 번 틀리면 잠기면서 해제 토큰이
+   * 만들어지고(그것을 막을 rate limit 이 없다), `/auth/unlock-user` 의 가드가
+   * `!(token || password)` 여서 **비밀번호만 담은 요청이 통과했다.**
+   *
+   * 실제로 전 과정을 태워 확인했다 — status `activated` · failCount 0 · 비밀번호는 공격자의
+   * 것 · 그 비밀번호로 로그인 성공.
+   *
+   * 두 자리를 다 고쳤다(컨트롤러의 요구 조건 · 라우터의 가드). 아래는 컨트롤러 쪽을 지킨다 —
+   * 라우터 가드가 되돌아가도 여기서 막힌다.
+   */
+  it('토큰 없이 부르면 잠긴 계정을 건드리지 못한다', async () => {
+    const user = await lockedUser()
+    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
+
+    expect(await unlockUser(undefined, 'ATTACKERpass1!')).toBe(false)
+
+    const after = await getRepository(User).findOneBy({ id: user.id })
+    expect(after.status).toBe('locked')
+    expect(after.failCount).toBe(5)
+    expect(User.verify(after.password, 'ATTACKERpass1!', after.salt)).toBe(false)
+    expect(User.verify(after.password, OLD, after.salt)).toBe(true)
+  })
+
+  it('빈 문자열 토큰도 같다', async () => {
+    const user = await lockedUser()
+    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
+
+    expect(await unlockUser('', 'ATTACKERpass1!')).toBe(false)
+
+    const after = await getRepository(User).findOneBy({ id: user.id })
+    expect(after.status).toBe('locked')
+  })
+
+  it('그 뒤에도 공격자의 비밀번호로 들어갈 수 없다', async () => {
+    const user = await lockedUser()
+    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
+
+    await unlockUser(undefined, 'ATTACKERpass1!')
+
+    await expect(signin({ username: 'kim', password: 'ATTACKERpass1!' })).rejects.toThrow()
+  })
+
+  it('비밀번호 없이 부르면 거절한다 — 던지지 않는다', async () => {
+    /* 예전에는 `User.encode(undefined, salt)` 가 `crypto` 안에서 던져 500 이 됐다. */
+    const user = await lockedUser()
+    await giveToken(user.id, 'tok', VerificationTokenType.UNLOCK)
+
+    expect(await unlockUser('tok', undefined)).toBe(false)
+
+    const after = await getRepository(User).findOneBy({ id: user.id })
+    expect(after.status).toBe('locked')
+  })
+
+  it('없는 토큰은 거절한다 — 던지지 않는다', async () => {
+    await lockedUser()
+
+    expect(await unlockUser('no-such-token', NEW)).toBe(false)
+  })
+})

package/tests/password-hashing.test.ts

@@ -0,0 +1,131 @@
+/**
+ * 비밀번호 저장 방식 시험.
+ *
+ * `signin` 은 `User.verify(user.password, 입력, user.salt)` 하나로 사람을 들여보낸다
+ * (`controllers/signin.ts:53`). 저장소의 시험 316개 중 이 함수를 부르는 것이 없었다.
+ *
+ * 아래는 **지금 그렇다**를 고정하는 시험이고, 그중 셋은 고쳐야 할 사실이다
+ * (`docs/design/auth-rebuild.md` §5-1):
+ *
+ *  ① 해시가 **KDF 가 아니다** — HMAC-SHA256 **1회**다. 대입 저항이 사실상 없다
+ *  ② `verify` 가 **SHA-1 도 받는다** — 옛 형식 하위호환
+ *  ③ salt 가 없으면 **`SECRET` 을 salt 로** 쓴다 — 그 경우 전 사용자가 같은 salt 다
+ *
+ * KDF 로 옮길 때는 이 시험을 먼저 바꾼다. ①의 「1회 HMAC 과 바이트가 같다」가 깨지는 것이
+ * 곧 옮겨졌다는 증거다.
+ *
+ * (여기서 다루지 않는 것: 비교가 `==` 문자열 비교라 상수 시간이 아니다. 타이밍은 시험으로
+ *  붙잡을 수 있는 성질이 아니므로 문서에만 남긴다.)
+ */
+
+import crypto from 'crypto'
+
+import { validatePasswordByRule } from '../server/controllers/utils/password-rule.js'
+import { loadCompiled } from './compiled'
+
+const { User } = loadCompiled('service/user/user')
+const { SECRET } = loadCompiled('utils/get-secret')
+
+const PASSWORD = 'Passw0rd!'
+const SALT = 'a1b2c3d4e5f6'
+
+describe('해시 만들기 (User.encode)', () => {
+  it('HMAC-SHA256 을 한 번 돌린 값과 바이트가 같다 — KDF 가 아니다', () => {
+    const oneRound = crypto.createHmac('sha256', SALT).update(PASSWORD).digest('base64')
+
+    expect(User.encode(PASSWORD, SALT)).toBe(oneRound)
+  })
+
+  it('같은 입력에 같은 값을 준다 — 호출마다 무작위가 섞이지 않는다', () => {
+    expect(User.encode(PASSWORD, SALT)).toBe(User.encode(PASSWORD, SALT))
+  })
+
+  it('salt 가 다르면 값이 다르다', () => {
+    expect(User.encode(PASSWORD, SALT)).not.toBe(User.encode(PASSWORD, 'other-salt'))
+  })
+
+  it('salt 가 없으면 `SECRET` 을 salt 로 쓴다 — 그 사용자들은 salt 를 공유한다', () => {
+    const withSecretAsSalt = crypto.createHmac('sha256', SECRET).update(PASSWORD).digest('base64')
+
+    expect(User.encode(PASSWORD, undefined)).toBe(withSecretAsSalt)
+    expect(User.encode(PASSWORD, null)).toBe(withSecretAsSalt)
+    expect(User.encode(PASSWORD, '')).toBe(withSecretAsSalt)
+  })
+
+  it('salt 는 16바이트 hex 다', () => {
+    const salt = User.generateSalt()
+
+    expect(salt).toMatch(/^[0-9a-f]{32}$/)
+    expect(salt).not.toBe(User.generateSalt())
+  })
+})
+
+describe('해시 맞추기 (User.verify)', () => {
+  it('SHA-256 으로 저장된 값을 맞춘다', () => {
+    expect(User.verify(User.encode(PASSWORD, SALT), PASSWORD, SALT)).toBe(true)
+  })
+
+  it('틀린 비밀번호를 거절한다', () => {
+    expect(User.verify(User.encode(PASSWORD, SALT), 'Passw0rd?', SALT)).toBe(false)
+  })
+
+  it('salt 가 다르면 거절한다', () => {
+    expect(User.verify(User.encode(PASSWORD, SALT), PASSWORD, 'other-salt')).toBe(false)
+  })
+
+  it('SHA-1 으로 저장된 값도 받는다 — 옛 형식 하위호환', () => {
+    const sha1 = crypto.createHmac('sha1', SALT).update(PASSWORD).digest('base64')
+
+    expect(User.verify(sha1, PASSWORD, SALT)).toBe(true)
+  })
+
+  it('저장된 해시가 없으면 거절한다', () => {
+    /* 기계 주체의 그림자 사용자는 `password` 칸에 **토큰 원문**이 들어간다
+       (appliance-mutation.ts:64 · oauth2-server.ts:152). 그 값은 해시가 아니므로
+       비밀번호 로그인으로는 통하지 않는다 — 노출 문제는 저장 쪽이고, 로그인 쪽은 막혀 있다. */
+    expect(User.verify(undefined, PASSWORD, SALT)).toBe(false)
+    expect(User.verify(null, PASSWORD, SALT)).toBe(false)
+    expect(User.verify('some-jwt-looking-string', PASSWORD, SALT)).toBe(false)
+  })
+})
+
+describe('서명 키 (SECRET)', () => {
+  it('설정이 없으면 저장소에 박힌 상수를 쓴다', () => {
+    /* production 에서는 던진다(get-secret.ts:7). 그 밖의 환경 — staging 포함 — 은
+       **공개된 상수**로 토큰을 서명한다. 이 값이 바뀌면 이 시험이 깨진다. */
+    expect(SECRET).toBe('0xD58F835B69D207A76CC5F84a70a1D0d4C79dAC95')
+  })
+})
+
+describe('비밀번호 규칙 (기본 설정)', () => {
+  /** 기본 규칙: 8자 이상 · 소문자 · 대문자 · 숫자 · 특수문자 · 같은 문자 3연속 금지. */
+  const rejects = (password: string) => expect(() => validatePasswordByRule(password, 'en-US')).toThrow()
+  const accepts = (password: string) => expect(() => validatePasswordByRule(password, 'en-US')).not.toThrow()
+
+  it('규칙을 모두 만족하면 통과한다', () => {
+    accepts('Passw0rd!')
+  })
+
+  it('짧으면 거절한다', () => {
+    rejects('Pw0rd!')
+  })
+
+  it('종류가 빠지면 거절한다', () => {
+    rejects('passw0rd!') // 대문자 없음
+    rejects('PASSW0RD!') // 소문자 없음
+    rejects('Password!') // 숫자 없음
+    rejects('Passw0rdd') // 특수문자 없음
+  })
+
+  it('같은 문자 3연속을 거절한다', () => {
+    rejects('Paaassw0rd!')
+  })
+
+  it('특수문자는 `!@#$%^&*()` 안에서만 인정한다', () => {
+    /* 규칙 정규식이 그 열 자만 본다(password-rule.ts:36). 그 밖의 기호(`-`·`_`·`~` 등)만
+       쓴 비밀번호는 특수문자가 없는 것으로 취급되어 거절된다 — 사용자에게는
+       「특수문자를 넣었는데 거절당했다」로 보인다. */
+    rejects('Passw0rd-')
+    accepts('Passw0rd#')
+  })
+})