์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿ›ก๏ธ ์›น ์Šคํฌ๋ž˜ํ•‘ ๋ฐฉ์ง€์™€ ๋ด‡ ํƒ์ง€๋ฅผ ์œ„ํ•œ ๋ณด์•ˆ ๊ธฐ์ˆ  ๊ตฌํ˜„ ์™„๋ฒฝ ๊ฐ€์ด๋“œ

๐Ÿ›ก๏ธ ์›น ์Šคํฌ๋ž˜ํ•‘ ๋ฐฉ์ง€์™€ ๋ด‡ ํƒ์ง€๋ฅผ ์œ„ํ•œ ๋ณด์•ˆ ๊ธฐ์ˆ  ๊ตฌํ˜„ ์™„๋ฒฝ ๊ฐ€์ด๋“œ

๋‹น์‹ ์˜ ์›น์‚ฌ์ดํŠธ๋ฅผ ์ง€ํ‚ค๋Š” ์ตœ์‹  ๋ฐฉ์–ด ๊ธฐ์ˆ ๋“ค

๐ŸŽฏ ์ด ๊ธ€์—์„œ ๋‹ค๋ฃฐ ๋‚ด์šฉ ์š”์ฆ˜ ์›น์‚ฌ์ดํŠธ ์šด์˜ํ•˜๋‹ค ๋ณด๋ฉด ์ •๋ง ๊ณจ์น˜ ์•„ํ”ˆ ๊ฒŒ ํ•˜๋‚˜ ์žˆ์–ด. ๋ฐ”๋กœ ๋ฌด๋ถ„๋ณ„ํ•œ ์›น ์Šคํฌ๋ž˜ํ•‘๊ณผ ์•…์„ฑ ๋ด‡๋“ค์ด์•ผ! ๐Ÿ˜ค ์—ด์‹ฌํžˆ ๋งŒ๋“  ์ฝ˜ํ…์ธ ๊ฐ€ ์ˆœ์‹๊ฐ„์— ๊ธํ˜€๊ฐ€๊ณ , ์„œ๋ฒ„๋Š” ๊ณผ๋ถ€ํ•˜๋กœ ๋น„๋ช…์„ ์ง€๋ฅด๊ณ ... ์ด๋Ÿฐ ๊ฒฝํ—˜ ์žˆ์ง€? ์˜ค๋Š˜์€ ์ด๋Ÿฐ ๊ณจ์นซ๊ฑฐ๋ฆฌ๋“ค์„ ํšจ๊ณผ์ ์œผ๋กœ ๋ง‰์•„๋‚ด๋Š” ๋ณด์•ˆ ๊ธฐ์ˆ ๋“ค์„ ์นœ๊ตฌ์ฒ˜๋Ÿผ ํŽธํ•˜๊ฒŒ ์•Œ๋ ค์ค„๊ฒŒ. ์‹ค์ „์—์„œ ๋ฐ”๋กœ ์จ๋จน์„ ์ˆ˜ ์žˆ๋Š” ๊ตฌ์ฒด์ ์ธ ๋ฐฉ๋ฒ•๋“ค์ด๋‹ˆ๊นŒ ๋๊นŒ์ง€ ์ง‘์ค‘ํ•ด์ค˜! ๐Ÿ’ช

๐Ÿค” ์›น ์Šคํฌ๋ž˜ํ•‘๊ณผ ๋ด‡, ์™œ ๋ฌธ์ œ๊ฐ€ ๋ ๊นŒ?

๋จผ์ € ๊ธฐ๋ณธ๋ถ€ํ„ฐ ์งš๊ณ  ๋„˜์–ด๊ฐ€์ž. ์›น ์Šคํฌ๋ž˜ํ•‘ ์ž์ฒด๊ฐ€ ๋‚˜์œ ๊ฑด ์•„๋‹ˆ์•ผ. ๊ฒ€์ƒ‰์—”์ง„ ๋ด‡์ฒ˜๋Ÿผ ์ข‹์€ ๋ด‡๋“ค๋„ ๋งŽ๊ฑฐ๋“ . ๋ฌธ์ œ๋Š” ์•…์˜์ ์ธ ๋ชฉ์ ์œผ๋กœ ์‚ฌ์šฉ๋  ๋•Œ์•ผ.

์‹ค์ œ๋กœ ์–ด๋–ค ๋ฌธ์ œ๋“ค์ด ๋ฐœ์ƒํ•˜๋Š”์ง€ ๋ณผ๊นŒ?

๐Ÿ’ธ ๋น„์ฆˆ๋‹ˆ์Šค ์†์‹ค
๊ฒฝ์Ÿ์‚ฌ๊ฐ€ ๋‹น์‹ ์˜ ๊ฐ€๊ฒฉ ์ •๋ณด๋ฅผ ์‹ค์‹œ๊ฐ„์œผ๋กœ ๊ธ์–ด๊ฐ€์„œ ํ•ญ์ƒ ์กฐ๊ธˆ ๋” ์‹ธ๊ฒŒ ํŒ๋‹ค๋ฉด? ์ด์ปค๋จธ์Šค ์—…๊ณ„์—์„œ๋Š” ์‹ค์ œ๋กœ ํ”ํ•œ ์ผ์ด์•ผ. ํ•œ ์˜จ๋ผ์ธ ์‡ผํ•‘๋ชฐ์€ ํ•˜๋ฃจ์— ์ˆ˜๋ฐฑ๋งŒ ๊ฑด์˜ ์Šคํฌ๋ž˜ํ•‘ ์š”์ฒญ์œผ๋กœ ์ธํ•ด ์„œ๋ฒ„ ๋น„์šฉ๋งŒ ์›” ์ˆ˜์ฒœ๋งŒ ์›์ด ์ถ”๊ฐ€๋กœ ๋ฐœ์ƒํ–ˆ๋Œ€.

โšก ์„œ๋ฒ„ ๊ณผ๋ถ€ํ•˜
์ •์ƒ ์‚ฌ์šฉ์ž 100๋ช…์ด ์ ‘์†ํ•  ๋•Œ์™€ ๋ด‡ 10,000๊ฐœ๊ฐ€ ๋™์‹œ์— ํฌ๋กค๋งํ•  ๋•Œ์˜ ์„œ๋ฒ„ ๋ถ€ํ•˜๋Š” ๋น„๊ต๊ฐ€ ์•ˆ ๋ผ. ์‹ค์ œ ์‚ฌ์šฉ์ž๋“ค์€ ๋А๋ฆฐ ์†๋„ ๋•Œ๋ฌธ์— ์ดํƒˆํ•˜๊ณ , ๋‹น์‹ ์€ AWS ์ฒญ๊ตฌ์„œ๋ฅผ ๋ณด๊ณ  ๊ธฐ์ ˆํ•˜๋Š” ๊ฑฐ์ง€. ๐Ÿ˜ฑ

๐Ÿ”’ ๋ฐ์ดํ„ฐ ์œ ์ถœ
ํšŒ์› ์ •๋ณด, ๋…์  ์ฝ˜ํ…์ธ , ๋น„์ฆˆ๋‹ˆ์Šค ๋กœ์ง... ์ด๋Ÿฐ ๊ฒƒ๋“ค์ด ๋ฌด๋‹จ์œผ๋กœ ์ˆ˜์ง‘๋˜๋ฉด ์‹ฌ๊ฐํ•œ ๋ณด์•ˆ ์‚ฌ๊ณ ๋กœ ์ด์–ด์งˆ ์ˆ˜ ์žˆ์–ด. ํŠนํžˆ ๊ฐœ์ธ์ •๋ณด๋ณดํ˜ธ๋ฒ• ์œ„๋ฐ˜์œผ๋กœ ๋ฒ•์  ์ฑ…์ž„๊นŒ์ง€ ์งˆ ์ˆ˜ ์žˆ๋‹ค๊ณ !
์›น์‚ฌ์ดํŠธ ์•…์„ฑ ๋ด‡ ์ •์ƒ ์‚ฌ์šฉ์ž ๋ณด์•ˆ ๊ณ„์ธต ํ•„ํ„ฐ๋ง & ํƒ์ง€ ๋ด‡ ํƒ์ง€ ์‹œ์Šคํ…œ์˜ ์—ญํ• 

๐Ÿ” ๋ด‡์„ ๊ตฌ๋ณ„ํ•˜๋Š” ํ•ต์‹ฌ ์›๋ฆฌ

์ž, ๊ทธ๋Ÿผ ์–ด๋–ป๊ฒŒ ๋ด‡๊ณผ ์‚ฌ๋žŒ์„ ๊ตฌ๋ณ„ํ•  ์ˆ˜ ์žˆ์„๊นŒ? ์‚ฌ์‹ค ์ด๊ฒŒ ํ•ต์‹ฌ์ด์•ผ. ๋ด‡๋“ค์€ ์•„๋ฌด๋ฆฌ ์ •๊ตํ•ด๋„ ์‚ฌ๋žŒ๊ณผ๋Š” ๋‹ค๋ฅธ ํŒจํ„ด์„ ๋ณด์ด๊ฑฐ๋“ .

๐ŸŽญ ํ–‰๋™ ํŒจํ„ด ๋ถ„์„ (Behavioral Analysis) ์‚ฌ๋žŒ์€ ์›นํŽ˜์ด์ง€๋ฅผ ๋ณผ ๋•Œ ๋ถˆ๊ทœ์น™์ ์ด์•ผ. ๋งˆ์šฐ์Šค๋ฅผ ์ด๋ฆฌ์ €๋ฆฌ ์›€์ง์ด๊ณ , ์Šคํฌ๋กค๋„ ์ฒœ์ฒœํžˆ ํ•˜๊ณ , ๊ฐ€๋” ๋ฉˆ์ถฐ์„œ ์ฝ๊ธฐ๋„ ํ•˜์ง€. ๋ฐ˜๋ฉด ๋ด‡์€?

โ€ข ๋งˆ์šฐ์Šค ์›€์ง์ž„์ด ์—†๊ฑฐ๋‚˜ ์ง์„ ์ 
โ€ข ํŽ˜์ด์ง€ ๋กœ๋”ฉ ํ›„ ์ •ํ™•ํžˆ 0.5์ดˆ ๋’ค์— ๋‹ค์Œ ํŽ˜์ด์ง€๋กœ ์ด๋™
โ€ข ์Šคํฌ๋กค ์—†์ด ๋ฐ”๋กœ ๋ฐ์ดํ„ฐ ์ถ”์ถœ
โ€ข ํด๋ฆญ ์ขŒํ‘œ๊ฐ€ ํ”ฝ์…€ ๋‹จ์œ„๋กœ ์ •ํ™•ํ•จ

์ด๋Ÿฐ ์ฐจ์ด์ ๋“ค์„ JavaScript๋กœ ์ถ”์ ํ•  ์ˆ˜ ์žˆ์–ด. ์‹ค์ œ๋กœ ๊ตฌ๊ธ€์˜ reCAPTCHA v3๋Š” ์ด๋Ÿฐ ํ–‰๋™ ํŒจํ„ด์„ ๋จธ์‹ ๋Ÿฌ๋‹์œผ๋กœ ๋ถ„์„ํ•ด์„œ ๋ด‡ ์ ์ˆ˜๋ฅผ ๋งค๊ธด๋‹ค๊ณ !
โฑ๏ธ ์š”์ฒญ ์†๋„ ๋ถ„์„ (Rate Limiting)

์‚ฌ๋žŒ์ด 1์ดˆ์— 10๊ฐœ ํŽ˜์ด์ง€๋ฅผ ๋ณผ ์ˆ˜ ์žˆ์„๊นŒ? ๋ถˆ๊ฐ€๋Šฅํ•˜์ง€. ํ•˜์ง€๋งŒ ๋ด‡์€ ๊ฐ€๋Šฅํ•ด. ๊ทธ๋ž˜์„œ ์š”์ฒญ ์†๋„๋ฅผ ๋ชจ๋‹ˆํ„ฐ๋งํ•˜๋Š” ๊ฒŒ ์ค‘์š”ํ•ด.

