JWT vs. OAuth 2.0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

// JWT 인증 구현 예시
const jwt = require('jsonwebtoken');
const express = require('express');
const app = express();

// 비밀키 - 실제로는 환경 변수로 관리해야 함
const SECRET_KEY = 'your_jwt_secret';

app.use(express.json());

// 로그인 라우트
app.post('/login', (req, res) => {
  // 사용자 인증 로직 (데이터베이스 조회 등)
  const user = { id: 1, username: 'test_user', role: 'admin' };
  
  // JWT 토큰 생성
  const token = jwt.sign(
    { 
      userId: user.id,
      username: user.username,
      role: user.role 
    },
    SECRET_KEY,
    { 
      expiresIn: '1h',  // 토큰 만료 시간
      issuer: 'myapp'   // 발행자
    }
  );
  
  // 클라이언트에 토큰 반환
  res.json({ token });
});

// 인증 미들웨어
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({ message: '인증 토큰이 필요합니다' });
  }
  
  // 토큰 검증
  jwt.verify(token, SECRET_KEY, (err, decoded) => {
    if (err) {
      // 토큰 검증 실패
      return res.status(403).json({ message: '유효하지 않은 토큰입니다' });
    }
    
    // 검증 성공 시 요청 객체에 사용자 정보 추가
    req.user = decoded;
    next();
  });
}

// 보호된 라우트
app.get('/protected', authenticateToken, (req, res) => {
  res.json({ 
    message: '인증된 사용자입니다!', 
    user: req.user 
  });
});

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

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

// OAuth 2.0 인가 코드 흐름 구현 예시
const express = require('express');
const axios = require('axios');
const crypto = require('crypto');
const app = express();

// OAuth 설정 - 실제로는 환경 변수로 관리해야 함
const CLIENT_ID = 'your_client_id';
const CLIENT_SECRET = 'your_client_secret';
const REDIRECT_URI = 'http://localhost:3000/callback';
const AUTH_SERVER_URL = 'https://authorization-server.com';

// 상태 값 저장을 위한 임시 저장소 (실제로는 Redis 등 사용)
const stateSessions = {};

app.get('/', (req, res) => {
  // CSRF 방지를 위한 상태 값 생성
  const state = crypto.randomBytes(16).toString('hex');
  
  // 상태 값을 세션에 저장
  stateSessions[state] = { created: new Date() };
  
  // 인가 서버로 리디렉션할 URL 생성
  const authorizationUrl = new URL(`${AUTH_SERVER_URL}/authorize`);
  authorizationUrl.searchParams.append('response_type', 'code');
  authorizationUrl.searchParams.append('client_id', CLIENT_ID);
  authorizationUrl.searchParams.append('redirect_uri', REDIRECT_URI);
  authorizationUrl.searchParams.append('scope', 'read profile');
  authorizationUrl.searchParams.append('state', state);
  
  // 사용자를 인가 서버로 리디렉션
  res.redirect(authorizationUrl.toString());
});

// 콜백 처리
app.get('/callback', async (req, res) => {
  const { code, state, error } = req.query;
  
  // 에러 처리
  if (error) {
    return res.status(400).json({ error: error });
  }
  
  // 상태 값 검증
  if (!state || !stateSessions[state]) {
    return res.status(400).json({ error: '유효하지 않은 상태 값입니다' });
  }
  
  // 상태 값 세션 삭제 (1회성)
  delete stateSessions[state];
  
  try {
    // 인가 코드를 액세스 토큰으로 교환
    const tokenResponse = await axios.post(`${AUTH_SERVER_URL}/token`, {
      grant_type: 'authorization_code',
      code: code,
      redirect_uri: REDIRECT_URI,
      client_id: CLIENT_ID,
      client_secret: CLIENT_SECRET
    }, {
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      }
    });
    
    // 토큰 정보 추출
    const { access_token, refresh_token, expires_in } = tokenResponse.data;
    
    // 사용자 정보 요청 (액세스 토큰 사용)
    const userResponse = await axios.get(`${AUTH_SERVER_URL}/userinfo`, {
      headers: {
        'Authorization': `Bearer ${access_token}`
      }
    });
    
    // 사용자 정보와 토큰 반환
    res.json({
      user: userResponse.data,
      tokens: {
        access_token,
        refresh_token,
        expires_in
      }
    });
    
  } catch (error) {
    res.status(500).json({
      error: '토큰 교환 중 오류가 발생했습니다',
      details: error.message
    });
  }
});

// 토큰 갱신 엔드포인트
app.post('/refresh-token', async (req, res) => {
  const { refresh_token } = req.body;
  
  if (!refresh_token) {
    return res.status(400).json({ error: '리프레시 토큰이 필요합니다' });
  }
  
  try {
    // 리프레시 토큰을 사용하여 새 액세스 토큰 요청
    const response = await axios.post(`${AUTH_SERVER_URL}/token`, {
      grant_type: 'refresh_token',
      refresh_token: refresh_token,
      client_id: CLIENT_ID,
      client_secret: CLIENT_SECRET
    }, {
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      }
    });
    
    // 새 토큰 정보 반환
    res.json(response.data);
    
  } catch (error) {
    res.status(500).json({
      error: '토큰 갱신 중 오류가 발생했습니다',
      details: error.message
    });
  }
});

app.listen(3000, () => {
  console.log('OAuth 클라이언트가 3000번 포트에서 실행 중입니다');
});