Node.js 인증 시스템 구축기 (2편) - 보안 강화와 고급 기능

🛡️ 다층 보안 시스템

1편에서 다룬 JWT 토큰 시스템을 기반으로, 이번 편에서는 실전에서 꼭 필요한 보안 기능들과 확장 가능한 고급 기능들을 살펴보겠습니다. 현대적인 웹 애플리케이션은 단순한 인증을 넘어 다양한 보안 위협에 대한 종합적인 대응이 필요합니다.

🚫 Rate Limiting - API 남용 방지

전역 Rate Limiting

// index.js에서 전역 Rate Limiting 설정
const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
    windowMs: 15 * 60 * 1000,    // 15분 시간 창
    max: 100,                    // IP당 최대 100회 요청
    message: {
        success: false,
        message: '너무 많은 요청입니다. 잠시 후 다시 시도해주세요.'
    },
    standardHeaders: true,        // `RateLimit-*` 헤더 추가
    legacyHeaders: false,        // `X-RateLimit-*` 헤더 비활성화
});

app.use(limiter);

로그인 전용 Rate Limiting

로그인 엔드포인트에는 더욱 엄격한 제한을 적용합니다:

// authRoutes.js에서 로그인 전용 리미터
const loginLimiter = rateLimit({
    windowMs: 15 * 60 * 1000,    // 15분
    max: 5,                      // 최대 5회 시도
    message: { 
        success: false,
        message: '너무 많은 로그인 시도. 15분 후에 다시 시도하세요.'
    },
    skipSuccessfulRequests: true,  // 성공한 요청은 카운트에서 제외
});

// 로그인 라우트에 적용
router.post('/login', loginValidator, loginLimiter, authController.login);

계정별 브루트포스 방지

IP 기반 제한과 함께 계정별 잠금 시스템도 구현했습니다:

// User 모델에 브루트포스 방지 필드
const UserSchema = new mongoose.Schema({
    loginAttempts: { type: Number, default: 0 },
    lockUntil: { type: Number, default: 0 },
    // ... 기타 필드
});

// 로그인 실패 처리 로직
if (!isMatch) {
    user.loginAttempts += 1;
    
    // 🔒 5회 실패 시 30분 잠금
    if (user.loginAttempts >= 5) {
        user.lockUntil = Date.now() + 30 * 60 * 1000;
        user.loginAttempts = 0;
        
        logger.security('계정 잠금 발생', {
            userId: user._id,
            email: user.email,
            ip: req.ip,
            attempts: user.loginAttempts
        });
    }
    
    await user.save();
    return res.status(401).json({
        success: false,
        message: '이메일 또는 비밀번호가 올바르지 않습니다.'
    });
}

// ✅ 로그인 성공 시 잠금 해제
user.loginAttempts = 0;
user.lockUntil = undefined;
await user.save();

🔐 CSRF 보호 - 크로스사이트 요청 위조 방지

선택적 CSRF 보호

모든 엔드포인트에 CSRF 보호를 적용하면 사용성이 떨어질 수 있어, 선택적 보호 전략을 채택했습니다:

// index.js에서 CSRF 설정
const csrf = require('csurf');

const csrfProtection = csrf({
    cookie: {
        httpOnly: true,
        secure: process.env.NODE_ENV === 'production',
        sameSite: 'strict'
    }
});

// 🎫 CSRF 토큰 제공 엔드포인트
app.get('/api/csrf-token', csrfProtection, (req, res) => {
    res.json({ csrfToken: req.csrfToken() });
});

// 🛡️ 민감한 작업에만 CSRF 보호 적용
// router.post('/register', csrfProtection, registerValidator, authController.register);
// router.post('/login', csrfProtection, loginValidator, loginLimiter, authController.login);

CSRF 에러 처리