// Node.js Express ์˜ˆ์‹œ
const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15๋ถ„
  max: 100, // ์ตœ๋Œ€ 100๊ฐœ ์š”์ฒญ
  message: '๋„ˆ๋ฌด ๋งŽ์€ ์š”์ฒญ์ด ๊ฐ์ง€๋˜์—ˆ์Šต๋‹ˆ๋‹ค. ์ž ์‹œ ํ›„ ๋‹ค์‹œ ์‹œ๋„ํ•ด์ฃผ์„ธ์š”.',
  standardHeaders: true,
  legacyHeaders: false,
});

app.use('/api/', limiter);

์ด๋ ‡๊ฒŒ ํ•˜๋ฉด 15๋ถ„ ๋™์•ˆ 100๊ฐœ ์ด์ƒ์˜ ์š”์ฒญ์„ ๋ณด๋‚ด๋Š” IP๋Š” ์ž๋™์œผ๋กœ ์ฐจ๋‹จ๋ผ. ๊ฐ„๋‹จํ•˜์ง€๋งŒ ํšจ๊ณผ์ ์ด์•ผ! ๐ŸŽฏ
๐Ÿ” ๋ธŒ๋ผ์šฐ์ € ์ง€๋ฌธ ์ธ์‹ (Browser Fingerprinting) ๋ชจ๋“  ๋ธŒ๋ผ์šฐ์ €๋Š” ๊ณ ์œ ํ•œ ํŠน์„ฑ์„ ๊ฐ€์ง€๊ณ  ์žˆ์–ด. ํ™”๋ฉด ํ•ด์ƒ๋„, ์„ค์น˜๋œ ํฐํŠธ, ํ”Œ๋Ÿฌ๊ทธ์ธ, ํƒ€์ž„์กด, ์–ธ์–ด ์„ค์ • ๋“ฑ๋“ฑ... ์ด๊ฑธ ์กฐํ•ฉํ•˜๋ฉด ๊ฑฐ์˜ ์œ ์ผํ•œ '์ง€๋ฌธ'์ด ๋งŒ๋“ค์–ด์ ธ.

๋ด‡๋“ค์€ ์ด๋Ÿฐ ์ •๋ณด๋ฅผ ์œ„์กฐํ•˜๊ธฐ ์–ด๋ ค์›Œ. ํŠนํžˆ Canvas Fingerprinting ๊ฐ™์€ ๊ธฐ์ˆ ์€ ๋ธŒ๋ผ์šฐ์ €๊ฐ€ ๊ทธ๋ž˜ํ”ฝ์„ ๋ Œ๋”๋งํ•˜๋Š” ๋ฐฉ์‹์˜ ๋ฏธ์„ธํ•œ ์ฐจ์ด๊นŒ์ง€ ๊ฐ์ง€ํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ .

๐Ÿ› ๏ธ ์‹ค์ „ ๋ฐฉ์–ด ๊ธฐ์ˆ  ๊ตฌํ˜„ํ•˜๊ธฐ

์ด๋ก ์€ ์ถฉ๋ถ„ํžˆ ๋ดค์œผ๋‹ˆ ์ด์ œ ์‹ค์ œ๋กœ ์–ด๋–ป๊ฒŒ ๊ตฌํ˜„ํ•˜๋Š”์ง€ ์•Œ์•„๋ณด์ž! ๋‚œ์ด๋„๋ณ„๋กœ ์ •๋ฆฌํ•ด์ค„๊ฒŒ.

๐ŸŒฑ ์ดˆ๊ธ‰: ๊ธฐ๋ณธ์ ์ธ ๋ฐฉ์–ด ๋ ˆ์ด์–ด

1๏ธโƒฃ robots.txt ์„ค์ •

๊ฐ€์žฅ ๊ธฐ๋ณธ์ด์ง€๋งŒ ์˜์™ธ๋กœ ๋งŽ์€ ์‚ฌ๋žŒ๋“ค์ด ๋†“์น˜๋Š” ๋ถ€๋ถ„์ด์•ผ. ์ฐฉํ•œ ๋ด‡๋“ค์€ ์ด ํŒŒ์ผ์„ ์กด์ค‘ํ•ด์ค˜.

User-agent: *
Disallow: /admin/
Disallow: /api/private/
Disallow: /user/profile/
Crawl-delay: 10

User-agent: Googlebot
Allow: /

User-agent: BadBot
Disallow: /

๋ฌผ๋ก  ์•…์˜์ ์ธ ๋ด‡์€ ๋ฌด์‹œํ•˜์ง€๋งŒ, ๊ทธ๋ž˜๋„ ๊ธฐ๋ณธ์€ ๊ฐ–์ถฐ์•ผ์ง€! ๐Ÿ˜Š
2๏ธโƒฃ User-Agent ๊ฒ€์ฆ

๋ชจ๋“  HTTP ์š”์ฒญ์—๋Š” User-Agent ํ—ค๋”๊ฐ€ ์žˆ์–ด. ์ด๊ฑธ ์ฒดํฌํ•˜๋Š” ๊ฑฐ์•ผ.

// Python Flask ์˜ˆ์‹œ
from flask import request, abort

BLOCKED_USER_AGENTS = [
    'scrapy', 'bot', 'spider', 'crawler',
    'curl', 'wget', 'python-requests'
]

@app.before_request
def block_bad_user_agents():
    user_agent = request.headers.get('User-Agent', '').lower()
    
    if any(blocked in user_agent for blocked in BLOCKED_USER_AGENTS):
        abort(403)
    
    if not user_agent:  # User-Agent๊ฐ€ ์—†๋Š” ๊ฒฝ์šฐ
        abort(403)

๊ฐ„๋‹จํ•˜์ง€๋งŒ ๊ธฐ๋ณธ์ ์ธ ์Šคํฌ๋ž˜ํ•‘ ์‹œ๋„์˜ 70% ์ •๋„๋Š” ๊ฑธ๋Ÿฌ๋‚ผ ์ˆ˜ ์žˆ์–ด! ๐Ÿ’ช
3๏ธโƒฃ Referrer ์ฒดํฌ

์ •์ƒ์ ์ธ ์‚ฌ์šฉ์ž๋Š” ๋ณดํ†ต ๊ฒ€์ƒ‰์—”์ง„์ด๋‚˜ ๋‹ค๋ฅธ ํŽ˜์ด์ง€์—์„œ ์œ ์ž…๋ผ. ํ•˜์ง€๋งŒ ๋ด‡์€ ์ง์ ‘ URL๋กœ ์ ‘๊ทผํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์ง€.

// JavaScript ํด๋ผ์ด์–ธํŠธ ์‚ฌ์ด๋“œ
if (document.referrer === '' && !sessionStorage.getItem('visited')) {
    // ์˜์‹ฌ์Šค๋Ÿฌ์šด ์ง์ ‘ ์ ‘๊ทผ
    console.warn('Direct access detected');
    // ์ถ”๊ฐ€ ๊ฒ€์ฆ ๋กœ์ง ์‹คํ–‰
}
sessionStorage.setItem('visited', 'true');

๐Ÿ”ฅ ์ค‘๊ธ‰: ๋™์  ๋ฐฉ์–ด ๋ฉ”์ปค๋‹ˆ์ฆ˜

๐ŸŽฒ ๋™์  ํ† ํฐ ์‹œ์Šคํ…œ

์ด๊ฑด ์ •๋ง ํšจ๊ณผ์ ์ด์•ผ! ํŽ˜์ด์ง€๋ฅผ ๋กœ๋“œํ•  ๋•Œ๋งˆ๋‹ค ๊ณ ์œ ํ•œ ํ† ํฐ์„ ์ƒ์„ฑํ•˜๊ณ , ๋‹ค์Œ ์š”์ฒญ ์‹œ ์ด ํ† ํฐ์„ ๊ฒ€์ฆํ•˜๋Š” ๊ฑฐ์•ผ.

// ์„œ๋ฒ„ ์‚ฌ์ด๋“œ (Node.js)
const crypto = require('crypto');
const tokens = new Map();

function generateToken(sessionId) {
    const token = crypto.randomBytes(32).toString('hex');
    const timestamp = Date.now();
    
    tokens.set(sessionId, {
        token: token,
        timestamp: timestamp,
        used: false
    });
    
    // 5๋ถ„ ํ›„ ์ž๋™ ์‚ญ์ œ
    setTimeout(() => tokens.delete(sessionId), 5 * 60 * 1000);
    
    return token;
}

function verifyToken(sessionId, token) {
    const stored = tokens.get(sessionId);
    
    if (!stored) return false;
    if (stored.used) return false;
    if (Date.now() - stored.timestamp > 5 * 60 * 1000) return false;
    if (stored.token !== token) return false;
    
    stored.used = true;  // ์ผํšŒ์šฉ ํ† ํฐ
    return true;
}

// ํด๋ผ์ด์–ธํŠธ ์‚ฌ์ด๋“œ
async function fetchData() {
    const response = await fetch('/api/data', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'X-CSRF-Token': document.querySelector('meta[name="csrf-token"]').content
        },
        body: JSON.stringify({ /* ๋ฐ์ดํ„ฐ */ })
    });
    
    return response.json();
}

์ด ๋ฐฉ์‹์˜ ์žฅ์ ์€ ๋ด‡์ด ํ† ํฐ์„ ์žฌ์‚ฌ์šฉํ•  ์ˆ˜ ์—†๋‹ค๋Š” ๊ฑฐ์•ผ. ๋งค๋ฒˆ ์ƒˆ๋กœ์šด ํ† ํฐ์ด ํ•„์š”ํ•˜๊ณ , ํ† ํฐ์€ ์ผํšŒ์šฉ์ด๊ฑฐ๋“ ! ๐ŸŽฏ
๐Ÿงฉ JavaScript ์ฑŒ๋ฆฐ์ง€

์ง„์งœ ๋ธŒ๋ผ์šฐ์ €์ธ์ง€ ํ™•์ธํ•˜๋Š” ๋ฐฉ๋ฒ• ์ค‘ ํ•˜๋‚˜๋Š” JavaScript ์‹คํ–‰์„ ์š”๊ตฌํ•˜๋Š” ๊ฑฐ์•ผ. ๋Œ€๋ถ€๋ถ„์˜ ๊ฐ„๋‹จํ•œ ์Šคํฌ๋ž˜ํผ๋Š” JavaScript๋ฅผ ์‹คํ–‰ํ•˜์ง€ ๋ชปํ•ด.

// ์„œ๋ฒ„์—์„œ ์ˆ˜ํ•™ ๋ฌธ์ œ๋ฅผ ์ƒ์„ฑ
app.get('/challenge', (req, res) => {
    const a = Math.floor(Math.random() * 100);
    const b = Math.floor(Math.random() * 100);
    const answer = a + b;
    
    req.session.challenge = {
        answer: answer,
        timestamp: Date.now()
    };
    
    res.json({ a, b });
});

// ํด๋ผ์ด์–ธํŠธ์—์„œ ํ•ด๊ฒฐ
async function solveChallenge() {
    const challenge = await fetch('/challenge').then(r => r.json());
    const answer = challenge.a + challenge.b;
    
    // ์‹ค์ œ๋กœ๋Š” ๋” ๋ณต์žกํ•œ ๊ณ„์‚ฐ์„ ํ•  ์ˆ˜ ์žˆ์–ด
    await new Promise(resolve => setTimeout(resolve, 1000));  // 1์ดˆ ๋Œ€๊ธฐ
    
    return fetch('/verify', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ answer })
    });
}

๋” ๋ฐœ์ „์‹œํ‚ค๋ฉด Canvas ๋ Œ๋”๋ง, WebGL ํ…Œ์ŠคํŠธ, ํƒ€์ด๋ฐ ๊ณต๊ฒฉ ๋ฐฉ์–ด ๋“ฑ์„ ์ถ”๊ฐ€ํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿš€
๐ŸŽช ํ—ˆ๋‹ˆํŒŸ (Honeypot) ๊ธฐ๋ฒ•

