Cookie-Based Authentication

 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

const express = require('express');
const session = require('express-session');
const bcrypt = require('bcrypt');
const app = express();

// 세션 미들웨어 설정
app.use(session({
  secret: '안전한_랜덤_문자열', // 세션 데이터 서명용 비밀 키
  resave: false,             // 세션이 변경되지 않아도 저장할지 여부
  saveUninitialized: false,  // 초기화되지 않은 세션도 저장할지 여부
  cookie: {
    httpOnly: true,          // JavaScript에서 쿠키 접근 방지
    secure: process.env.NODE_ENV === 'production', // HTTPS에서만 쿠키 전송
    maxAge: 1000 * 60 * 60 * 24, // 쿠키 유효 기간 (1일)
    sameSite: 'lax'          // CSRF 방지를 위한 SameSite 설정
  }
}));

// 사용자 로그인 처리
app.post('/login', async (req, res) => {
  const { username, password } = req.body;
  
  // 사용자 정보 조회 (실제로는 데이터베이스에서 조회)
  const user = await findUserByUsername(username);
  
  if (!user) {
    return res.status(401).json({ error: '사용자를 찾을 수 없습니다' });
  }
  
  // 비밀번호 검증
  const isPasswordValid = await bcrypt.compare(password, user.passwordHash);
  
  if (!isPasswordValid) {
    return res.status(401).json({ error: '비밀번호가 일치하지 않습니다' });
  }
  
  // 세션에 사용자 정보 저장 (민감한 정보 제외)
  req.session.user = {
    id: user.id,
    username: user.username,
    role: user.role
  };
  
  // 로그인 성공 응답
  res.json({ success: true, user: req.session.user });
});

// 인증된 사용자만 접근할 수 있는 라우트 보호
function requireAuth(req, res, next) {
  if (!req.session.user) {
    return res.status(401).json({ error: '인증이 필요합니다' });
  }
  next();
}

// 보호된 라우트 예시
app.get('/profile', requireAuth, (req, res) => {
  res.json({ user: req.session.user });
});

// 로그아웃 처리
app.post('/logout', (req, res) => {
  req.session.destroy(err => {
    if (err) {
      return res.status(500).json({ error: '로그아웃 처리 중 오류가 발생했습니다' });
    }
    res.clearCookie('connect.sid'); // 세션 쿠키 삭제
    res.json({ success: true });
  });
});

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

// 로그인 요청 함수
async function login(username, password) {
  try {
    const response = await fetch('/login', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ username, password }),
      credentials: 'same-origin' // 쿠키가 요청과 함께 전송되도록 설정
    });
    
    const data = await response.json();
    
    if (!response.ok) {
      throw new Error(data.error || '로그인에 실패했습니다');
    }
    
    // 로그인 성공 처리
    console.log('로그인 성공:', data.user);
    return data.user;
  } catch (error) {
    console.error('로그인 오류:', error);
    throw error;
  }
}

// 보호된 라우트 데이터 요청 함수
async function fetchProfile() {
  try {
    const response = await fetch('/profile', {
      credentials: 'same-origin' // 쿠키가 요청과 함께 전송되도록 설정
    });
    
    if (!response.ok) {
      if (response.status === 401) {
        // 인증되지 않은 상태 처리
        window.location.href = '/login-page';
        return;
      }
      throw new Error('프로필 데이터 요청 실패');
    }
    
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('프로필 요청 오류:', error);
    throw error;
  }
}

// 로그아웃 함수
async function logout() {
  try {
    const response = await fetch('/logout', {
      method: 'POST',
      credentials: 'same-origin'
    });
    
    const data = await response.json();
    
    if (data.success) {
      // 로그아웃 후 처리 (예: 로그인 페이지로 리디렉션)
      window.location.href = '/login-page';
    }
  } catch (error) {
    console.error('로그아웃 오류:', error);
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// CSRF 토큰 구현 예시 (Express)
const csrf = require('csurf');
const csrfProtection = csrf({ cookie: true });

// CSRF 보호가 필요한 라우트에 미들웨어 적용
app.get('/form', csrfProtection, (req, res) => {
  // CSRF 토큰을 폼에 포함
  res.render('form', { csrfToken: req.csrfToken() });
});

app.post('/process', csrfProtection, (req, res) => {
  // CSRF 토큰이 유효한 경우에만 처리
  // 처리 로직…
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 안전한 쿠키 설정 예시
app.use(session({
  // … 기타 옵션 …
  cookie: {
    httpOnly: true,           // JavaScript에서 쿠키 접근 방지
    secure: true,             // HTTPS에서만 쿠키 전송
    sameSite: 'strict',       // 동일 사이트 요청에서만 쿠키 전송
    domain: 'example.com',    // 특정 도메인에서만 유효
    path: '/',                // 모든 경로에서 유효
    maxAge: 3600000           // 1시간 후 만료
  }
}));

 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

// 세션 하이재킹 방지 예시 (Express)
app.use(session({
  // … 기타 옵션 …
  rolling: true,              // 각 요청마다 세션 쿠키 갱신
  regenerate: true,           // 주기적으로 세션 ID 재생성
  saveUninitialized: false    // 초기화되지 않은 세션 저장 방지
}));

// 사용자 IP 또는 사용자 에이전트 변경 감지
app.use((req, res, next) => {
  const currentIp = req.ip;
  const currentUserAgent = req.headers['user-agent'];
  
  if (req.session.user) {
    // 첫 로그인 시 IP와 사용자 에이전트 저장
    if (!req.session.ip) {
      req.session.ip = currentIp;
      req.session.userAgent = currentUserAgent;
    }
    
    // 이전 세션 정보와 비교
    if (req.session.ip !== currentIp || req.session.userAgent !== currentUserAgent) {
      console.warn('잠재적 세션 하이재킹 시도 감지');
      return req.session.destroy(() => {
        res.redirect('/login');
      });
    }
  }
  
  next();
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

const session = require('express-session');
const RedisStore = require('connect-redis')(session);
const redis = require('redis');
const redisClient = redis.createClient();

app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: '안전한_비밀_키',
  resave: false,
  saveUninitialized: false,
  cookie: { /* 보안 설정 */ }
}));

 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

// JWT를 HTTP-only 쿠키에 저장하는 예시
app.post('/login', (req, res) => {
  // 인증 로직…
  
  const token = jwt.sign({ userId: user.id }, 'secret_key', { expiresIn: '1h' });
  
  res.cookie('token', token, {
    httpOnly: true,
    secure: true,
    sameSite: 'strict',
    maxAge: 3600000 // 1시간
  });
  
  res.json({ success: true });
});

// 미들웨어에서 쿠키로부터 JWT 검증
app.use((req, res, next) => {
  const token = req.cookies.token;
  
  if (!token) {
    return res.status(401).json({ error: '인증이 필요합니다' });
  }
  
  try {
    const decoded = jwt.verify(token, 'secret_key');
    req.user = decoded;
    next();
  } catch (err) {
    return res.status(401).json({ error: '유효하지 않은 토큰입니다' });
  }
});