// 전역 에러 핸들러에서 CSRF 에러 처리
app.use((err, req, res, next) => {
    if (err.code === 'EBADCSRFTOKEN') {
        return res.status(403).json({ 
            message: 'CSRF 토큰이 유효하지 않습니다.',
            hint: 'CSRF 토큰을 /api/csrf-token에서 받아서 X-CSRF-TOKEN 헤더에 포함하세요.'
        });
    }
    // 기타 에러 처리...
});

🌐 CORS 설정 - 안전한 크로스 오리진 요청

동적 Origin 검증

// index.js에서 CORS 설정
const allowedOrigins = [
    'http://localhost:3000',
    'http://localhost:8080',
    'http://localhost:8081',
    process.env.CLIENT_URL
].filter(Boolean);

app.use(cors({
    origin: function (origin, callback) {
        // 🔧 개발 환경에서는 origin이 undefined일 수 있음
        if (!origin && process.env.NODE_ENV === 'development') {
            return callback(null, true);
        }

        if (allowedOrigins.includes(origin)) {
            callback(null, true);
        } else {
            console.log('CORS 차단된 도메인:', origin);
            callback(new Error('CORS 정책에 의해 차단됨'));
        }
    },
    credentials: true,                              // 쿠키 포함 요청 허용
    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
    allowedHeaders: ['Content-Type', 'Authorization', 'X-CSRF-TOKEN']
}));

👤 소셜 로그인 구현 - Passport.js 전략

Passport 전략 설정

// config/passport.js
const passport = require('passport');
const { Strategy: JwtStrategy, ExtractJwt } = require('passport-jwt');
const KakaoStrategy = require('passport-kakao').Strategy;
const NaverStrategy = require('passport-naver').Strategy;

// 🔑 JWT 전략
const jwtOptions = {
    jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
    secretOrKey: process.env.JWT_SECRET
};

passport.use(new JwtStrategy(jwtOptions, async (payload, done) => {
    try {
        const user = await User.findById(payload.id);
        return user ? done(null, user) : done(null, false);
    } catch (error) {
        return done(error, false);
    }
}));

// 🟡 카카오 로그인 전략
passport.use(new KakaoStrategy({
    clientID: process.env.KAKAO_CLIENT_ID,
    callbackURL: process.env.KAKAO_CALLBACK_URL
}, async (accessToken, refreshToken, profile, done) => {
    try {
        // 기존 사용자 찾기
        let user = await User.findOne({ kakaoId: profile.id });

        if (!user) {
            // 🆕 새 사용자 생성
            user = await User.create({
                name: profile.displayName || profile.username,
                email: profile._json.kakao_account.email,
                kakaoId: profile.id,
                termsAgree: true    // 소셜 로그인 시 약관 동의 처리
            });
        }

        return done(null, user);
    } catch (error) {
        return done(error, false);
    }
}));

// 🟢 네이버 로그인 전략
passport.use(new NaverStrategy({
    clientID: process.env.NAVER_CLIENT_ID,
    clientSecret: process.env.NAVER_CLIENT_SECRET,
    callbackURL: process.env.NAVER_CALLBACK_URL
}, async (accessToken, refreshToken, profile, done) => {
    try {
        let user = await User.findOne({ naverId: profile.id });

        if (!user) {
            user = await User.create({
                name: profile.displayName,
                email: profile.emails[0].value,
                naverId: profile.id,
                termsAgree: true
            });
        }

        return done(null, user);
    } catch (error) {
        return done(error, false);
    }
}));

소셜 로그인 콜백 처리