์ด๊ฑด ์ง„์งœ ์žฌ๋ฏธ์žˆ๋Š” ๋ฐฉ๋ฒ•์ด์•ผ! ์‚ฌ๋žŒ ๋ˆˆ์—๋Š” ๋ณด์ด์ง€ ์•Š์ง€๋งŒ ๋ด‡์€ ๋ณผ ์ˆ˜ ์žˆ๋Š” ํ•จ์ •์„ ๋งŒ๋“œ๋Š” ๊ฑฐ์•ผ.

<!-- HTML์— ์ˆจ๊ฒจ์ง„ ํ•„๋“œ ์ถ”๊ฐ€ -->
<form action="/submit" method="post">
    <input type="text" name="username" placeholder="์ด๋ฆ„">
    <input type="email" name="email" placeholder="์ด๋ฉ”์ผ">
    
    <!-- ํ—ˆ๋‹ˆํŒŸ ํ•„๋“œ (CSS๋กœ ์ˆจ๊น€) -->
    <input type="text" name="website" style="display:none;" tabindex="-1" autocomplete="off">
    
    <button type="submit">์ œ์ถœ</button>
</form>

// ์„œ๋ฒ„์—์„œ ๊ฒ€์ฆ
app.post('/submit', (req, res) => {
    // ํ—ˆ๋‹ˆํŒŸ ํ•„๋“œ์— ๊ฐ’์ด ์žˆ์œผ๋ฉด ๋ด‡!
    if (req.body.website) {
        console.log('Bot detected!');
        return res.status(403).send('Access denied');
    }
    
    // ์ •์ƒ ์ฒ˜๋ฆฌ
    processForm(req.body);
});

๋ด‡๋“ค์€ ๋ชจ๋“  ์ž…๋ ฅ ํ•„๋“œ๋ฅผ ์ฑ„์šฐ๋ ค๊ณ  ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ์ด ํ•จ์ •์— ๊ฑธ๋ ค! ๐Ÿ˜ˆ

โšก ๊ณ ๊ธ‰: ๋จธ์‹ ๋Ÿฌ๋‹ ๊ธฐ๋ฐ˜ ํƒ์ง€

โš ๏ธ ์ฃผ์˜์‚ฌํ•ญ ๊ณ ๊ธ‰ ๊ธฐ์ˆ ์€ ๊ตฌํ˜„์ด ๋ณต์žกํ•˜๊ณ  ๋ฆฌ์†Œ์Šค๋„ ๋งŽ์ด ํ•„์š”ํ•ด. ํ•˜์ง€๋งŒ ๋Œ€๊ทœ๋ชจ ์„œ๋น„์Šค๋ผ๋ฉด ๋ฐ˜๋“œ์‹œ ๊ณ ๋ คํ•ด์•ผ ํ•  ๋ถ€๋ถ„์ด์•ผ!
๐Ÿค– ํ–‰๋™ ํŒจํ„ด ๋จธ์‹ ๋Ÿฌ๋‹ ๋ชจ๋ธ

์‚ฌ์šฉ์ž์˜ ํ–‰๋™ ๋ฐ์ดํ„ฐ๋ฅผ ์ˆ˜์ง‘ํ•ด์„œ ๋จธ์‹ ๋Ÿฌ๋‹ ๋ชจ๋ธ์„ ํ•™์Šต์‹œํ‚ค๋Š” ๊ฑฐ์•ผ. ์ด๊ฑด ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ๋„ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๋ฐฉ๋ฒ•์ด์•ผ!

์ˆ˜์ง‘ํ•  ๋ฐ์ดํ„ฐ:
โ€ข ๋งˆ์šฐ์Šค ์ด๋™ ๊ฒฝ๋กœ์™€ ์†๋„
โ€ข ํ‚ค๋ณด๋“œ ํƒ€์ดํ•‘ ํŒจํ„ด (ํƒ€์ด๋ฐ, ์†๋„)
โ€ข ์Šคํฌ๋กค ํ–‰๋™ (์†๋„, ํŒจํ„ด, ๋ฉˆ์ถค)
โ€ข ํŽ˜์ด์ง€ ์ฒด๋ฅ˜ ์‹œ๊ฐ„
โ€ข ํด๋ฆญ ์œ„์น˜์™€ ํƒ€์ด๋ฐ
โ€ข ํ„ฐ์น˜ ์ œ์Šค์ฒ˜ (๋ชจ๋ฐ”์ผ)

// ํด๋ผ์ด์–ธํŠธ์—์„œ ๋ฐ์ดํ„ฐ ์ˆ˜์ง‘
class BehaviorTracker {
    constructor() {
        this.data = {
            mouseMovements: [],
            clicks: [],
            scrolls: [],
            keystrokes: [],
            timestamps: []
        };
        this.initTracking();
    }
    
    initTracking() {
        let lastMouseMove = 0;
        
        document.addEventListener('mousemove', (e) => {
            const now = Date.now();
            if (now - lastMouseMove > 50) {  // 50ms ์ƒ˜ํ”Œ๋ง
                this.data.mouseMovements.push({
                    x: e.clientX,
                    y: e.clientY,
                    time: now
                });
                lastMouseMove = now;
            }
        });
        
        document.addEventListener('click', (e) => {
            this.data.clicks.push({
                x: e.clientX,
                y: e.clientY,
                time: Date.now()
            });
        });
        
        window.addEventListener('scroll', () => {
            this.data.scrolls.push({
                y: window.scrollY,
                time: Date.now()
            });
        });
        
        document.addEventListener('keydown', (e) => {
            this.data.keystrokes.push({
                key: e.key,
                time: Date.now()
            });
        });
    }
    
    async sendData() {
        const features = this.extractFeatures();
        
        await fetch('/api/behavior-check', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(features)
        });
    }
    
    extractFeatures() {
        // ํŠน์ง• ์ถ”์ถœ
        const mouseSpeed = this.calculateMouseSpeed();
        const clickPattern = this.analyzeClickPattern();
        const scrollPattern = this.analyzeScrollPattern();
        
        return {
            mouseSpeed,
            clickPattern,
            scrollPattern,
            totalTime: Date.now() - this.data.timestamps[0]
        };
    }
    
    calculateMouseSpeed() {
        if (this.data.mouseMovements.length < 2) return 0;
        
        let totalSpeed = 0;
        for (let i = 1; i < this.data.mouseMovements.length; i++) {
            const prev = this.data.mouseMovements[i - 1];
            const curr = this.data.mouseMovements[i];
            
            const distance = Math.sqrt(
                Math.pow(curr.x - prev.x, 2) + 
                Math.pow(curr.y - prev.y, 2)
            );
            const time = curr.time - prev.time;
            
            totalSpeed += distance / time;
        }
        
        return totalSpeed / (this.data.mouseMovements.length - 1);
    }
    
    analyzeClickPattern() {
        // ํด๋ฆญ ๊ฐ„๊ฒฉ์˜ ํ‘œ์ค€ํŽธ์ฐจ ๊ณ„์‚ฐ
        if (this.data.clicks.length < 2) return 0;
        
        const intervals = [];
        for (let i = 1; i < this.data.clicks.length; i++) {
            intervals.push(this.data.clicks[i].time - this.data.clicks[i-1].time);
        }
        
        const mean = intervals.reduce((a, b) => a + b) / intervals.length;
        const variance = intervals.reduce((sum, val) => 
            sum + Math.pow(val - mean, 2), 0) / intervals.length;
        
        return Math.sqrt(variance);  // ํ‘œ์ค€ํŽธ์ฐจ
    }
    
    analyzeScrollPattern() {
        // ์Šคํฌ๋กค ์†๋„์˜ ๋ณ€ํ™” ๋ถ„์„
        if (this.data.scrolls.length < 2) return 0;
        
        const speeds = [];
        for (let i = 1; i < this.data.scrolls.length; i++) {
            const prev = this.data.scrolls[i - 1];
            const curr = this.data.scrolls[i];
            
            const speed = Math.abs(curr.y - prev.y) / (curr.time - prev.time);
            speeds.push(speed);
        }
        
        return speeds.reduce((a, b) => a + b, 0) / speeds.length;
    }
}

// ์‚ฌ์šฉ
const tracker = new BehaviorTracker();

// ํŽ˜์ด์ง€ ์ดํƒˆ ์ „์— ๋ฐ์ดํ„ฐ ์ „์†ก
window.addEventListener('beforeunload', () => {
    tracker.sendData();
});

์„œ๋ฒ„์—์„œ๋Š” ์ด ๋ฐ์ดํ„ฐ๋ฅผ ๋ฐ›์•„์„œ ๋จธ์‹ ๋Ÿฌ๋‹ ๋ชจ๋ธ๋กœ ๋ถ„์„ํ•ด. Python์˜ scikit-learn์ด๋‚˜ TensorFlow๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์–ด.

# Python ์„œ๋ฒ„ ์‚ฌ์ด๋“œ
from sklearn.ensemble import RandomForestClassifier
import numpy as np

class BotDetector:
    def __init__(self):
        self.model = RandomForestClassifier(n_estimators=100)
        self.trained = False
    
    def train(self, X_train, y_train):
        """
        X_train: ํŠน์ง• ๋ฒกํ„ฐ๋“ค (๋งˆ์šฐ์Šค ์†๋„, ํด๋ฆญ ํŒจํ„ด ๋“ฑ)
        y_train: ๋ ˆ์ด๋ธ” (0: ์‚ฌ๋žŒ, 1: ๋ด‡)
        """
        self.model.fit(X_train, y_train)
        self.trained = True
    
    def predict(self, features):
        if not self.trained:
            raise Exception("Model not trained yet")
        
        # ํŠน์ง• ๋ฒกํ„ฐ ๋ณ€ํ™˜
        X = np.array([[
            features['mouseSpeed'],
            features['clickPattern'],
            features['scrollPattern'],
            features['totalTime']
        ]])
        
        # ์˜ˆ์ธก (0~1 ์‚ฌ์ด์˜ ํ™•๋ฅ )
        probability = self.model.predict_proba(X)[0][1]
        
        return {
            'isBot': probability > 0.7,  # 70% ์ด์ƒ์ด๋ฉด ๋ด‡์œผ๋กœ ํŒ๋‹จ
            'confidence': probability
        }

# Flask ์—”๋“œํฌ์ธํŠธ
detector = BotDetector()
# ... ๋ชจ๋ธ ํ•™์Šต ์ฝ”๋“œ ...

@app.post('/api/behavior-check')
def check_behavior():
    features = request.json
    result = detector.predict(features)
    
    if result['isBot']:
        # ๋ด‡์œผ๋กœ ํŒ๋‹จ๋˜๋ฉด ์„ธ์…˜์— ํ‘œ์‹œ
        session['bot_score'] = result['confidence']
        return jsonify({'status': 'suspicious'}), 403
    
    return jsonify({'status': 'ok'}), 200

์ด ๋ฐฉ๋ฒ•์˜ ์žฅ์ ์€ ๋ด‡์ด ์ ์  ์ •๊ตํ•ด์ ธ๋„ ๋ชจ๋ธ์„ ์žฌํ•™์Šต์‹œ์ผœ์„œ ๋Œ€์‘ํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฑฐ์•ผ! ๐ŸŽ“

๐Ÿ” ๊ณ ๊ธ‰ ๋ณด์•ˆ ๋ ˆ์ด์–ด ์ถ”๊ฐ€ํ•˜๊ธฐ

๐ŸŒ CDN๊ณผ WAF ํ™œ์šฉ

Cloudflare๋ฅผ ํ™œ์šฉํ•œ ๋ด‡ ๋ฐฉ์–ด

Cloudflare๋Š” ๋ฌด๋ฃŒ ํ”Œ๋žœ์—์„œ๋„ ๊ฐ•๋ ฅํ•œ ๋ด‡ ๋ฐฉ์–ด ๊ธฐ๋Šฅ์„ ์ œ๊ณตํ•ด. ํŠนํžˆ "I'm Under Attack" ๋ชจ๋“œ๋Š” DDoS ๊ณต๊ฒฉ์ด๋‚˜ ๋Œ€๊ทœ๋ชจ ์Šคํฌ๋ž˜ํ•‘ ์‹œ๋„๋ฅผ ํšจ๊ณผ์ ์œผ๋กœ ๋ง‰์•„์ค˜.

