동시 로그인 방지 구현 가이드 — IP·세션·JWT·Nginx 계층별 전략과 실전 코드

1. 로그인 → 세션 생성 → Redis에 user:{userId}:sessions = {sessionId}
2. 새 로그인 발생 → 기존 세션 ID 조회 → 기존 세션 무효화(삭제)
3. 기존 기기에서 요청 → 세션 없음 → 401 + "다른 곳에서 로그인됨" 메시지

1. 로그인 → access_token + refresh_token 발급
2. refresh_token을 서버 DB/Redis에 저장 (user_id → token_family)
3. 새 기기 로그인 → 새 token_family 발급 + 기존 family 전체 폐기
4. 기존 기기가 refresh 시도 → family가 폐기됨 → 401 + 재로그인 유도

# Rate Limiting — 동일 IP에서의 과도한 요청 제한
limit_req_zone $binary_remote_addr zone=login:10m rate=5r/s;

server {
    location /api/auth/login {
        limit_req zone=login burst=10 nodelay;
        proxy_pass http://backend;
    }
}

# IP 기반 접근 제어
geo $blocked {
    default 0;
    10.0.0.0/8 0;      # 내부망 허용
    192.168.0.0/16 0;   # 내부망 허용
    # 특정 악성 IP 차단
    203.0.113.50 1;
}

server {
    if ($blocked) {
        return 403;
    }
}

# 국가별 차단 (GeoIP2 모듈)
geoip2 /etc/nginx/GeoLite2-Country.mmdb {
    $geoip2_country_code country iso_code;
}

map $geoip2_country_code $allowed_country {
    KR 1;
    US 1;
    JP 1;
    default 0;
}

-- OpenResty + Lua 예시: JWT에서 user_id 추출 후 Redis 세션 검증
local jwt = require "resty.jwt"
local redis = require "resty.redis"

local token = ngx.var.http_authorization:sub(8) -- "Bearer " 제거
local jwt_obj = jwt:load_jwt(token)

if jwt_obj.valid then
    local red = redis:new()
    red:connect("127.0.0.1", 6379)
    local active_session = red:get("user:" .. jwt_obj.payload.sub .. ":session")
    if active_session ~= jwt_obj.payload.jti then
        ngx.status = 401
        ngx.say('{"error": "session_expired", "message": "다른 곳에서 로그인되었습니다"}')
        return ngx.exit(401)
    end
end

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .sessionManagement(session -> session
                .maximumSessions(1)                    // 최대 1개 세션
                .maxSessionsPreventsLogin(false)        // false: 기존 세션 만료 (기본)
                                                       // true: 새 로그인 차단
                .expiredSessionStrategy(event -> {
                    HttpServletResponse response = event.getResponse();
                    response.setStatus(401);
                    response.setContentType("application/json;charset=UTF-8");
                    response.getWriter().write(
                        "{\"error\":\"session_expired\",\"message\":\"다른 곳에서 로그인되었습니다\"}"
                    );
                })
            );
        return http.build();
    }

    // 분산 환경에서는 Spring Session + Redis 사용
    @Bean
    public SessionRegistry sessionRegistry() {
        return new SpringSessionBackedSessionRegistry<>(this.sessionRepository);
    }

    @Autowired
    private FindByIndexNameSessionRepository<?> sessionRepository;
}

<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-data-redis</artifactId>
</dependency>

# middleware.py
import redis
from django.conf import settings
from django.contrib.auth import logout

r = redis.Redis(host=settings.REDIS_HOST, port=6379, db=0, decode_responses=True)

ACTIVE_SESSION_PREFIX = "user:active_session:"

class SingleSessionMiddleware:
    """한 계정에 하나의 세션만 허용하는 미들웨어"""

    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if request.user.is_authenticated:
            key = f"{ACTIVE_SESSION_PREFIX}{request.user.id}"
            current_session = request.session.session_key
            active_session = r.get(key)

            if active_session and active_session != current_session:
                # 현재 세션이 활성 세션이 아님 → 강제 로그아웃
                logout(request)
                from django.http import JsonResponse
                return JsonResponse(
                    {"error": "session_expired",
                     "message": "다른 곳에서 로그인되었습니다"},
                    status=401
                )

        return self.get_response(request)

# signals.py — 로그인 시 활성 세션 등록
from django.contrib.auth.signals import user_logged_in
from django.dispatch import receiver

@receiver(user_logged_in)
def register_active_session(sender, request, user, **kwargs):
    key = f"user:active_session:{user.id}"
    # 기존 세션 삭제 (Django session store에서)
    old_session_key = r.get(key)
    if old_session_key:
        from django.contrib.sessions.models import Session
        Session.objects.filter(session_key=old_session_key).delete()

    # 새 세션 등록
    r.set(key, request.session.session_key, ex=settings.SESSION_COOKIE_AGE)

// Node.js / Express 예시
const redis = require('ioredis')
const jwt = require('jsonwebtoken')
const crypto = require('crypto')

const client = new redis()