// authController.js에서 카카오 콜백 처리
exports.kakaoCallback = async (req, res) => {
    try {
        const user = req.user;

        // 🎫 토큰 생성
        const accessToken = generateAccessToken(user._id);
        const refreshToken = generateRefreshToken(user._id);

        // 💾 리프레시 토큰 DB 저장
        await RefreshToken.create({
            user: user._id,
            token: refreshToken,
            ip: req.ip,
            userAgent: req.get('User-Agent') || 'Unknown',
            expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
        });

        // 🍪 HTTP-only 쿠키 설정
        res.cookie('refreshToken', refreshToken, {
            httpOnly: true,
            secure: process.env.NODE_ENV === 'production',
            sameSite: 'strict',
            maxAge: 7 * 24 * 60 * 60 * 1000
        });

        // 🔄 프론트엔드로 리다이렉트 (토큰과 함께)
        res.redirect(`${process.env.CLIENT_URL}/?token=${accessToken}&social=kakao`);
        
    } catch (error) {
        logger.logError('카카오 로그인 콜백 오류', error, {
            ip: req.ip,
            userAgent: req.headers['user-agent']
        });
        res.redirect(`${process.env.CLIENT_URL}/login?error=kakao_login_failed`);
    }
};

✅ 포괄적인 유효성 검증

강력한 비밀번호 정책

// middleware/validators.js
const passwordStrengthCheck = (value) => {
    // 최소 8자, 대소문자, 숫자, 특수문자 각 1개 이상
    const strongPasswordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
    
    if (!strongPasswordRegex.test(value)) {
        throw new Error('비밀번호는 최소 8자 이상이며, 대문자, 소문자, 숫자, 특수문자를 각각 하나 이상 포함해야 합니다.');
    }
    
    // 🚫 일반적인 패턴 차단
    const commonPatterns = ['123456', 'password', 'qwerty', 'admin', '111111'];
    if (commonPatterns.some(pattern => value.toLowerCase().includes(pattern))) {
        throw new Error('흔히 사용되는 비밀번호 패턴이 포함되어 있습니다.');
    }
    
    return true;
};

// 🚫 금지어 검사
const forbiddenWordsCheck = (value) => {
    const forbiddenWords = ['비속어', '욕설', 'badword'];
    
    if (forbiddenWords.some(word => value.toLowerCase().includes(word))) {
        throw new Error('부적절한 단어가 포함되어 있습니다.');
    }
    
    return true;
};

회원가입 유효성 검증

const registerValidator = [
    body('name')
        .notEmpty().withMessage('이름은 필수 입력사항입니다.')
        .isLength({ min: 2, max: 50}).withMessage('이름은 2~50자 사이여야 합니다.')
        .trim()
        .escape()                           // HTML 이스케이프
        .custom(forbiddenWordsCheck),

    body('email')
        .notEmpty().withMessage('이메일은 필수 입력사항입니다.')
        .isEmail().withMessage('유효한 이메일 형식이 아닙니다.')
        .normalizeEmail(),                  // 이메일 정규화

    body('password')
        .notEmpty().withMessage('비밀번호는 필수 입력사항입니다.')
        .isLength({ min: 8 }).withMessage('비밀번호는 최소 8자 이상이어야 합니다.')
        .matches(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])/)
        .withMessage('비밀번호는 대문자, 소문자, 숫자, 특수문자를 각각 하나 이상 포함해야 합니다.')
        .custom(passwordStrengthCheck),

    body('confirmPassword')
        .custom((value, { req }) => {
            if (value !== req.body.password) {
                throw new Error('비밀번호와 비밀번호 확인이 일치하지 않습니다.');
            }
            return true;
        }),

    body('phone')
        .optional()
        .isMobilePhone('ko-KR').withMessage('유효한 한국 전화번호 형식이 아닙니다.'),

    body('termsAgree')
        .isBoolean()
        .custom(value => {
            if (value !== true) {
                throw new Error('서비스 이용을 위해 약관에 동의해야 합니다.');
            }
            return true;
        }),

    validate  // 유효성 검사 결과 확인 미들웨어
];

로그인 이메일 정규화

const loginValidator = [
    body('email')
        .notEmpty().withMessage('이메일은 필수 입력사항입니다.')
        .isEmail().withMessage('유효한 이메일 형식이 아닙니다.')
        .normalizeEmail({
            gmail_remove_dots: false,           // Gmail의 점 제거 안함
            gmail_remove_subaddress: true,      // +부분 제거
            all_lowercase: true,                // 소문자 변환
            gmail_convert_googlemaildotcom: true // googlemail.com → gmail.com
        }),

    body('password')
        .notEmpty().withMessage('비밀번호는 필수 입력사항입니다.'),

    validate
];