์„ค์ • ๋ฐฉ๋ฒ•:
1. Cloudflare ๋Œ€์‹œ๋ณด๋“œ โ†’ Firewall
2. Firewall Rules ์ƒ์„ฑ
3. ์กฐ๊ฑด ์„ค์ • (์˜ˆ: Bot Score < 30)
4. ์•ก์…˜ ์„ ํƒ (Challenge, Block, JS Challenge)

// Cloudflare Workers๋กœ ์ปค์Šคํ…€ ๋กœ์ง ์ถ”๊ฐ€
addEventListener('fetch', event => {
    event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
    const botScore = request.cf.botManagement.score
    
    // ๋ด‡ ์ ์ˆ˜๊ฐ€ 30 ๋ฏธ๋งŒ์ด๋ฉด ์ฐจ๋‹จ
    if (botScore < 30) {
        return new Response('Access Denied', { 
            status: 403,
            headers: {
                'Content-Type': 'text/plain'
            }
        })
    }
    
    // Rate limiting ์ฒดํฌ
    const ip = request.headers.get('CF-Connecting-IP')
    const rateLimitKey = `rate_limit:${ip}`
    
    // KV ์Šคํ† ๋ฆฌ์ง€์—์„œ ์š”์ฒญ ํšŸ์ˆ˜ ํ™•์ธ
    const count = await RATE_LIMIT.get(rateLimitKey)
    
    if (count && parseInt(count) > 100) {
        return new Response('Too Many Requests', { status: 429 })
    }
    
    // ์š”์ฒญ ํšŸ์ˆ˜ ์ฆ๊ฐ€
    await RATE_LIMIT.put(rateLimitKey, 
        (parseInt(count) || 0) + 1, 
        { expirationTtl: 60 }  // 60์ดˆ ํ›„ ๋งŒ๋ฃŒ
    )
    
    return fetch(request)
}

Cloudflare Workers๋Š” ์—ฃ์ง€์—์„œ ์‹คํ–‰๋˜๊ธฐ ๋•Œ๋ฌธ์— ์„œ๋ฒ„ ๋ถ€ํ•˜๋ฅผ ์ค„์ด๋ฉด์„œ๋„ ๋น ๋ฅธ ์‘๋‹ต์ด ๊ฐ€๋Šฅํ•ด! โšก

๐ŸŽฏ CAPTCHA ์‹œ์Šคํ…œ ํ†ตํ•ฉ

reCAPTCHA v3 ๊ตฌํ˜„

๊ตฌ๊ธ€์˜ reCAPTCHA v3๋Š” ์‚ฌ์šฉ์ž ๊ฒฝํ—˜์„ ํ•ด์น˜์ง€ ์•Š์œผ๋ฉด์„œ๋„ ํšจ๊ณผ์ ์œผ๋กœ ๋ด‡์„ ๊ฑธ๋Ÿฌ๋‚ผ ์ˆ˜ ์žˆ์–ด. ์ฒดํฌ๋ฐ•์Šค ํด๋ฆญ๋„ ํ•„์š” ์—†์ด ๋ฐฑ๊ทธ๋ผ์šด๋“œ์—์„œ ์ž‘๋™ํ•˜๊ฑฐ๋“ !

<!-- HTML head์— ์ถ”๊ฐ€ -->
<script src="https://www.google.com/recaptcha/api.js?render=YOUR_SITE_KEY"></script>

<script>
function onSubmit(e) {
    e.preventDefault();
    
    grecaptcha.ready(function() {
        grecaptcha.execute('YOUR_SITE_KEY', {action: 'submit'})
            .then(function(token) {
                // ํ† ํฐ์„ ํผ์— ์ถ”๊ฐ€
                document.getElementById('recaptchaToken').value = token;
                document.getElementById('myForm').submit();
            });
    });
}
</script>

<form id="myForm" onsubmit="onSubmit(event)">
    <input type="hidden" id="recaptchaToken" name="recaptcha_token">
    <!-- ๋‹ค๋ฅธ ํผ ํ•„๋“œ๋“ค -->
    <button type="submit">์ œ์ถœ</button>
</form>

// Node.js ์„œ๋ฒ„์—์„œ ๊ฒ€์ฆ
const axios = require('axios');

async function verifyRecaptcha(token) {
    const secretKey = 'YOUR_SECRET_KEY';
    
    const response = await axios.post(
        'https://www.google.com/recaptcha/api/siteverify',
        null,
        {
            params: {
                secret: secretKey,
                response: token
            }
        }
    );
    
    const data = response.data;
    
    // ์ ์ˆ˜๊ฐ€ 0.5 ์ด์ƒ์ด๋ฉด ํ†ต๊ณผ
    return data.success && data.score >= 0.5;
}

app.post('/submit', async (req, res) => {
    const token = req.body.recaptcha_token;
    
    const isHuman = await verifyRecaptcha(token);
    
    if (!isHuman) {
        return res.status(403).json({ 
            error: '๋ด‡์œผ๋กœ ์˜์‹ฌ๋˜๋Š” ํ™œ๋™์ด ๊ฐ์ง€๋˜์—ˆ์Šต๋‹ˆ๋‹ค.' 
        });
    }
    
    // ์ •์ƒ ์ฒ˜๋ฆฌ
    processForm(req.body);
});

reCAPTCHA v3๋Š” 0.0~1.0 ์‚ฌ์ด์˜ ์ ์ˆ˜๋ฅผ ๋ฐ˜ํ™˜ํ•ด. 1.0์— ๊ฐ€๊นŒ์šธ์ˆ˜๋ก ์‚ฌ๋žŒ์ผ ํ™•๋ฅ ์ด ๋†’์€ ๊ฑฐ์•ผ. ๋ณดํ†ต 0.5๋ฅผ ๊ธฐ์ค€์œผ๋กœ ํ•˜์ง€๋งŒ, ์„œ๋น„์Šค ํŠน์„ฑ์— ๋”ฐ๋ผ ์กฐ์ •ํ•  ์ˆ˜ ์žˆ์–ด! ๐ŸŽš๏ธ

๐Ÿ”’ API ๋ณด์•ˆ ๊ฐ•ํ™”

JWT ํ† ํฐ ๊ธฐ๋ฐ˜ ์ธ์ฆ

API๋ฅผ ๋ณดํ˜ธํ•˜๋Š” ๊ฐ€์žฅ ํšจ๊ณผ์ ์ธ ๋ฐฉ๋ฒ• ์ค‘ ํ•˜๋‚˜๋Š” JWT(JSON Web Token)๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฑฐ์•ผ.

// Node.js JWT ์ƒ์„ฑ
const jwt = require('jsonwebtoken');

function generateToken(userId) {
    const payload = {
        userId: userId,
        iat: Math.floor(Date.now() / 1000),  // ๋ฐœ๊ธ‰ ์‹œ๊ฐ„
        exp: Math.floor(Date.now() / 1000) + (60 * 60)  // 1์‹œ๊ฐ„ ํ›„ ๋งŒ๋ฃŒ
    };
    
    return jwt.sign(payload, process.env.JWT_SECRET);
}

// ๋กœ๊ทธ์ธ ์—”๋“œํฌ์ธํŠธ
app.post('/api/login', async (req, res) => {
    const { username, password } = req.body;
    
    // ์‚ฌ์šฉ์ž ์ธ์ฆ
    const user = await authenticateUser(username, password);
    
    if (!user) {
        return res.status(401).json({ error: 'Invalid credentials' });
    }
    
    const token = generateToken(user.id);
    
    res.json({ 
        token: token,
        expiresIn: 3600
    });
});

// JWT ๊ฒ€์ฆ ๋ฏธ๋“ค์›จ์–ด
function authenticateToken(req, res, next) {
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[1];
    
    if (!token) {
        return res.status(401).json({ error: 'No token provided' });
    }
    
    jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
        if (err) {
            return res.status(403).json({ error: 'Invalid token' });
        }
        
        req.user = user;
        next();
    });
}

// ๋ณดํ˜ธ๋œ ๋ผ์šฐํŠธ
app.get('/api/protected-data', authenticateToken, (req, res) => {
    res.json({ 
        message: 'This is protected data',
        userId: req.user.userId
    });
});

์ถ”๊ฐ€๋กœ Refresh Token์„ ๊ตฌํ˜„ํ•˜๋ฉด ๋” ์•ˆ์ „ํ•ด์ ธ:

// Refresh Token ์‹œ์Šคํ…œ
const refreshTokens = new Map();  // ์‹ค์ œ๋กœ๋Š” Redis ์‚ฌ์šฉ ๊ถŒ์žฅ

function generateRefreshToken(userId) {
    const token = crypto.randomBytes(40).toString('hex');
    
    refreshTokens.set(token, {
        userId: userId,
        createdAt: Date.now()
    });
    
    return token;
}

app.post('/api/refresh', (req, res) => {
    const { refreshToken } = req.body;
    
    const tokenData = refreshTokens.get(refreshToken);
    
    if (!tokenData) {
        return res.status(403).json({ error: 'Invalid refresh token' });
    }
    
    // ์ƒˆ๋กœ์šด ์•ก์„ธ์Šค ํ† ํฐ ๋ฐœ๊ธ‰
    const newAccessToken = generateToken(tokenData.userId);
    
    res.json({ 
        accessToken: newAccessToken,
        expiresIn: 3600
    });
});

๐Ÿ“Š ๋ชจ๋‹ˆํ„ฐ๋ง๊ณผ ๋ถ„์„

๋ณด์•ˆ ์‹œ์Šคํ…œ์„ ๊ตฌ์ถ•ํ–ˆ๋‹ค๋ฉด ์ด์ œ ๋ชจ๋‹ˆํ„ฐ๋ง์ด ์ค‘์š”ํ•ด! ์‹ค์‹œ๊ฐ„์œผ๋กœ ๊ณต๊ฒฉ์„ ๊ฐ์ง€ํ•˜๊ณ  ๋Œ€์‘ํ•ด์•ผ ํ•˜๊ฑฐ๋“ .

๐Ÿ“ˆ ๋กœ๊ทธ ๋ถ„์„ ์‹œ์Šคํ…œ

๋ชจ๋“  ์˜์‹ฌ์Šค๋Ÿฌ์šด ํ™œ๋™์„ ๋กœ๊น…ํ•˜๊ณ  ๋ถ„์„ํ•ด์•ผ ํ•ด. ELK ์Šคํƒ(Elasticsearch, Logstash, Kibana)์„ ์‚ฌ์šฉํ•˜๋ฉด ํšจ๊ณผ์ ์ด์•ผ.

// Winston ๋กœ๊ฑฐ ์„ค์ •
const winston = require('winston');
const { ElasticsearchTransport } = require('winston-elasticsearch');

const logger = winston.createLogger({
    level: 'info',
    format: winston.format.json(),
    transports: [
        new winston.transports.File({ filename: 'error.log', level: 'error' }),
        new winston.transports.File({ filename: 'combined.log' }),
        new ElasticsearchTransport({
            level: 'info',
            clientOpts: { node: 'http://localhost:9200' },
            index: 'security-logs'
        })
    ]
});

// ์˜์‹ฌ์Šค๋Ÿฌ์šด ํ™œ๋™ ๋กœ๊น…
function logSuspiciousActivity(req, reason) {
    logger.warn('Suspicious activity detected', {
        ip: req.ip,
        userAgent: req.headers['user-agent'],
        url: req.url,
        method: req.method,
        reason: reason,
        timestamp: new Date().toISOString(),
        headers: req.headers,
        body: req.body
    });
}