async function login(userId, deviceId) {
  const tokenFamily = crypto.randomUUID()
  const jti = crypto.randomUUID()

  // 기존 token family 폐기
  const oldFamily = await client.get(`user:${userId}:token_family`)
  if (oldFamily) {
    await client.del(`token_family:${oldFamily}`)
  }

  // 새 token family 등록
  await client.set(`user:${userId}:token_family`, tokenFamily, 'EX', 86400 * 7)
  await client.set(
    `token_family:${tokenFamily}`,
    JSON.stringify({
      userId,
      deviceId,
      jti,
      rotationCount: 0,
    }),
    'EX',
    86400 * 7
  )

  const accessToken = jwt.sign({ sub: userId, jti, device_id: deviceId }, process.env.JWT_SECRET, {
    expiresIn: '15m',
  })

  const refreshToken = jwt.sign(
    { sub: userId, family: tokenFamily, jti: crypto.randomUUID() },
    process.env.JWT_REFRESH_SECRET,
    { expiresIn: '7d' }
  )

  return { accessToken, refreshToken }
}

async function refresh(refreshToken) {
  const decoded = jwt.verify(refreshToken, process.env.JWT_REFRESH_SECRET)
  const familyData = await client.get(`token_family:${decoded.family}`)

  if (!familyData) {
    // Token family가 폐기됨 → 탈취 의심 → 모든 세션 무효화
    await client.del(`user:${decoded.sub}:token_family`)
    throw new Error('TOKEN_FAMILY_REVOKED')
  }

  const family = JSON.parse(familyData)

  // Rotation: 새 토큰 발급 + 기존 refresh 무효화
  const newJti = crypto.randomUUID()
  family.jti = newJti
  family.rotationCount += 1

  await client.set(`token_family:${decoded.family}`, JSON.stringify(family), 'EX', 86400 * 7)

  const newAccessToken = jwt.sign(
    { sub: decoded.sub, jti: newJti, device_id: family.deviceId },
    process.env.JWT_SECRET,
    { expiresIn: '15m' }
  )

  const newRefreshToken = jwt.sign(
    { sub: decoded.sub, family: decoded.family, jti: crypto.randomUUID() },
    process.env.JWT_REFRESH_SECRET,
    { expiresIn: '7d' }
  )

  return { accessToken: newAccessToken, refreshToken: newRefreshToken }
}

# /etc/nginx/conf.d/security.conf

# 로그인 엔드포인트 Rate Limit
limit_req_zone $binary_remote_addr zone=auth_limit:10m rate=5r/s;

# 전역 연결 제한
limit_conn_zone $binary_remote_addr zone=conn_limit:10m;

# 의심 IP 맵
map $remote_addr $is_suspicious {
    default 0;
    ~^192\.168\.100\. 1;  # 예시: 내부 테스트 대역 차단
}

server {
    listen 443 ssl;
    server_name api.example.com;

    # 로그인 엔드포인트
    location /api/auth/login {
        limit_req zone=auth_limit burst=10 nodelay;
        limit_conn conn_limit 10;

        if ($is_suspicious) {
            return 403;
        }

        proxy_pass http://backend;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    # 인증 필요 API — 앱에서 세션/토큰 검증
    location /api/ {
        proxy_pass http://backend;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

┌────────────────────────────────────────────────┐
│                  클라이언트                       │
│  (브라우저/앱 — device_id, fingerprint 생성)      │
└─────────────────────┬──────────────────────────┘
                      │
┌─────────────────────▼──────────────────────────┐
│              Nginx / L7 Proxy                    │
│  ✅ Rate Limit (login brute-force 방어)          │
│  ✅ IP 차단 (geo, deny)                         │
│  ✅ 기본 헤더 검증                               │
│  ❌ 세션 유효성 판단 (앱 역할)                    │
└─────────────────────┬──────────────────────────┘
                      │
┌─────────────────────▼──────────────────────────┐
│           인증 서버 / API Gateway                 │
│  ✅ JWT 검증 (서명, 만료, jti 블랙리스트)         │
│  ✅ session_version 비교                         │
│  ✅ Refresh Token Rotation 관리                  │
│  ✅ 동시 세션 수 정책 판단                        │
└─────────────────────┬──────────────────────────┘
                      │
┌─────────────────────▼──────────────────────────┐
│              세션/토큰 저장소 (Redis)              │
│  - user:{id}:sessions → Set<sessionId>           │
│  - user:{id}:token_family → familyId             │
│  - token_family:{id} → {userId, deviceId, jti}   │
│  - blacklist:jti:{jti} → TTL                     │
└──────────────────────────────────────────────────┘

원인: VPN 연결 시 IP가 VPN 게이트웨이 IP로 변경
해결: IP 변경만으로는 세션을 끊지 않고, refresh token이 유효하면 세션 유지
      + IP 변경 이벤트를 감사 로그에만 기록

{
  "concurrent_session_policy": {
    "max_total": 5,
    "per_device_type": {
      "web_browser": 2,
      "mobile_app": 2,
      "tablet_app": 1
    },
    "on_exceed": "expire_oldest",
    "admin_override": true
  }
}

# 예시: 디바이스 유형별 슬롯 관리
def check_session_limit(user_id, device_type, new_session_id):
    key = f"user:{user_id}:sessions:{device_type}"
    sessions = redis.lrange(key, 0, -1)
    max_slots = POLICY['per_device_type'].get(device_type, 1)

    if len(sessions) >= max_slots:
        if POLICY['on_exceed'] == 'expire_oldest':
            oldest = redis.lpop(key)
            invalidate_session(oldest)  # 가장 오래된 세션 만료
        elif POLICY['on_exceed'] == 'deny_new':
            raise SessionLimitExceeded()

    redis.rpush(key, new_session_id)
    redis.expire(key, SESSION_TTL)