📊 Winston을 활용한 구조화된 로깅

로그 레벨별 파일 분리

// utils/logger.js
const winston = require('winston');
const { format, transports } = winston;
require('winston-daily-rotate-file');

// 📁 로그 디렉토리 생성
const logDir = 'logs';
if (!fs.existsSync(logDir)) {
    fs.mkdirSync(logDir);
}

// 🎨 커스텀 로그 포맷
const logFormat = format.printf(({ level, message, timestamp, ...meta }) => {
    return `${timestamp} [${level.toUpperCase()}]: ${message} ${
        Object.keys(meta).length ? JSON.stringify(meta, null, 2) : ''
    }`;
});

const logger = winston.createLogger({
    level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
    format: format.combine(
        format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
        format.errors({ stack: true }),
        logFormat
    ),
    defaultMeta: { service: 'guardian-auth' },
    transports: [
        // 🖥️ 콘솔 출력
        new transports.Console({
            format: format.combine(format.colorize(), logFormat)
        }),

        // 📄 일반 로그 (일별 순환)
        new transports.DailyRotateFile({
            filename: path.join(logDir, 'application-%DATE%.log'),
            datePattern: 'YYYY-MM-DD',
            maxSize: '20m',
            maxFiles: '14d',
            level: 'info'
        }),

        // ❌ 에러 로그 (장기 보관)
        new transports.DailyRotateFile({
            filename: path.join(logDir, 'error-%DATE%.log'),
            datePattern: 'YYYY-MM-DD',
            maxSize: '20m',
            maxFiles: '30d',
            level: 'error'
        }),

        // 🔒 보안 이벤트 전용 로그
        new transports.DailyRotateFile({
            filename: path.join(logDir, 'security-%DATE%.log'),
            datePattern: 'YYYY-MM-DD',
            maxSize: '20m',
            maxFiles: '90d',
            level: 'info',
            format: format.combine(
                format.timestamp(),
                format.json(),
                format((info) => info.security ? info : false)()
            )
        })
    ]
});

보안 이벤트 로깅

// 전용 로깅 메서드
logger.logError = (message, error, meta = {}) => {
    logger.error(message, {
        error: {
            message: error.message,
            stack: error.stack
        },
        ...meta
    });
};

logger.security = (message, meta = {}) => {
    logger.info(message, { security: true, ...meta });
};

// 사용 예시 - 의심스러운 토큰 사용
logger.security('유효하지 않은 리프레시 토큰 사용', {
    ip: req.ip,
    userAgent: req.headers['user-agent'],
    tokenFound: !!storedToken,
    tokenRevoked: storedToken ? storedToken.isRevoked : false,
    timestamp: new Date().toISOString()
});

// 사용 예시 - 계정 생성
logger.security('사용자 계정 생성 성공', {
    userId: user._id.toString(),
    email,
    ip: req.ip,
    userAgent: req.headers['user-agent']
});

🔧 보안 헤더와 미들웨어 설정

Helmet을 통한 보안 헤더

// index.js에서 Helmet 설정
const helmet = require('helmet');

// 🛡️ 보안 헤더 설정 (가장 먼저 적용)
app.use(helmet({
    contentSecurityPolicy: {
        directives: {
            defaultSrc: ["'self'"],
            styleSrc: ["'self'", "'unsafe-inline'"],
            scriptSrc: ["'self'"],
            imgSrc: ["'self'", "data:", "https:"]
        }
    },
    hsts: {
        maxAge: 31536000,
        includeSubDomains: true,
        preload: true
    }
}));

요청 로깅 미들웨어