// ๋ฏธ๋“ค์›จ์–ด์—์„œ ์‚ฌ์šฉ
app.use((req, res, next) => {
    // Rate limit ์ฒดํฌ
    if (isRateLimitExceeded(req.ip)) {
        logSuspiciousActivity(req, 'Rate limit exceeded');
        return res.status(429).send('Too Many Requests');
    }
    
    // User-Agent ์ฒดํฌ
    if (isSuspiciousUserAgent(req.headers['user-agent'])) {
        logSuspiciousActivity(req, 'Suspicious user agent');
        return res.status(403).send('Forbidden');
    }
    
    next();
});
๐Ÿšจ ์‹ค์‹œ๊ฐ„ ์•Œ๋ฆผ ์‹œ์Šคํ…œ

์‹ฌ๊ฐํ•œ ๊ณต๊ฒฉ์ด ๊ฐ์ง€๋˜๋ฉด ์ฆ‰์‹œ ์•Œ๋ฆผ์„ ๋ฐ›์•„์•ผ ํ•ด. Slack์ด๋‚˜ ์ด๋ฉ”์ผ๋กœ ์•Œ๋ฆผ์„ ๋ณด๋‚ผ ์ˆ˜ ์žˆ์–ด.

// Slack ์›นํ›… ์•Œ๋ฆผ
const axios = require('axios');

async function sendSlackAlert(message, severity = 'warning') {
    const webhookUrl = process.env.SLACK_WEBHOOK_URL;
    
    const color = {
        'info': '#36a64f',
        'warning': '#ff9900',
        'critical': '#ff0000'
    }[severity];
    
    await axios.post(webhookUrl, {
        attachments: [{
            color: color,
            title: '๐Ÿšจ ๋ณด์•ˆ ์•Œ๋ฆผ',
            text: message,
            fields: [
                {
                    title: '์‹ฌ๊ฐ๋„',
                    value: severity.toUpperCase(),
                    short: true
                },
                {
                    title: '์‹œ๊ฐ„',
                    value: new Date().toLocaleString('ko-KR'),
                    short: true
                }
            ],
            footer: '๋ณด์•ˆ ๋ชจ๋‹ˆํ„ฐ๋ง ์‹œ์Šคํ…œ',
            ts: Math.floor(Date.now() / 1000)
        }]
    });
}

// ๊ณต๊ฒฉ ํŒจํ„ด ๊ฐ์ง€
const attackCounts = new Map();

function detectAttackPattern(ip) {
    const count = attackCounts.get(ip) || 0;
    attackCounts.set(ip, count + 1);
    
    // 5๋ถ„๋งˆ๋‹ค ์นด์šดํŠธ ๋ฆฌ์…‹
    setTimeout(() => {
        attackCounts.delete(ip);
    }, 5 * 60 * 1000);
    
    // 1๋ถ„์— 50ํšŒ ์ด์ƒ์ด๋ฉด ๊ณต๊ฒฉ์œผ๋กœ ํŒ๋‹จ
    if (count > 50) {
        sendSlackAlert(
            `IP ${ip}์—์„œ ๋น„์ •์ƒ์ ์ธ ํŠธ๋ž˜ํ”ฝ ๊ฐ์ง€!\n` +
            `1๋ถ„๊ฐ„ ${count}ํšŒ์˜ ์š”์ฒญ์ด ๋ฐœ์ƒํ–ˆ์Šต๋‹ˆ๋‹ค.`,
            'critical'
        );
        
        // IP ์ž๋™ ์ฐจ๋‹จ
        blockIP(ip);
        
        return true;
    }
    
    return false;
}
๐Ÿ’ก ๋Œ€์‹œ๋ณด๋“œ ๊ตฌ์ถ•ํ•˜๊ธฐ Grafana๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ฉ‹์ง„ ๋ชจ๋‹ˆํ„ฐ๋ง ๋Œ€์‹œ๋ณด๋“œ๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด. ์‹ค์‹œ๊ฐ„์œผ๋กœ ๋‹ค์Œ ์ง€ํ‘œ๋“ค์„ ์ถ”์ ํ•  ์ˆ˜ ์žˆ์ง€:

โ€ข ์‹œ๊ฐ„๋Œ€๋ณ„ ์š”์ฒญ ์ˆ˜
โ€ข ์ฐจ๋‹จ๋œ IP ์ˆ˜
โ€ข ๋ด‡ ํƒ์ง€์œจ
โ€ข ํ‰๊ท  ์‘๋‹ต ์‹œ๊ฐ„
โ€ข ์ง€์—ญ๋ณ„ ํŠธ๋ž˜ํ”ฝ ๋ถ„ํฌ
โ€ข ๊ฐ€์žฅ ๋งŽ์ด ๊ณต๊ฒฉ๋ฐ›๋Š” ์—”๋“œํฌ์ธํŠธ

์ด๋Ÿฐ ๋ฐ์ดํ„ฐ๋ฅผ ์‹œ๊ฐํ™”ํ•˜๋ฉด ๊ณต๊ฒฉ ํŒจํ„ด์„ ํŒŒ์•…ํ•˜๊ณ  ๋Œ€์‘ ์ „๋žต์„ ์„ธ์šฐ๊ธฐ ํ›จ์”ฌ ์‰ฌ์›Œ์ ธ! ๐Ÿ“Š

๐ŸŽ“ ์‹ค์ „ ์ผ€์ด์Šค ์Šคํ„ฐ๋””

์ด๋ก ๋งŒ ์•Œ์•„์„œ๋Š” ๋ถ€์กฑํ•˜์ง€! ์‹ค์ œ ์‚ฌ๋ก€๋ฅผ ํ†ตํ•ด ๋ฐฐ์›Œ๋ณด์ž.

๐Ÿ“š ์‚ฌ๋ก€ 1: ์ด์ปค๋จธ์Šค ๊ฐ€๊ฒฉ ์Šคํฌ๋ž˜ํ•‘ ๋ฐฉ์–ด

ํ•œ ์ค‘์†Œ ์‡ผํ•‘๋ชฐ์ด ๊ฒฝ์Ÿ์‚ฌ์˜ ๊ฐ€๊ฒฉ ์Šคํฌ๋ž˜ํ•‘์œผ๋กœ ๊ณ ํ†ต๋ฐ›๊ณ  ์žˆ์—ˆ์–ด. ํ•˜๋ฃจ์— ์ˆ˜๋งŒ ๊ฑด์˜ ์š”์ฒญ์ด ๋“ค์–ด์™€์„œ ์„œ๋ฒ„๊ฐ€ ๋‹ค์šด๋˜๊ธฐ ์ผ๋ณด ์ง์ „์ด์—ˆ์ง€.

๋ฌธ์ œ ๋ถ„์„:
โ€ข ํŠน์ • IP ๋Œ€์—ญ์—์„œ ์ดˆ๋‹น 100๊ฐœ ์ด์ƒ์˜ ์ƒํ’ˆ ํŽ˜์ด์ง€ ์š”์ฒญ
โ€ข User-Agent๊ฐ€ ์ •์ƒ ๋ธŒ๋ผ์šฐ์ €๋กœ ์œ„์žฅ๋จ
โ€ข ์ฟ ํ‚ค์™€ ์„ธ์…˜์„ ์ •์ƒ์ ์œผ๋กœ ์ฒ˜๋ฆฌํ•จ

ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•:

1๋‹จ๊ณ„: Rate Limiting ๊ฐ•ํ™”
// Redis ๊ธฐ๋ฐ˜ Rate Limiter
const redis = require('redis');
const client = redis.createClient();

async function checkRateLimit(ip, endpoint) {
    const key = `rate:${ip}:${endpoint}`;
    const limit = 10;  // 10์ดˆ์— 10๊ฐœ ์š”์ฒญ
    const window = 10;
    
    const current = await client.incr(key);
    
    if (current === 1) {
        await client.expire(key, window);
    }
    
    return current <= limit;
}

2๋‹จ๊ณ„: ๋™์  ๊ฐ€๊ฒฉ ํ‘œ์‹œ
// ๊ฐ€๊ฒฉ์„ JavaScript๋กœ ๋™์  ๋ Œ๋”๋ง
<div id="price" data-product-id="12345">๋กœ๋”ฉ์ค‘...</div>

<script>
async function loadPrice() {
    const productId = document.getElementById('price').dataset.productId;
    
    // ํ† ํฐ ์ƒ์„ฑ (์„œ๋ฒ„์—์„œ ํŽ˜์ด์ง€ ๋กœ๋“œ ์‹œ ์ œ๊ณต)
    const token = document.querySelector('meta[name="price-token"]').content;
    
    const response = await fetch(`/api/price/${productId}`, {
        headers: {
            'X-Price-Token': token
        }
    });
    
    const data = await response.json();
    document.getElementById('price').textContent = `${data.price.toLocaleString()}์›`;
}

loadPrice();
</script>

3๋‹จ๊ณ„: ํ–‰๋™ ํŒจํ„ด ๋ถ„์„
// ์ •์ƒ ์‚ฌ์šฉ์ž๋Š” ์ƒํ’ˆ ์ด๋ฏธ์ง€๋ฅผ ๋กœ๋“œํ•˜์ง€๋งŒ ๋ด‡์€ ์•ˆ ํ•จ
app.get('/product/:id', (req, res) => {
    const sessionId = req.session.id;
    
    // ์ด๋ฏธ์ง€ ๋กœ๋“œ ์—ฌ๋ถ€ ์ถ”์ 
    req.session.imageLoaded = false;
    
    res.render('product', { productId: req.params.id });
});

app.get('/product-image/:id', (req, res) => {
    req.session.imageLoaded = true;
    res.sendFile(`images/${req.params.id}.jpg`);
});

app.get('/api/price/:id', (req, res) => {
    // ์ด๋ฏธ์ง€๋ฅผ ๋กœ๋“œํ•˜์ง€ ์•Š์•˜๋‹ค๋ฉด ์˜์‹ฌ
    if (!req.session.imageLoaded) {
        logSuspiciousActivity(req, 'Price request without image load');
        return res.status(403).json({ error: 'Forbidden' });
    }
    
    // ๊ฐ€๊ฒฉ ์ •๋ณด ์ œ๊ณต
    res.json({ price: getPrice(req.params.id) });
});

๊ฒฐ๊ณผ:
โ€ข ์Šคํฌ๋ž˜ํ•‘ ํŠธ๋ž˜ํ”ฝ 95% ๊ฐ์†Œ
โ€ข ์„œ๋ฒ„ ๋น„์šฉ 60% ์ ˆ๊ฐ
โ€ข ์ •์ƒ ์‚ฌ์šฉ์ž ๊ฒฝํ—˜์€ ๊ทธ๋Œ€๋กœ ์œ ์ง€

์ด ๋ฐฉ๋ฒ•๋“ค์„ ์กฐํ•ฉํ•˜๋‹ˆ๊นŒ ๋Œ€๋ถ€๋ถ„์˜ ์Šคํฌ๋ž˜ํ•‘ ๋ด‡์„ ๋ง‰์„ ์ˆ˜ ์žˆ์—ˆ์–ด! ๐Ÿ’ช
๐ŸŽฎ ์‚ฌ๋ก€ 2: ๊ฒŒ์ž„ ์•„์ดํ…œ ๊ฑฐ๋ž˜ ์‚ฌ์ดํŠธ ๋ด‡ ๋ฐฉ์–ด

๊ฒŒ์ž„ ์•„์ดํ…œ ๊ฑฐ๋ž˜ ํ”Œ๋žซํผ์—์„œ ๋ด‡๋“ค์ด ์ €๋ ดํ•œ ์•„์ดํ…œ์„ ์ž๋™์œผ๋กœ ๊ตฌ๋งคํ•˜๋Š” ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ–ˆ์–ด. ์ผ๋ฐ˜ ์œ ์ €๋“ค์€ ์ข‹์€ ๋”œ์„ ์žก์„ ๊ธฐํšŒ์กฐ์ฐจ ์—†์—ˆ์ง€.

ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•:

1๋‹จ๊ณ„: ๊ตฌ๋งค ๋ฒ„ํŠผ์— ํƒ€์ด๋ฐ ๊ฒ€์ฆ
// ํŽ˜์ด์ง€ ๋กœ๋“œ ํ›„ ์ตœ์†Œ 3์ดˆ๋Š” ์ง€๋‚˜์•ผ ๊ตฌ๋งค ๊ฐ€๋Šฅ
let pageLoadTime = Date.now();

