Session 기반 Admin 인증

클라이언트                     서버                     저장소
   |                           |                        |
   |--- POST /login ---------->|                        |
   |    {id, password}         |                        |
   |                           |-- 비밀번호 검증 ------->|
   |                           |                        |
   |                           |-- SET session:uuid --->|
   |                           |     value: loginId     |
   |                           |     EX: 43200          |
   |<-- Set-Cookie: sessionId=uuid                      |
   |                           |                        |
   |--- GET /admin/data ------>|                        |
   |    Cookie: sessionId=uuid |                        |
   |                           |-- GET session:uuid --->|
   |                           |<-- loginId ------------|
   |<-- 200 OK                 |                        |

const sessions = new Map<string, string>();
sessions.set(sessionId, loginId);

CREATE TABLE sessions (
  session_id VARCHAR(36) PRIMARY KEY,
  login_id VARCHAR(255),
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  expires_at TIMESTAMP
);

SET session:550e8400-e29b-41d4-a716-446655440000 "admin01" EX 43200

import { v4 as uuidv4 } from 'uuid';

const sessionId = uuidv4();
// "550e8400-e29b-41d4-a716-446655440000"

import { randomBytes } from 'crypto';

const sessionId = randomBytes(32).toString('hex');
// 256비트 랜덤 문자열

@Injectable()
export class AuthService {
  constructor(
    private readonly adminRepository: AdminRepository,
    private readonly redisService: RedisService,
  ) {}

  async login(loginId: string, password: string, req: Request, res: Response) {
    // 1. 자격 증명 검증
    const admin = await this.adminRepository.findOne({
      where: { loginId },
    });

    if (!admin || !(await bcrypt.compare(password, admin.password))) {
      throw new UnauthorizedException('아이디 혹은 비밀번호가 잘못되었습니다.');
    }

    // 2. 기존 쿠키의 세션 삭제
    const existingCookie = req.cookies['sessionId'];
    if (existingCookie) {
      await this.redisService.del(`session:auth:${existingCookie}`);
    }

    // 3. 같은 계정의 다른 세션 찾아서 삭제 (단일 세션 정책)
    await this.invalidateExistingSessions(loginId);

    // 4. 새 세션 생성
    const sessionId = uuidv4();
    await this.redisService.set(
      `session:auth:${sessionId}`,
      admin.loginId,
      'EX',
      SESSION_TTL,  // 예: 12시간 (43200초)
    );

    // 5. 쿠키에 세션 ID 설정
    res.cookie('sessionId', sessionId, {
      httpOnly: true,
      secure: true,
      sameSite: 'none',
      path: '/',
    });
  }
}

private async invalidateExistingSessions(loginId: string) {
  let cursor = '0';
  do {
    const [newCursor, keys] = await this.redisService.scan(
      cursor,
      'session:auth:*',
      100,
    );
    cursor = newCursor;

    if (!keys.length) break;

    const values = await this.redisService.mget(...keys);
    for (let i = 0; i < keys.length; i++) {
      if (values[i] === loginId) {
        await this.redisService.del(keys[i]);
        return; // 관리자는 한 명당 하나의 세션만 있으므로
      }
    }
  } while (cursor !== '0');
}

// 로그인 시 양방향 매핑
await this.redisService.set(`session:auth:${sessionId}`, loginId, 'EX', SESSION_TTL);
await this.redisService.set(`session:reverse:${loginId}`, sessionId, 'EX', SESSION_TTL);

// 기존 세션 삭제 시
const oldSession = await this.redisService.get(`session:reverse:${loginId}`);
if (oldSession) {
  await this.redisService.del(`session:auth:${oldSession}`);
}

const cookieOptions = {
  httpOnly: true,    // JavaScript에서 접근 불가
  secure: true,      // HTTPS에서만 전송
  sameSite: 'none',  // 크로스 사이트 요청에서도 전송
  path: '/',         // 모든 경로에서 유효
};

// httpOnly: true이면 이게 동작하지 않음
console.log(document.cookie); // sessionId가 보이지 않음

export const cookieConfig = {
  production: {
    httpOnly: true,
    secure: true,
    sameSite: 'none' as const,
    path: '/',
  },
  development: {
    httpOnly: true,
    secure: false,
    sameSite: 'lax' as const,
    path: '/',
  },
};

// 사용 시
res.cookie('sessionId', sessionId, cookieConfig[process.env.NODE_ENV]);

@Injectable()
export class AdminAuthGuard implements CanActivate {
  constructor(private readonly redisService: RedisService) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const request = context.switchToHttp().getRequest<Request>();
    const sid = request.cookies['sessionId'];

    if (!sid) {
      throw new UnauthorizedException('세션 ID가 없습니다.');
    }

    const loginId = await this.redisService.get(`session:auth:${sid}`);

    if (!loginId) {
      throw new UnauthorizedException('인증되지 않은 요청입니다.');
    }

    // 인증된 사용자 정보를 request에 주입
    request['user'] = { loginId };

    return true;
  }
}

@Controller('admin')
export class AdminController {
  @Get('dashboard')
  @UseGuards(AdminAuthGuard)
  getDashboard(@Req() req: Request) {
    const { loginId } = req['user'];
    return { message: `Welcome, ${loginId}` };
  }
}

// 특정 컨트롤러 전체에 적용
@Controller('admin')
@UseGuards(AdminAuthGuard)
export class AdminController {
  // 이 컨트롤러의 모든 핸들러에 Guard 적용
}

// 전역 적용 (main.ts)
app.useGlobalGuards(new AdminAuthGuard(redisService));

async logout(req: Request, res: Response) {
  const sid = req.cookies['sessionId'];

  if (sid) {
    await this.redisService.del(`session:auth:${sid}`);
  }

  res.clearCookie('sessionId');
}