// 상세한 요청 로깅
app.use((req, res, next) => {
    const startTime = Date.now();
    
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.path}`);
    console.log('Origin:', req.headers.origin);
    console.log('User-Agent:', req.headers['user-agent']);
    
    res.on('finish', () => {
        const duration = Date.now() - startTime;
        logger.info('요청 완료', {
            method: req.method,
            path: req.path,
            statusCode: res.statusCode,
            duration: `${duration}ms`,
            ip: req.ip
        });
    });
    
    next();
});

🚀 확장 가능한 에러 처리

중앙화된 에러 핸들링

// 전역 에러 핸들러
app.use((err, req, res, next) => {
    console.error('서버 에러:', err);

    // CSRF 토큰 에러
    if (err.code === 'EBADCSRFTOKEN') {
        return res.status(403).json({ 
            message: 'CSRF 토큰이 유효하지 않습니다.',
            hint: 'CSRF 토큰을 /api/csrf-token에서 받아서 X-CSRF-TOKEN 헤더에 포함하세요.'
        });
    }

    // Mongoose 유효성 검증 에러
    if (err.name === 'ValidationError') {
        const errors = Object.values(err.errors).map(e => e.message);
        return res.status(400).json({
            success: false,
            message: '입력 데이터가 유효하지 않습니다.',
            errors
        });
    }

    // MongoDB 중복 키 에러
    if (err.code === 11000) {
        return res.status(400).json({
            success: false,
            message: '이미 사용 중인 값입니다.'
        });
    }

    // 기본 에러 응답
    res.status(500).json({
        success: false,
        message: '서버 내부 오류가 발생했습니다.',
        error: process.env.NODE_ENV === 'development' ? err.message : '내부 서버 오류'
    });
});

📈 성능 최적화와 모니터링

데이터베이스 인덱스

// User 모델에서 성능 최적화
UserSchema.index({ email: 1 });                    // 이메일 검색 최적화
UserSchema.index({ kakaoId: 1 }, { sparse: true }); // 소셜 ID 검색
UserSchema.index({ naverId: 1 }, { sparse: true });
UserSchema.index({ lastLocation: '2dsphere' });     // 위치 기반 검색
UserSchema.index({ createdAt: 1 });                 // 시간순 정렬

// RefreshToken 모델
RefreshTokenSchema.index({ token: 1 });             // 토큰 검색 최적화
RefreshTokenSchema.index({ user: 1 });              // 사용자별 토큰 조회
RefreshTokenSchema.index({ expiresAt: 1 });         // 만료 토큰 정리

🎯 결론

이번 인증 시스템 구축을 통해 다음과 같은 현대적 보안 요구사항을 모두 만족하는 시스템을 완성했습니다:

✅ 구현된 보안 기능

• 다층 인증 시스템: JWT + Refresh Token
• 브루트포스 방지: Rate Limiting + 계정 잠금
• CSRF 보호: 선택적 토큰 검증
• 소셜 로그인: 안전한 OAuth 구현
• 입력 검증: 포괄적 유효성 검사
• 보안 로깅: 구조화된 이벤트 추적

🚀 확장성 고려사항

• 모듈화된 구조: 기능별 파일 분리
• 환경별 설정: 개발/운영 환경 대응
• 성능 최적화: 데이터베이스 인덱싱
• 모니터링: 상세한 로깅과 에러 추적

💡 실전 적용 팁

1. 보안 정책 수립: 비밀번호 강도, 토큰 만료 시간 등
2. 모니터링 체계: 보안 이벤트 알림 시스템 구축
3. 정기 보안 점검: 로그 분석과 취약점 점검
4. 사용자 교육: 안전한 비밀번호 사용 가이드

이러한 체계적인 접근을 통해 안전하고 확장 가능한 인증 시스템을 구축할 수 있으며, 실제 서비스에서 요구되는 다양한 보안 요구사항을 효과적으로 대응할 수 있습니다.

보안은 한 번 구축하고 끝나는 것이 아니라 지속적으로 개선해야 하는 영역입니다. 새로운 위협에 대응하고 사용자 경험을 개선하기 위해 꾸준한 업데이트와 모니터링이 필요합니다.