document.getElementById('buyButton').addEventListener('click', async (e) => {
    e.preventDefault();
    
    const timeSinceLoad = Date.now() - pageLoadTime;
    
    if (timeSinceLoad < 3000) {
        alert('๋„ˆ๋ฌด ๋น ๋ฅธ ํด๋ฆญ์ด ๊ฐ์ง€๋˜์—ˆ์Šต๋‹ˆ๋‹ค.');
        return;
    }
    
    // ๋งˆ์šฐ์Šค ์›€์ง์ž„์ด ์žˆ์—ˆ๋Š”์ง€ ํ™•์ธ
    if (!window.mouseMovementDetected) {
        alert('๋น„์ •์ƒ์ ์ธ ํ™œ๋™์ด ๊ฐ์ง€๋˜์—ˆ์Šต๋‹ˆ๋‹ค.');
        return;
    }
    
    // ๊ตฌ๋งค ์ง„ํ–‰
    await processPurchase();
});

// ๋งˆ์šฐ์Šค ์›€์ง์ž„ ๊ฐ์ง€
window.mouseMovementDetected = false;
document.addEventListener('mousemove', () => {
    window.mouseMovementDetected = true;
}, { once: true });

2๋‹จ๊ณ„: ์บก์ฐจ + ๋Œ€๊ธฐ์—ด ์‹œ์Šคํ…œ
// ์ธ๊ธฐ ์•„์ดํ…œ์€ ๋Œ€๊ธฐ์—ด ์‹œ์Šคํ…œ ์ ์šฉ
app.post('/api/purchase/:itemId', async (req, res) => {
    const item = await getItem(req.params.itemId);
    
    // ์ธ๊ธฐ ์•„์ดํ…œ์ธ ๊ฒฝ์šฐ
    if (item.popularity > 80) {
        // reCAPTCHA ๊ฒ€์ฆ ํ•„์ˆ˜
        const captchaValid = await verifyRecaptcha(req.body.captcha_token);
        
        if (!captchaValid) {
            return res.status(403).json({ 
                error: '์บก์ฐจ ๊ฒ€์ฆ์— ์‹คํŒจํ–ˆ์Šต๋‹ˆ๋‹ค.' 
            });
        }
        
        // ๋Œ€๊ธฐ์—ด์— ์ถ”๊ฐ€
        const queuePosition = await addToQueue(req.user.id, req.params.itemId);
        
        return res.json({
            status: 'queued',
            position: queuePosition,
            estimatedWait: queuePosition * 2  // ์ดˆ ๋‹จ์œ„
        });
    }
    
    // ์ผ๋ฐ˜ ์•„์ดํ…œ์€ ๋ฐ”๋กœ ๊ตฌ๋งค
    await processPurchase(req.user.id, req.params.itemId);
    res.json({ status: 'success' });
});

3๋‹จ๊ณ„: ๊ตฌ๋งค ํŒจํ„ด ๋ถ„์„
// ๋น„์ •์ƒ์ ์ธ ๊ตฌ๋งค ํŒจํ„ด ๊ฐ์ง€
class PurchasePatternAnalyzer {
    constructor() {
        this.userPurchases = new Map();
    }
    
    async analyzePurchase(userId, itemId) {
        const key = userId;
        const purchases = this.userPurchases.get(key) || [];
        
        const now = Date.now();
        purchases.push({ itemId, timestamp: now });
        
        // ์ตœ๊ทผ 1์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ๋งŒ ์œ ์ง€
        const recentPurchases = purchases.filter(p => 
            now - p.timestamp < 60 * 60 * 1000
        );
        
        this.userPurchases.set(key, recentPurchases);
        
        // ์˜์‹ฌ์Šค๋Ÿฌ์šด ํŒจํ„ด ์ฒดํฌ
        const suspiciousPatterns = {
            tooManyPurchases: recentPurchases.length > 10,  // 1์‹œ๊ฐ„์— 10๊ฐœ ์ด์ƒ
            tooFast: this.checkPurchaseSpeed(recentPurchases),
            sameItems: this.checkDuplicateItems(recentPurchases)
        };
        
        const isSuspicious = Object.values(suspiciousPatterns).some(v => v);
        
        if (isSuspicious) {
            await this.flagUser(userId, suspiciousPatterns);
        }
        
        return !isSuspicious;
    }
    
    checkPurchaseSpeed(purchases) {
        if (purchases.length < 2) return false;
        
        // ์—ฐ์† ๊ตฌ๋งค ๊ฐ„๊ฒฉ์ด ๋ชจ๋‘ 5์ดˆ ๋ฏธ๋งŒ์ด๋ฉด ์˜์‹ฌ
        for (let i = 1; i < purchases.length; i++) {
            const interval = purchases[i].timestamp - purchases[i-1].timestamp;
            if (interval >= 5000) return false;
        }
        
        return true;
    }
    
    checkDuplicateItems(purchases) {
        const itemCounts = {};
        
        purchases.forEach(p => {
            itemCounts[p.itemId] = (itemCounts[p.itemId] || 0) + 1;
        });
        
        // ๊ฐ™์€ ์•„์ดํ…œ์„ 3๋ฒˆ ์ด์ƒ ๊ตฌ๋งคํ•˜๋ฉด ์˜์‹ฌ
        return Object.values(itemCounts).some(count => count >= 3);
    }
    
    async flagUser(userId, reasons) {
        await logger.warn('Suspicious purchase pattern', {
            userId,
            reasons,
            timestamp: new Date().toISOString()
        });
        
        // ์ผ์‹œ์ ์œผ๋กœ ๊ตฌ๋งค ์ œํ•œ
        await redis.setex(`purchase_limit:${userId}`, 3600, '1');
        
        // ๊ด€๋ฆฌ์ž์—๊ฒŒ ์•Œ๋ฆผ
        await sendSlackAlert(
            `์‚ฌ์šฉ์ž ${userId}์˜ ๋น„์ •์ƒ์ ์ธ ๊ตฌ๋งค ํŒจํ„ด ๊ฐ์ง€\n` +
            `์‚ฌ์œ : ${JSON.stringify(reasons)}`,
            'warning'
        );
    }
}

const analyzer = new PurchasePatternAnalyzer();

app.post('/api/purchase/:itemId', async (req, res) => {
    // ๊ตฌ๋งค ์ œํ•œ ์ฒดํฌ
    const isLimited = await redis.get(`purchase_limit:${req.user.id}`);
    
    if (isLimited) {
        return res.status(429).json({
            error: '์ผ์‹œ์ ์œผ๋กœ ๊ตฌ๋งค๊ฐ€ ์ œํ•œ๋˜์—ˆ์Šต๋‹ˆ๋‹ค. ๊ณ ๊ฐ์„ผํ„ฐ์— ๋ฌธ์˜ํ•ด์ฃผ์„ธ์š”.'
        });
    }
    
    // ํŒจํ„ด ๋ถ„์„
    const isAllowed = await analyzer.analyzePurchase(
        req.user.id, 
        req.params.itemId
    );
    
    if (!isAllowed) {
        return res.status(403).json({
            error: '๋น„์ •์ƒ์ ์ธ ํ™œ๋™์ด ๊ฐ์ง€๋˜์—ˆ์Šต๋‹ˆ๋‹ค.'
        });
    }
    
    // ๊ตฌ๋งค ์ง„ํ–‰
    await processPurchase(req.user.id, req.params.itemId);
    res.json({ status: 'success' });
});

๊ฒฐ๊ณผ:
โ€ข ๋ด‡ ๊ตฌ๋งค 90% ๊ฐ์†Œ
โ€ข ์ผ๋ฐ˜ ์œ ์ € ๋งŒ์กฑ๋„ ์ƒ์Šน
โ€ข ๊ฑฐ๋ž˜ ๊ณต์ •์„ฑ ํ™•๋ณด

์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ๋„ ์ด๋Ÿฐ ๋ฐฉ์‹์„ ์‘์šฉํ•  ์ˆ˜ ์žˆ์–ด. ์ธ๊ธฐ ์žฌ๋Šฅ ์„œ๋น„์Šค์— ๋Œ€ํ•œ ์ž๋™ ์˜ˆ์•ฝ ๋ด‡์„ ๋ง‰๋Š” ๋ฐ ํšจ๊ณผ์ ์ด๊ฑฐ๋“ ! ๐ŸŽฏ

๐Ÿš€ ์ตœ์‹  ํŠธ๋ Œ๋“œ์™€ ๋ฏธ๋ž˜ ๊ธฐ์ˆ 

๋ณด์•ˆ ๊ธฐ์ˆ ์€ ๊ณ„์† ์ง„ํ™”ํ•˜๊ณ  ์žˆ์–ด. ์ตœ์‹  ํŠธ๋ Œ๋“œ๋ฅผ ์•Œ์•„๋‘๋ฉด ์•ž์„œ๊ฐˆ ์ˆ˜ ์žˆ์ง€!

๐Ÿง  AI ๊ธฐ๋ฐ˜ ๋ด‡ ํƒ์ง€

์š”์ฆ˜์€ ๋”ฅ๋Ÿฌ๋‹์„ ํ™œ์šฉํ•œ ๋ด‡ ํƒ์ง€๊ฐ€ ๋Œ€์„ธ์•ผ. ํŠนํžˆ GAN(Generative Adversarial Network)์„ ์—ญ์œผ๋กœ ํ™œ์šฉํ•˜๋Š” ๋ฐฉ๋ฒ•์ด ์ฃผ๋ชฉ๋ฐ›๊ณ  ์žˆ์–ด.

์ž‘๋™ ์›๋ฆฌ:
1. ์ •์ƒ ์‚ฌ์šฉ์ž์˜ ํ–‰๋™ ํŒจํ„ด์„ ํ•™์Šต
2. ์ƒˆ๋กœ์šด ์š”์ฒญ์ด ๋“ค์–ด์˜ค๋ฉด ์‹ค์‹œ๊ฐ„์œผ๋กœ ๋ถ„์„
3. ์ด์ƒ ์ง•ํ›„๋ฅผ ์ž๋™์œผ๋กœ ๊ฐ์ง€
4. ์ง€์†์ ์ธ ํ•™์Šต์œผ๋กœ ์ •ํ™•๋„ ํ–ฅ์ƒ

์‹ค์ œ๋กœ ๊ตฌ๊ธ€, ์•„๋งˆ์กด ๊ฐ™์€ ๋Œ€๊ธฐ์—…๋“ค์€ ์ด๋ฏธ ์ด๋Ÿฐ ์‹œ์Šคํ…œ์„ ์šด์˜ ์ค‘์ด์•ผ. ๊ฐœ์ธ ๊ฐœ๋ฐœ์ž๋„ TensorFlow.js๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ธŒ๋ผ์šฐ์ €์—์„œ ์ง์ ‘ ๋ชจ๋ธ์„ ์‹คํ–‰ํ•  ์ˆ˜ ์žˆ์–ด!

// TensorFlow.js ์˜ˆ์‹œ
import * as tf from '@tensorflow/tfjs';

class BehaviorClassifier {
    constructor() {
        this.model = null;
    }
    
    async loadModel() {
        this.model = await tf.loadLayersModel('/models/bot-detector/model.json');
    }
    
    async predict(behaviorData) {
        // ์ž…๋ ฅ ๋ฐ์ดํ„ฐ ์ •๊ทœํ™”
        const input = tf.tensor2d([[
            behaviorData.mouseSpeed / 1000,
            behaviorData.clickInterval / 1000,
            behaviorData.scrollSpeed / 100,
            behaviorData.pageTime / 60000
        ]]);
        
        // ์˜ˆ์ธก
        const prediction = this.model.predict(input);
        const score = await prediction.data();
        
        input.dispose();
        prediction.dispose();
        
        return score[0];  // 0~1 ์‚ฌ์ด์˜ ๋ด‡ ํ™•๋ฅ 
    }
}

