Ver3.0 ๐ก๏ธ ์น ์คํฌ๋ํ ๋ฐฉ์ง์ ๋ด ํ์ง๋ฅผ ์ํ ๋ณด์ ๊ธฐ์ ๊ตฌํ ์๋ฒฝ ๊ฐ์ด๋

๐ก๏ธ ์น ์คํฌ๋ํ ๋ฐฉ์ง์ ๋ด ํ์ง๋ฅผ ์ํ ๋ณด์ ๊ธฐ์ ๊ตฌํ ์๋ฒฝ ๊ฐ์ด๋
๋น์ ์ ์น์ฌ์ดํธ๋ฅผ ์งํค๋ ์ต์ ๋ฐฉ์ด ๊ธฐ์ ๋ค
๐ค ์น ์คํฌ๋ํ๊ณผ ๋ด, ์ ๋ฌธ์ ๊ฐ ๋ ๊น?
์ค์ ๋ก ์ด๋ค ๋ฌธ์ ๋ค์ด ๋ฐ์ํ๋์ง ๋ณผ๊น?
๐ธ ๋น์ฆ๋์ค ์์ค
๊ฒฝ์์ฌ๊ฐ ๋น์ ์ ๊ฐ๊ฒฉ ์ ๋ณด๋ฅผ ์ค์๊ฐ์ผ๋ก ๊ธ์ด๊ฐ์ ํญ์ ์กฐ๊ธ ๋ ์ธ๊ฒ ํ๋ค๋ฉด? ์ด์ปค๋จธ์ค ์ ๊ณ์์๋ ์ค์ ๋ก ํํ ์ผ์ด์ผ. ํ ์จ๋ผ์ธ ์ผํ๋ชฐ์ ํ๋ฃจ์ ์๋ฐฑ๋ง ๊ฑด์ ์คํฌ๋ํ ์์ฒญ์ผ๋ก ์ธํด ์๋ฒ ๋น์ฉ๋ง ์ ์์ฒ๋ง ์์ด ์ถ๊ฐ๋ก ๋ฐ์ํ๋.
โก ์๋ฒ ๊ณผ๋ถํ
์ ์ ์ฌ์ฉ์ 100๋ช ์ด ์ ์ํ ๋์ ๋ด 10,000๊ฐ๊ฐ ๋์์ ํฌ๋กค๋งํ ๋์ ์๋ฒ ๋ถํ๋ ๋น๊ต๊ฐ ์ ๋ผ. ์ค์ ์ฌ์ฉ์๋ค์ ๋๋ฆฐ ์๋ ๋๋ฌธ์ ์ดํํ๊ณ , ๋น์ ์ AWS ์ฒญ๊ตฌ์๋ฅผ ๋ณด๊ณ ๊ธฐ์ ํ๋ ๊ฑฐ์ง. ๐ฑ
๐ ๋ฐ์ดํฐ ์ ์ถ
ํ์ ์ ๋ณด, ๋ ์ ์ฝํ ์ธ , ๋น์ฆ๋์ค ๋ก์ง... ์ด๋ฐ ๊ฒ๋ค์ด ๋ฌด๋จ์ผ๋ก ์์ง๋๋ฉด ์ฌ๊ฐํ ๋ณด์ ์ฌ๊ณ ๋ก ์ด์ด์ง ์ ์์ด. ํนํ ๊ฐ์ธ์ ๋ณด๋ณดํธ๋ฒ ์๋ฐ์ผ๋ก ๋ฒ์ ์ฑ ์๊น์ง ์ง ์ ์๋ค๊ณ !
๐ ๋ด์ ๊ตฌ๋ณํ๋ ํต์ฌ ์๋ฆฌ
โข ๋ง์ฐ์ค ์์ง์์ด ์๊ฑฐ๋ ์ง์ ์
โข ํ์ด์ง ๋ก๋ฉ ํ ์ ํํ 0.5์ด ๋ค์ ๋ค์ ํ์ด์ง๋ก ์ด๋
โข ์คํฌ๋กค ์์ด ๋ฐ๋ก ๋ฐ์ดํฐ ์ถ์ถ
โข ํด๋ฆญ ์ขํ๊ฐ ํฝ์ ๋จ์๋ก ์ ํํจ
์ด๋ฐ ์ฐจ์ด์ ๋ค์ JavaScript๋ก ์ถ์ ํ ์ ์์ด. ์ค์ ๋ก ๊ตฌ๊ธ์ reCAPTCHA v3๋ ์ด๋ฐ ํ๋ ํจํด์ ๋จธ์ ๋ฌ๋์ผ๋ก ๋ถ์ํด์ ๋ด ์ ์๋ฅผ ๋งค๊ธด๋ค๊ณ !
์ฌ๋์ด 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๋ ์๋์ผ๋ก ์ฐจ๋จ๋ผ. ๊ฐ๋จํ์ง๋ง ํจ๊ณผ์ ์ด์ผ! ๐ฏ
๋ด๋ค์ ์ด๋ฐ ์ ๋ณด๋ฅผ ์์กฐํ๊ธฐ ์ด๋ ค์. ํนํ Canvas Fingerprinting ๊ฐ์ ๊ธฐ์ ์ ๋ธ๋ผ์ฐ์ ๊ฐ ๊ทธ๋ํฝ์ ๋ ๋๋งํ๋ ๋ฐฉ์์ ๋ฏธ์ธํ ์ฐจ์ด๊น์ง ๊ฐ์งํ ์ ์๊ฑฐ๋ .
๐ ๏ธ ์ค์ ๋ฐฉ์ด ๊ธฐ์ ๊ตฌํํ๊ธฐ
๐ฑ ์ด๊ธ: ๊ธฐ๋ณธ์ ์ธ ๋ฐฉ์ด ๋ ์ด์ด
๊ฐ์ฅ ๊ธฐ๋ณธ์ด์ง๋ง ์์ธ๋ก ๋ง์ ์ฌ๋๋ค์ด ๋์น๋ ๋ถ๋ถ์ด์ผ. ์ฐฉํ ๋ด๋ค์ ์ด ํ์ผ์ ์กด์คํด์ค.
User-agent: *
Disallow: /admin/
Disallow: /api/private/
Disallow: /user/profile/
Crawl-delay: 10
User-agent: Googlebot
Allow: /
User-agent: BadBot
Disallow: /๋ฌผ๋ก ์ ์์ ์ธ ๋ด์ ๋ฌด์ํ์ง๋ง, ๊ทธ๋๋ ๊ธฐ๋ณธ์ ๊ฐ์ถฐ์ผ์ง! ๐
๋ชจ๋ 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% ์ ๋๋ ๊ฑธ๋ฌ๋ผ ์ ์์ด! ๐ช
์ ์์ ์ธ ์ฌ์ฉ์๋ ๋ณดํต ๊ฒ์์์ง์ด๋ ๋ค๋ฅธ ํ์ด์ง์์ ์ ์ ๋ผ. ํ์ง๋ง ๋ด์ ์ง์ 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๋ฅผ ์คํํ์ง ๋ชปํด.
// ์๋ฒ์์ ์ํ ๋ฌธ์ ๋ฅผ ์์ฑ
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 ํ ์คํธ, ํ์ด๋ฐ ๊ณต๊ฒฉ ๋ฐฉ์ด ๋ฑ์ ์ถ๊ฐํ ์ ์์ด! ๐
์ด๊ฑด ์ง์ง ์ฌ๋ฏธ์๋ ๋ฐฉ๋ฒ์ด์ผ! ์ฌ๋ ๋์๋ ๋ณด์ด์ง ์์ง๋ง ๋ด์ ๋ณผ ์ ์๋ ํจ์ ์ ๋ง๋๋ ๊ฑฐ์ผ.
<!-- 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๋ ๋ฌด๋ฃ ํ๋์์๋ ๊ฐ๋ ฅํ ๋ด ๋ฐฉ์ด ๊ธฐ๋ฅ์ ์ ๊ณตํด. ํนํ "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๋ ์ฌ์ฉ์ ๊ฒฝํ์ ํด์น์ง ์์ผ๋ฉด์๋ ํจ๊ณผ์ ์ผ๋ก ๋ด์ ๊ฑธ๋ฌ๋ผ ์ ์์ด. ์ฒดํฌ๋ฐ์ค ํด๋ฆญ๋ ํ์ ์์ด ๋ฐฑ๊ทธ๋ผ์ด๋์์ ์๋ํ๊ฑฐ๋ !
<!-- 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 ๋ณด์ ๊ฐํ
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;
}
โข ์๊ฐ๋๋ณ ์์ฒญ ์
โข ์ฐจ๋จ๋ IP ์
โข ๋ด ํ์ง์จ
โข ํ๊ท ์๋ต ์๊ฐ
โข ์ง์ญ๋ณ ํธ๋ํฝ ๋ถํฌ
โข ๊ฐ์ฅ ๋ง์ด ๊ณต๊ฒฉ๋ฐ๋ ์๋ํฌ์ธํธ
์ด๋ฐ ๋ฐ์ดํฐ๋ฅผ ์๊ฐํํ๋ฉด ๊ณต๊ฒฉ ํจํด์ ํ์ ํ๊ณ ๋์ ์ ๋ต์ ์ธ์ฐ๊ธฐ ํจ์ฌ ์ฌ์์ ธ! ๐
๐ ์ค์ ์ผ์ด์ค ์คํฐ๋
ํ ์ค์ ์ผํ๋ชฐ์ด ๊ฒฝ์์ฌ์ ๊ฐ๊ฒฉ ์คํฌ๋ํ์ผ๋ก ๊ณ ํต๋ฐ๊ณ ์์์ด. ํ๋ฃจ์ ์๋ง ๊ฑด์ ์์ฒญ์ด ๋ค์ด์์ ์๋ฒ๊ฐ ๋ค์ด๋๊ธฐ ์ผ๋ณด ์ง์ ์ด์์ง.
๋ฌธ์ ๋ถ์:
โข ํน์ 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% ์ ๊ฐ
โข ์ ์ ์ฌ์ฉ์ ๊ฒฝํ์ ๊ทธ๋๋ก ์ ์ง
์ด ๋ฐฉ๋ฒ๋ค์ ์กฐํฉํ๋๊น ๋๋ถ๋ถ์ ์คํฌ๋ํ ๋ด์ ๋ง์ ์ ์์์ด! ๐ช
๊ฒ์ ์์ดํ ๊ฑฐ๋ ํ๋ซํผ์์ ๋ด๋ค์ด ์ ๋ ดํ ์์ดํ ์ ์๋์ผ๋ก ๊ตฌ๋งคํ๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ์ด. ์ผ๋ฐ ์ ์ ๋ค์ ์ข์ ๋์ ์ก์ ๊ธฐํ์กฐ์ฐจ ์์์ง.
ํด๊ฒฐ ๋ฐฉ๋ฒ:
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% ๊ฐ์
โข ์ผ๋ฐ ์ ์ ๋ง์กฑ๋ ์์น
โข ๊ฑฐ๋ ๊ณต์ ์ฑ ํ๋ณด
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์๋ ์ด๋ฐ ๋ฐฉ์์ ์์ฉํ ์ ์์ด. ์ธ๊ธฐ ์ฌ๋ฅ ์๋น์ค์ ๋ํ ์๋ ์์ฝ ๋ด์ ๋ง๋ ๋ฐ ํจ๊ณผ์ ์ด๊ฑฐ๋ ! ๐ฏ
๐ ์ต์ ํธ๋ ๋์ ๋ฏธ๋ ๊ธฐ์
์์ฆ์ ๋ฅ๋ฌ๋์ ํ์ฉํ ๋ด ํ์ง๊ฐ ๋์ธ์ผ. ํนํ 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('๋ด์ผ๋ก ํ๋จ๋จ');
}
์ฅ์ :
โข ์๋ณ์กฐ ๋ถ๊ฐ๋ฅ
โข ๊ฐ์ธ์ ๋ณด ๋ณดํธ
โข ๋จ์ผ ์ฅ์ ์ ์์
โข ํฌ๋ก์ค ํ๋ซํผ ์ธ์ฆ ๊ฐ๋ฅ
์์ง์ ์ด๊ธฐ ๋จ๊ณ์ง๋ง, ์์ผ๋ก ์น3.0 ์๋์๋ ํ์ ๊ธฐ์ ์ด ๋ ๊ฑฐ์ผ! ๐
ํ์ดํ ์๋, ๋ง์ฐ์ค ์์ง์ ํจํด, ํฐ์น ์๋ ฅ ๋ฑ ์ฌ์ฉ์์ ๊ณ ์ ํ ํ๋ ํน์ฑ์ ์ธ์ฆ์ ํ์ฉํ๋ ๊ฑฐ์ผ.
// ํ์ดํ ํจํด ๋ถ์
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;
}์ด ๋ฐฉ๋ฒ์ ์ฌ์ฉ์๊ฐ ์์ํ์ง ๋ชปํ๋ ์ฌ์ด์ ์ง์์ ์ผ๋ก ์ธ์ฆ์ด ์ด๋ฃจ์ด์ ธ์ ํธ๋ฆฌํ๋ฉด์๋ ์์ ํด! ๐
๐ก ์ค๋ฌด ํ๊ณผ ๋ฒ ์คํธ ํ๋ํฐ์ค
๋ ์ด์ด 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๊ฐ ๋ ์ด์ด๋ฅผ ๋ชจ๋ ๊ตฌ์ถํ๋ฉด ๊ฑฐ์ ์๋ฒฝํ ๋ฐฉ์ด๊ฐ ๊ฐ๋ฅํด! ๐ช
๋ณด์์ด ์ค์ํ๋ค๊ณ 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, ๋ธ๋ก์ฒด์ธ, ํ๋ ์์ฒด ์ธ์ฆ ๋ฑ ์๋ก์ด ๊ธฐ์ ์ ์ฃผ์ํด์ผ ํด.
โข robots.txt ์ค์
โข Rate Limiting ๊ตฌํ
โข User-Agent ๊ฒ์ฆ
2์ฃผ์ฐจ: ์ค๊ธ ๊ธฐ์ ๋์
โข ๋์ ํ ํฐ ์์คํ
โข JavaScript ์ฑ๋ฆฐ์ง
โข ํ๋ํ ์ค์น
3์ฃผ์ฐจ: ๋ชจ๋ํฐ๋ง ์์คํ
โข ๋ก๊น ์์คํ ๊ตฌ์ถ
โข ๋์๋ณด๋ ์ค์
โข ์๋ฆผ ์์คํ ์ฐ๋
4์ฃผ์ฐจ: ๊ณ ๊ธ ๊ธฐ๋ฅ
โข ํ๋ ํจํด ๋ถ์
โข ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ ๋์
โข ์๋ ๋์ ์์คํ
์ด๋ ๊ฒ ๋จ๊ณ์ ์ผ๋ก ์ ๊ทผํ๋ฉด ๋ถ๋ด ์์ด ๊ตฌ์ถํ ์ ์์ด! ๐
๊ธฐ์ตํด, ์๋ฒฝํ ๋ณด์์ ์์ด. ํ์ง๋ง ์ง์์ ์ผ๋ก ๋ ธ๋ ฅํ๋ฉด ๋๋ถ๋ถ์ ๊ณต๊ฒฉ์ ๋ง์ ์ ์์ด. ์ค๋ ๋ฐฐ์ด ๋ด์ฉ๋ค์ ์ค์ ์ ์ ์ฉํด๋ณด๊ณ , ๊ณ์ ๊ฐ์ ํด๋๊ฐ์! ๐ช
๊ถ๊ธํ ์ ์ด๋ ๋ ์๊ณ ์ถ์ ๋ด์ฉ์ด ์์ผ๋ฉด ์ธ์ ๋ ์ฐพ์๋ด. ๋ณด์์ ํจ๊ป ๊ณต๋ถํ๊ณ ๊ณต์ ํ ๋ ๋ ๊ฐํด์ง๋๊น! ๐ค
๊ทธ๋ผ ์์ ํ ์น ๊ฐ๋ฐ ๋๊ธธ ๋ฐ๋๊ฒ! ํ์ดํ ! ๐
๋ณด์์ ํ ๋ฒ์ ์ค์ ์ด ์๋ ์ง์์ ์ธ ๊ณผ์ ์
๋๋ค.
์ค๋ ๋ฐฐ์ด ๊ธฐ์ ๋ค์ ํ๋์ฉ ์ ์ฉํ๋ฉฐ ๋ ์์ ํ ์น์ ๋ง๋ค์ด๊ฐ์ธ์! ๐ช
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.