// ์‚ฌ์šฉ
const classifier = new BehaviorClassifier();
await classifier.loadModel();

const score = await classifier.predict({
    mouseSpeed: 500,
    clickInterval: 200,
    scrollSpeed: 50,
    pageTime: 30000
});

if (score > 0.8) {
    console.log('๋ด‡์œผ๋กœ ํŒ๋‹จ๋จ');
}
๐Ÿ” ๋ธ”๋ก์ฒด์ธ ๊ธฐ๋ฐ˜ ์ธ์ฆ ๋ธ”๋ก์ฒด์ธ์„ ํ™œ์šฉํ•œ ๋ถ„์‚ฐ ์‹ ์› ์ธ์ฆ(DID)๋„ ๋– ์˜ค๋ฅด๋Š” ๊ธฐ์ˆ ์ด์•ผ. ์ค‘์•™ ์„œ๋ฒ„ ์—†์ด๋„ ์‚ฌ์šฉ์ž๋ฅผ ์•ˆ์ „ํ•˜๊ฒŒ ์ธ์ฆํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ .

์žฅ์ :
โ€ข ์œ„๋ณ€์กฐ ๋ถˆ๊ฐ€๋Šฅ
โ€ข ๊ฐœ์ธ์ •๋ณด ๋ณดํ˜ธ
โ€ข ๋‹จ์ผ ์žฅ์• ์  ์—†์Œ
โ€ข ํฌ๋กœ์Šค ํ”Œ๋žซํผ ์ธ์ฆ ๊ฐ€๋Šฅ

์•„์ง์€ ์ดˆ๊ธฐ ๋‹จ๊ณ„์ง€๋งŒ, ์•ž์œผ๋กœ ์›น3.0 ์‹œ๋Œ€์—๋Š” ํ•„์ˆ˜ ๊ธฐ์ˆ ์ด ๋  ๊ฑฐ์•ผ! ๐ŸŒ
๐ŸŽฏ ํ–‰๋™ ์ƒ์ฒด ์ธ์ฆ (Behavioral Biometrics)

ํƒ€์ดํ•‘ ์†๋„, ๋งˆ์šฐ์Šค ์›€์ง์ž„ ํŒจํ„ด, ํ„ฐ์น˜ ์••๋ ฅ ๋“ฑ ์‚ฌ์šฉ์ž์˜ ๊ณ ์œ ํ•œ ํ–‰๋™ ํŠน์„ฑ์„ ์ธ์ฆ์— ํ™œ์šฉํ•˜๋Š” ๊ฑฐ์•ผ.

// ํƒ€์ดํ•‘ ํŒจํ„ด ๋ถ„์„
class TypingPatternAnalyzer {
    constructor() {
        this.keyTimings = [];
    }
    
    recordKeyPress(key, timestamp) {
        this.keyTimings.push({ key, timestamp });
    }
    
    analyzePattern() {
        if (this.keyTimings.length < 10) return null;
        
        const intervals = [];
        for (let i = 1; i < this.keyTimings.length; i++) {
            intervals.push(
                this.keyTimings[i].timestamp - this.keyTimings[i-1].timestamp
            );
        }
        
        // ํ‰๊ท  ํƒ€์ดํ•‘ ์†๋„
        const avgSpeed = intervals.reduce((a, b) => a + b) / intervals.length;
        
        // ์†๋„ ๋ณ€๋™์„ฑ (ํ‘œ์ค€ํŽธ์ฐจ)
        const variance = intervals.reduce((sum, val) => 
            sum + Math.pow(val - avgSpeed, 2), 0) / intervals.length;
        const stdDev = Math.sqrt(variance);
        
        return {
            avgSpeed,
            stdDev,
            pattern: intervals
        };
    }
    
    comparePatterns(pattern1, pattern2) {
        // ๋‘ ํŒจํ„ด์˜ ์œ ์‚ฌ๋„ ๊ณ„์‚ฐ
        const speedDiff = Math.abs(pattern1.avgSpeed - pattern2.avgSpeed);
        const stdDevDiff = Math.abs(pattern1.stdDev - pattern2.stdDev);
        
        // ์ •๊ทœํ™”๋œ ์œ ์‚ฌ๋„ ์ ์ˆ˜ (0~100)
        const similarity = 100 - Math.min(
            (speedDiff / 100 + stdDevDiff / 50) * 50,
            100
        );
        
        return similarity;
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
const analyzer = new TypingPatternAnalyzer();

document.addEventListener('keydown', (e) => {
    analyzer.recordKeyPress(e.key, Date.now());
});

// ๋กœ๊ทธ์ธ ์‹œ ํŒจํ„ด ๊ฒ€์ฆ
async function verifyUser(username, password) {
    const currentPattern = analyzer.analyzePattern();
    const storedPattern = await getUserTypingPattern(username);
    
    if (!storedPattern) {
        // ์ฒซ ๋กœ๊ทธ์ธ - ํŒจํ„ด ์ €์žฅ
        await saveUserTypingPattern(username, currentPattern);
        return true;
    }
    
    const similarity = analyzer.comparePatterns(currentPattern, storedPattern);
    
    if (similarity < 70) {
        // ํƒ€์ดํ•‘ ํŒจํ„ด์ด ๋‹ค๋ฆ„ - ์ถ”๊ฐ€ ์ธ์ฆ ์š”๊ตฌ
        return { requiresAdditionalAuth: true, similarity };
    }
    
    return true;
}

์ด ๋ฐฉ๋ฒ•์€ ์‚ฌ์šฉ์ž๊ฐ€ ์˜์‹ํ•˜์ง€ ๋ชปํ•˜๋Š” ์‚ฌ์ด์— ์ง€์†์ ์œผ๋กœ ์ธ์ฆ์ด ์ด๋ฃจ์–ด์ ธ์„œ ํŽธ๋ฆฌํ•˜๋ฉด์„œ๋„ ์•ˆ์ „ํ•ด! ๐Ÿ”’

๐Ÿ’ก ์‹ค๋ฌด ํŒ๊ณผ ๋ฒ ์ŠคํŠธ ํ”„๋ž™ํ‹ฐ์Šค

๋งˆ์ง€๋ง‰์œผ๋กœ ์‹ค๋ฌด์—์„œ ๊ผญ ์•Œ์•„์•ผ ํ•  ํŒ๋“ค์„ ์ •๋ฆฌํ•ด์ค„๊ฒŒ!

โœ… ๋‹ค์ธต ๋ฐฉ์–ด ์ „๋žต (Defense in Depth) ํ•˜๋‚˜์˜ ๋ฐฉ์–ด ๊ธฐ๋ฒ•๋งŒ์œผ๋กœ๋Š” ๋ถ€์กฑํ•ด. ์—ฌ๋Ÿฌ ๋ ˆ์ด์–ด๋ฅผ ๊ฒน์ณ์„œ ๋ฐฉ์–ดํ•ด์•ผ ํ•ด:

๋ ˆ์ด์–ด 1: ๋„คํŠธ์›Œํฌ ๋ ˆ๋ฒจ
โ€ข CDN/WAF (Cloudflare, AWS WAF)
โ€ข DDoS ๋ฐฉ์–ด
โ€ข IP ๊ธฐ๋ฐ˜ ํ•„ํ„ฐ๋ง

๋ ˆ์ด์–ด 2: ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜ ๋ ˆ๋ฒจ
โ€ข Rate Limiting
โ€ข User-Agent ๊ฒ€์ฆ
โ€ข Referrer ์ฒดํฌ

๋ ˆ์ด์–ด 3: ํ–‰๋™ ๋ถ„์„
โ€ข JavaScript ์ฑŒ๋ฆฐ์ง€
โ€ข ๋งˆ์šฐ์Šค/ํ‚ค๋ณด๋“œ ํŒจํ„ด ๋ถ„์„
โ€ข ํƒ€์ด๋ฐ ๊ฒ€์ฆ

๋ ˆ์ด์–ด 4: ์ธ์ฆ/์ธ๊ฐ€
โ€ข JWT ํ† ํฐ
โ€ข CAPTCHA
โ€ข 2FA (Two-Factor Authentication)

๋ ˆ์ด์–ด 5: ๋ชจ๋‹ˆํ„ฐ๋ง
โ€ข ์‹ค์‹œ๊ฐ„ ๋กœ๊ทธ ๋ถ„์„
โ€ข ์ด์ƒ ์ง•ํ›„ ํƒ์ง€
โ€ข ์ž๋™ ๋Œ€์‘ ์‹œ์Šคํ…œ

์ด๋ ‡๊ฒŒ 5๊ฐœ ๋ ˆ์ด์–ด๋ฅผ ๋ชจ๋‘ ๊ตฌ์ถ•ํ•˜๋ฉด ๊ฑฐ์˜ ์™„๋ฒฝํ•œ ๋ฐฉ์–ด๊ฐ€ ๊ฐ€๋Šฅํ•ด! ๐Ÿ’ช
โš ๏ธ ํ”ํ•œ ์‹ค์ˆ˜๋“ค 1. ๊ณผ๋„ํ•œ ๋ณด์•ˆ์œผ๋กœ ์‚ฌ์šฉ์ž ๊ฒฝํ—˜ ํ•ด์นจ
๋ณด์•ˆ์ด ์ค‘์š”ํ•˜๋‹ค๊ณ  CAPTCHA๋ฅผ ๋ชจ๋“  ํŽ˜์ด์ง€์— ๋„ฃ์œผ๋ฉด? ์‚ฌ์šฉ์ž๋“ค์ด ๋– ๋‚˜๋ฒ„๋ ค. ๊ท ํ˜•์ด ์ค‘์š”ํ•ด!

2. ํด๋ผ์ด์–ธํŠธ ์‚ฌ์ด๋“œ๋งŒ ๋ฏฟ๊ธฐ
JavaScript๋กœ๋งŒ ๊ฒ€์ฆํ•˜๋ฉด ์‰ฝ๊ฒŒ ์šฐํšŒ๋ผ. ๋ฐ˜๋“œ์‹œ ์„œ๋ฒ„ ์‚ฌ์ด๋“œ ๊ฒ€์ฆ๋„ ํ•ด์•ผ ํ•ด!

3. ์—๋Ÿฌ ๋ฉ”์‹œ์ง€๋กœ ์ •๋ณด ๋…ธ์ถœ
"์ด IP๋Š” ์ฐจ๋‹จ๋˜์—ˆ์Šต๋‹ˆ๋‹ค" ๊ฐ™์€ ๋ฉ”์‹œ์ง€๋Š” ๊ณต๊ฒฉ์ž์—๊ฒŒ ํžŒํŠธ๋ฅผ ์ค˜. ์ผ๋ฐ˜์ ์ธ ๋ฉ”์‹œ์ง€๋ฅผ ์‚ฌ์šฉํ•ด!

4. ๋กœ๊ทธ๋ฅผ ์•ˆ ๋‚จ๊ธฐ๊ฑฐ๋‚˜ ๋ถ„์„ ์•ˆ ํ•จ
๋กœ๊ทธ ์—†์ด๋Š” ๊ณต๊ฒฉ ํŒจํ„ด์„ ํŒŒ์•…ํ•  ์ˆ˜ ์—†์–ด. ๋ฐ˜๋“œ์‹œ ๋กœ๊น…ํ•˜๊ณ  ์ •๊ธฐ์ ์œผ๋กœ ๋ถ„์„ํ•ด!

5. ์—…๋ฐ์ดํŠธ ์•ˆ ํ•จ
๋ด‡ ๊ธฐ์ˆ ๋„ ๊ณ„์† ์ง„ํ™”ํ•ด. ๋ฐฉ์–ด ์‹œ์Šคํ…œ๋„ ์ง€์†์ ์œผ๋กœ ์—…๋ฐ์ดํŠธํ•ด์•ผ ํ•ด!
๐ŸŽฏ ์„ฑ๋Šฅ ์ตœ์ ํ™” ํŒ

๋ณด์•ˆ ๊ฒ€์‚ฌ๊ฐ€ ๋งŽ์•„์ง€๋ฉด ์„ฑ๋Šฅ์ด ๋–จ์–ด์งˆ ์ˆ˜ ์žˆ์–ด. ์ตœ์ ํ™” ๋ฐฉ๋ฒ•๋“ค:

1. ์บ์‹ฑ ํ™œ์šฉ
// Redis๋กœ ๊ฒ€์ฆ ๊ฒฐ๊ณผ ์บ์‹ฑ
async function checkBot(ip, userAgent) {
    const cacheKey = `bot_check:${ip}:${userAgent}`;
    
    // ์บ์‹œ ํ™•์ธ
    const cached = await redis.get(cacheKey);
    if (cached !== null) {
        return JSON.parse(cached);
    }
    
    // ์‹ค์ œ ๊ฒ€์ฆ
    const result = await performBotCheck(ip, userAgent);
    
    // ๊ฒฐ๊ณผ ์บ์‹ฑ (5๋ถ„)
    await redis.setex(cacheKey, 300, JSON.stringify(result));
    
    return result;
}

2. ๋น„๋™๊ธฐ ์ฒ˜๋ฆฌ
// ๋ฌด๊ฑฐ์šด ๊ฒ€์ฆ์€ ๋ฐฑ๊ทธ๋ผ์šด๋“œ์—์„œ
app.post('/api/action', async (req, res) => {
    // ๋น ๋ฅธ ๊ธฐ๋ณธ ๊ฒ€์ฆ๋งŒ ํ•˜๊ณ  ์‘๋‹ต
    const basicCheck = quickValidation(req);
    
    if (!basicCheck) {
        return res.status(403).json({ error: 'Forbidden' });
    }
    
    // ์‘๋‹ต ๋จผ์ € ๋ณด๋‚ด๊ธฐ
    res.json({ status: 'processing' });
    
    // ๋ฌด๊ฑฐ์šด ๊ฒ€์ฆ์€ ๋ฐฑ๊ทธ๋ผ์šด๋“œ์—์„œ
    performDeepAnalysis(req).then(result => {
        if (!result.isValid) {
            flagUser(req.user.id);
        }
    });
});

3. ์ƒ˜ํ”Œ๋ง
// ๋ชจ๋“  ์š”์ฒญ์„ ๊ฒ€์‚ฌํ•˜์ง€ ๋ง๊ณ  ์ƒ˜ํ”Œ๋ง
function shouldPerformDeepCheck() {
    // 10% ํ™•๋ฅ ๋กœ ์‹ฌ์ธต ๊ฒ€์‚ฌ
    return Math.random() < 0.1;
}

app.use((req, res, next) => {
    // ๊ธฐ๋ณธ ๊ฒ€์‚ฌ๋Š” ํ•ญ์ƒ
    if (!basicCheck(req)) {
        return res.status(403).send('Forbidden');
    }
    
    // ์‹ฌ์ธต ๊ฒ€์‚ฌ๋Š” ์ƒ˜ํ”Œ๋ง
    if (shouldPerformDeepCheck()) {
        performDeepCheck(req);
    }
    
    next();
});

์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ๋ณด์•ˆ์€ ์œ ์ง€ํ•˜๋ฉด์„œ๋„ ์„ฑ๋Šฅ ์ €ํ•˜๋ฅผ ์ตœ์†Œํ™”ํ•  ์ˆ˜ ์žˆ์–ด! โšก

๐ŸŽฌ ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€, ์—ฌ๊ธฐ๊นŒ์ง€ ์ •๋ง ๊ธด ์—ฌ์ •์ด์—ˆ์ง€? ๐Ÿ˜… ์›น ์Šคํฌ๋ž˜ํ•‘ ๋ฐฉ์ง€์™€ ๋ด‡ ํƒ์ง€๋Š” ๋์—†๋Š” ์‹ธ์›€์ด์•ผ. ๋ด‡์ด ์ง„ํ™”ํ•˜๋ฉด ์šฐ๋ฆฌ๋„ ์ง„ํ™”ํ•ด์•ผ ํ•˜๊ฑฐ๋“ .

๐ŸŽฏ ํ•ต์‹ฌ ์ •๋ฆฌ ๊ธฐ์–ตํ•ด์•ผ ํ•  ๊ฒƒ๋“ค:

1๏ธโƒฃ ๋‹ค์ธต ๋ฐฉ์–ด๊ฐ€ ๋‹ต์ด๋‹ค
ํ•˜๋‚˜์˜ ๊ธฐ๋ฒ•๋งŒ์œผ๋กœ๋Š” ๋ถ€์กฑํ•ด. ์—ฌ๋Ÿฌ ๋ ˆ์ด์–ด๋ฅผ ์กฐํ•ฉํ•ด์•ผ ํ•ด.

2๏ธโƒฃ ์‚ฌ์šฉ์ž ๊ฒฝํ—˜์„ ํ•ด์น˜์ง€ ๋ง์ž
๋ณด์•ˆ๊ณผ ํŽธ์˜์„ฑ์˜ ๊ท ํ˜•์ด ์ค‘์š”ํ•ด. ์ •์ƒ ์‚ฌ์šฉ์ž๊ฐ€ ๋ถˆํŽธํ•˜๋ฉด ์•ˆ ๋ผ.

3๏ธโƒฃ ์ง€์†์ ์ธ ๋ชจ๋‹ˆํ„ฐ๋ง๊ณผ ๊ฐœ์„ 
ํ•œ ๋ฒˆ ์„ค์ •ํ•˜๊ณ  ๋์ด ์•„๋‹ˆ์•ผ. ๊ณ„์† ๋ชจ๋‹ˆํ„ฐ๋งํ•˜๊ณ  ์—…๋ฐ์ดํŠธํ•ด์•ผ ํ•ด.

4๏ธโƒฃ ๋กœ๊ทธ์™€ ๋ฐ์ดํ„ฐ ๋ถ„์„
๊ณต๊ฒฉ ํŒจํ„ด์„ ์ดํ•ดํ•ด์•ผ ํšจ๊ณผ์ ์œผ๋กœ ๋Œ€์‘ํ•  ์ˆ˜ ์žˆ์–ด.

5๏ธโƒฃ ์ตœ์‹  ๊ธฐ์ˆ  ํŠธ๋ Œ๋“œ ํŒŒ์•…
AI, ๋ธ”๋ก์ฒด์ธ, ํ–‰๋™ ์ƒ์ฒด ์ธ์ฆ ๋“ฑ ์ƒˆ๋กœ์šด ๊ธฐ์ˆ ์„ ์ฃผ์‹œํ•ด์•ผ ํ•ด.

๐Ÿ’ผ ์‹ค๋ฌด ์ ์šฉ ๋กœ๋“œ๋งต 1์ฃผ์ฐจ: ๊ธฐ๋ณธ ๋ฐฉ์–ด ๊ตฌ์ถ•
โ€ข robots.txt ์„ค์ •
โ€ข Rate Limiting ๊ตฌํ˜„
โ€ข User-Agent ๊ฒ€์ฆ

2์ฃผ์ฐจ: ์ค‘๊ธ‰ ๊ธฐ์ˆ  ๋„์ž…
โ€ข ๋™์  ํ† ํฐ ์‹œ์Šคํ…œ
โ€ข JavaScript ์ฑŒ๋ฆฐ์ง€
โ€ข ํ—ˆ๋‹ˆํŒŸ ์„ค์น˜

3์ฃผ์ฐจ: ๋ชจ๋‹ˆํ„ฐ๋ง ์‹œ์Šคํ…œ
โ€ข ๋กœ๊น… ์‹œ์Šคํ…œ ๊ตฌ์ถ•
โ€ข ๋Œ€์‹œ๋ณด๋“œ ์„ค์ •
โ€ข ์•Œ๋ฆผ ์‹œ์Šคํ…œ ์—ฐ๋™

4์ฃผ์ฐจ: ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ
โ€ข ํ–‰๋™ ํŒจํ„ด ๋ถ„์„
โ€ข ๋จธ์‹ ๋Ÿฌ๋‹ ๋ชจ๋ธ ๋„์ž…
โ€ข ์ž๋™ ๋Œ€์‘ ์‹œ์Šคํ…œ

์ด๋ ‡๊ฒŒ ๋‹จ๊ณ„์ ์œผ๋กœ ์ ‘๊ทผํ•˜๋ฉด ๋ถ€๋‹ด ์—†์ด ๊ตฌ์ถ•ํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿš€
์žฌ๋Šฅ๋„ท์—์„œ ์›น ๊ฐœ๋ฐœ ์žฌ๋Šฅ์„ ๊ฑฐ๋ž˜ํ•˜๋Š” ๋ถ„๋“ค๋„ ์ด๋Ÿฐ ๋ณด์•ˆ ๊ธฐ์ˆ ์„ ์ž˜ ํ™œ์šฉํ•˜๋ฉด ๋” ์•ˆ์ „ํ•˜๊ณ  ์‹ ๋ขฐ๋ฐ›๋Š” ์„œ๋น„์Šค๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์„ ๊ฑฐ์•ผ. ํŠนํžˆ ์‚ฌ์šฉ์ž ๋ฐ์ดํ„ฐ๋ฅผ ๋‹ค๋ฃจ๋Š” ํ”Œ๋žซํผ์ด๋ผ๋ฉด ๋ณด์•ˆ์€ ์„ ํƒ์ด ์•„๋‹ˆ๋ผ ํ•„์ˆ˜๊ฑฐ๋“ !

๊ธฐ์–ตํ•ด, ์™„๋ฒฝํ•œ ๋ณด์•ˆ์€ ์—†์–ด. ํ•˜์ง€๋งŒ ์ง€์†์ ์œผ๋กœ ๋…ธ๋ ฅํ•˜๋ฉด ๋Œ€๋ถ€๋ถ„์˜ ๊ณต๊ฒฉ์„ ๋ง‰์„ ์ˆ˜ ์žˆ์–ด. ์˜ค๋Š˜ ๋ฐฐ์šด ๋‚ด์šฉ๋“ค์„ ์‹ค์ „์— ์ ์šฉํ•ด๋ณด๊ณ , ๊ณ„์† ๊ฐœ์„ ํ•ด๋‚˜๊ฐ€์ž! ๐Ÿ’ช

๊ถ๊ธˆํ•œ ์ ์ด๋‚˜ ๋” ์•Œ๊ณ  ์‹ถ์€ ๋‚ด์šฉ์ด ์žˆ์œผ๋ฉด ์–ธ์ œ๋“  ์ฐพ์•„๋ด. ๋ณด์•ˆ์€ ํ•จ๊ป˜ ๊ณต๋ถ€ํ•˜๊ณ  ๊ณต์œ ํ•  ๋•Œ ๋” ๊ฐ•ํ•ด์ง€๋‹ˆ๊นŒ! ๐Ÿค

๊ทธ๋Ÿผ ์•ˆ์ „ํ•œ ์›น ๊ฐœ๋ฐœ ๋˜๊ธธ ๋ฐ”๋ž„๊ฒŒ! ํ™”์ดํŒ…! ๐ŸŽ‰
๐Ÿ›ก๏ธ ๋‹น์‹ ์˜ ์›น์‚ฌ์ดํŠธ๋ฅผ ์ง€ํ‚ค๋Š” ์—ฌ์ •, ์ง€๊ธˆ ์‹œ์ž‘ํ•˜์„ธ์š”!

๋ณด์•ˆ์€ ํ•œ ๋ฒˆ์˜ ์„ค์ •์ด ์•„๋‹Œ ์ง€์†์ ์ธ ๊ณผ์ •์ž…๋‹ˆ๋‹ค.
์˜ค๋Š˜ ๋ฐฐ์šด ๊ธฐ์ˆ ๋“ค์„ ํ•˜๋‚˜์”ฉ ์ ์šฉํ•˜๋ฉฐ ๋” ์•ˆ์ „ํ•œ ์›น์„ ๋งŒ๋“ค์–ด๊ฐ€์„ธ์š”! ๐Ÿ’ช

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.