Ver3.5 그래프 데이터베이스 접근 제어 구현

그래프 데이터베이스 접근 제어 구현
복잡한 관계형 데이터를 안전하게 지키는 실전 보안 가이드 🛡️
안녕! 오늘은 그래프 데이터베이스(Graph Database)의 보안, 그 중에서도 접근 제어(Access Control)를 어떻게 구현하는지 같이 파헤쳐볼 거야. 😎
요즘 SNS, 추천 시스템, 지식 그래프, 사기 탐지 시스템 등에서 그래프 DB가 엄청나게 많이 쓰이고 있잖아. 근데 막상 "이걸 어떻게 안전하게 보호하지?"라는 질문에 제대로 답할 수 있는 사람은 생각보다 많지 않아.
그래프 DB는 관계형 DB랑 구조 자체가 다르기 때문에, 접근 제어 방식도 완전히 다른 접근이 필요해. 노드(Node), 엣지(Edge), 속성(Property) 각각에 대한 세밀한 권한 관리가 필요하거든. 자, 그럼 같이 깊이 들어가보자! 🚀
먼저 왜 그래프 DB의 보안이 일반 관계형 DB보다 까다로운지 이해해야 해.
관계형 DB는 테이블 단위로 권한을 주면 어느 정도 해결이 되잖아. "이 테이블은 읽기만 가능" 이런 식으로.
근데 그래프 DB는 달라. 데이터가 노드(Node)와 엣지(Edge)로 연결된 네트워크 구조거든. 그래서 단순히 "이 노드는 접근 가능"이라고 해도, 그 노드에서 연결된 엣지를 타고 다른 민감한 노드로 이동할 수 있어. 이게 바로 그래프 순회(Graph Traversal) 공격의 핵심이야.
그래프 DB에 적용할 수 있는 접근 제어 모델은 여러 가지야. 각각의 특징을 알고 상황에 맞게 선택하는 게 중요해!
| 모델 | 특징 | 적합한 상황 |
|---|---|---|
| DAC (임의적 접근 제어) |
데이터 소유자가 직접 권한 부여 | 소규모 시스템, 유연성 필요 |
| MAC (강제적 접근 제어) |
시스템이 보안 레벨 기반으로 강제 적용 | 군사·정부 시스템, 높은 보안 필요 |
| RBAC (역할 기반 접근 제어) |
역할(Role)에 권한 부여 후 사용자에게 역할 할당 | 기업 시스템, 대부분의 일반 서비스 |
| ABAC (속성 기반 접근 제어) |
사용자·리소스·환경 속성 조합으로 동적 결정 | 복잡한 정책, 세밀한 제어 필요 |
| ReBAC (관계 기반 접근 제어) |
그래프 내 관계 자체를 기반으로 권한 결정 | 소셜 네트워크, 그래프 DB 특화 |
ReBAC는 그래프 DB에 특화된 접근 제어 모델이야. 핵심 아이디어는 이거야:
"사용자가 어떤 리소스에 접근할 수 있는지는, 그 사용자와 리소스 사이의 그래프 관계로 결정된다."
구글의 Zanzibar 시스템이 바로 이 ReBAC를 대규모로 구현한 대표적인 사례야. Google Docs, YouTube, Google Maps 등 구글의 거의 모든 서비스의 권한 관리를 담당하고 있어.
- User: 접근 주체
- Relation: 사용자와 객체 사이의 관계 (owner, editor, viewer 등)
- Tuple: (object, relation, user) 형태의 권한 정의 단위
가장 널리 쓰이는 그래프 DB인 Neo4j를 기준으로 실제 접근 제어를 어떻게 구현하는지 알아보자. Neo4j 4.x 이상부터는 세밀한 접근 제어(Fine-Grained Access Control)를 지원해서 노드 레이블, 관계 타입, 속성 레벨까지 권한을 설정할 수 있어.
// 역할 생성
CREATE ROLE analyst;
CREATE ROLE data_engineer;
CREATE ROLE admin;
// 사용자 생성 및 역할 할당
CREATE USER kim_analyst SET PASSWORD 'secure_pass_123' CHANGE NOT REQUIRED;
GRANT ROLE analyst TO kim_analyst;
CREATE USER lee_engineer SET PASSWORD 'eng_pass_456' CHANGE NOT REQUIRED;
GRANT ROLE data_engineer TO lee_engineer;
// analyst 역할에 특정 DB 읽기 권한만 부여
GRANT ACCESS ON DATABASE production TO analyst;
GRANT MATCH {*} ON GRAPH production TO analyst;
// data_engineer에게 쓰기 권한 추가
GRANT ACCESS ON DATABASE production TO data_engineer;
GRANT WRITE ON GRAPH production TO data_engineer;
// 특정 레이블에만 접근 허용 (노드 레벨 제어)
GRANT MATCH {*} ON GRAPH production NODE Product TO analyst;
GRANT MATCH {*} ON GRAPH production NODE Category TO analyst;
이게 진짜 핵심이야! 노드 전체가 아니라 특정 속성(Property)만 숨기거나 허용할 수 있어.
// User 노드에서 이름과 이메일만 읽기 허용 (비밀번호 해시, 주민번호 등은 숨김)
GRANT MATCH {name, email} ON GRAPH production NODE User TO analyst;
// 민감한 속성은 명시적으로 거부
DENY MATCH {password_hash, ssn, credit_card} ON GRAPH production NODE User TO analyst;
// 관계(엣지) 레벨 권한 설정
GRANT MATCH {*} ON GRAPH production RELATIONSHIP PURCHASED TO analyst;
DENY MATCH {*} ON GRAPH production RELATIONSHIP PRIVATE_MESSAGE TO analyst;
특정 조건을 만족하는 노드들만 접근 가능하게 하는 서브그래프 접근 제어도 구현할 수 있어. 이건 주로 애플리케이션 레이어에서 처리하는 경우가 많아.
// 사용자가 자신의 데이터만 볼 수 있도록 하는 Cypher 쿼리 패턴
// (애플리케이션에서 currentUserId를 파라미터로 주입)
MATCH (u:User {id: $currentUserId})-[:OWNS]->(d:Document)
WHERE d.visibility = 'private' OR d.visibility = 'public'
RETURN d.title, d.content, d.createdAt
// 팀 멤버십 기반 접근 제어
MATCH (u:User {id: $currentUserId})-[:MEMBER_OF]->(t:Team)
-[:HAS_ACCESS_TO]->(r:Resource)
RETURN r.name, r.type, r.url
AWS의 완전 관리형 그래프 DB인 Amazon Neptune은 IAM(Identity and Access Management)과 통합되어 있어서 AWS 생태계에서 쓰기에 최적화되어 있어.
// IAM 정책 예시 (JSON)
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"neptune-db:ReadDataViaQuery",
"neptune-db:GetQueryStatus"
],
"Resource": "arn:aws:neptune-db:us-east-1:123456789:cluster-XXXXX/*",
"Condition": {
"StringEquals": {
"neptune-db:QueryLanguage": "Gremlin"
}
}
},
{
"Effect": "Deny",
"Action": [
"neptune-db:WriteDataViaQuery",
"neptune-db:DeleteDataViaQuery"
],
"Resource": "*"
}
]
}
// Terraform으로 Neptune 보안 그룹 설정
resource "aws_security_group" "neptune_sg" {
name = "neptune-access-control"
description = "Neptune 클러스터 접근 제어"
vpc_id = aws_vpc.main.id
ingress {
from_port = 8182
to_port = 8182
protocol = "tcp"
security_groups = [aws_security_group.app_sg.id]
description = "앱 서버에서만 Neptune 접근 허용"
}
egress {
from_port = 0
to_port = 0
protocol = "-1"
cidr_blocks = ["0.0.0.0/0"]
}
}
DB 자체의 권한 설정만으로는 부족해. 애플리케이션 레이어에서도 접근 제어 로직을 구현해야 해. 특히 미들웨어 패턴과 쿼리 인터셉터를 활용하는 게 효과적이야.
// accessControlMiddleware.js
const neo4j = require('neo4j-driver');
class GraphAccessController {
constructor(driver) {
this.driver = driver;
this.policyCache = new Map();
}
// 사용자의 노드 접근 권한 확인
async canAccessNode(userId, nodeId, permission) {
const cacheKey = `${userId}:${nodeId}:${permission}`;
if (this.policyCache.has(cacheKey)) {
return this.policyCache.get(cacheKey);
}
const session = this.driver.session();
try {
const result = await session.run(`
MATCH (u:User {id: $userId})
MATCH (n {id: $nodeId})
OPTIONAL MATCH path = (u)-[:HAS_ROLE]->(r:Role)-[:GRANTS]->(p:Permission {type: $permission})-[:APPLIES_TO]->(n)
OPTIONAL MATCH directPath = (u)-[:OWNS|MANAGES|VIEWS]->(n)
RETURN
COUNT(path) > 0 OR COUNT(directPath) > 0 AS hasAccess
`, { userId, nodeId, permission });
const hasAccess = result.records[0]?.get('hasAccess') ?? false;
// 5분 캐시
this.policyCache.set(cacheKey, hasAccess);
setTimeout(() => this.policyCache.delete(cacheKey), 300000);
return hasAccess;
} finally {
await session.close();
}
}
// 쿼리 실행 전 권한 검사 래퍼
async executeWithAccessControl(userId, query, params, requiredPermission) {
const session = this.driver.session();
try {
// 1. 사용자 역할 조회
const roleResult = await session.run(
'MATCH (u:User {id: $userId})-[:HAS_ROLE]->(r:Role) RETURN r.name AS role',
{ userId }
);
const roles = roleResult.records.map(r => r.get('role'));
// 2. 역할 기반 쿼리 필터 적용
const filteredQuery = this.applyRoleFilter(query, roles, userId);
// 3. 감사 로그 기록
await this.logAccess(session, userId, query, roles);
// 4. 필터된 쿼리 실행
return await session.run(filteredQuery, params);
} finally {
await session.close();
}
}
// 역할에 따른 쿼리 필터 적용
applyRoleFilter(query, roles, userId) {
if (roles.includes('admin')) {
return query; // 관리자는 필터 없음
}
if (roles.includes('analyst')) {
// 분석가는 자신의 팀 데이터만 접근
return query + ` AND (n.teamId IN [(u:User {id: "${userId}"})-[:MEMBER_OF]->(t:Team) | t.id])`;
}
// 일반 사용자는 자신의 데이터만
return query + ` AND (n.ownerId = "${userId}" OR n.visibility = "public")`;
}
// 감사 로그 기록
async logAccess(session, userId, query, roles) {
await session.run(`
CREATE (log:AccessLog {
userId: $userId,
query: $query,
roles: $roles,
timestamp: datetime(),
ipAddress: $ip
})
`, { userId, query: query.substring(0, 500), roles, ip: 'captured_from_request' });
}
}
module.exports = GraphAccessController;
from gremlin_python.driver import client, serializer
from functools import wraps
import hashlib
class GraphSecurityLayer:
"""그래프 DB 보안 레이어 - 속성 마스킹 및 접근 제어"""
# 역할별 허용 속성 정의
ALLOWED_PROPERTIES = {
'admin': '*', # 모든 속성
'analyst': ['name', 'email', 'created_at', 'category', 'status'],
'viewer': ['name', 'category', 'status'],
'guest': ['name', 'category']
}
# 마스킹이 필요한 민감 속성
SENSITIVE_PROPERTIES = {
'email': lambda v: v[:3] + '***@' + v.split('@')[1] if '@' in v else '***',
'phone': lambda v: v[:3] + '****' + v[-4:] if len(v) >= 7 else '***',
'ssn': lambda v: '***-**-' + v[-4:] if len(v) >= 4 else '***',
'credit_card': lambda v: '**** **** **** ' + v[-4:] if len(v) >= 4 else '***'
}
def __init__(self, gremlin_client, user_role):
self.client = gremlin_client
self.user_role = user_role
self.allowed_props = self.ALLOWED_PROPERTIES.get(user_role, [])
def mask_properties(self, vertex_data):
"""속성 마스킹 적용"""
if self.allowed_props == '*':
return vertex_data # 관리자는 마스킹 없음
masked = {}
for key, value in vertex_data.items():
if key not in self.allowed_props:
continue # 허용되지 않은 속성은 제외
if key in self.SENSITIVE_PROPERTIES and self.user_role != 'admin':
masked[key] = self.SENSITIVE_PROPERTIES[key](str(value))
else:
masked[key] = value
return masked
def secure_query(self, traversal_query, params=None):
"""보안이 적용된 쿼리 실행"""
# 위험한 쿼리 패턴 차단
dangerous_patterns = ['drop()', 'addV(', 'addE(', 'property(set,']
if self.user_role not in ['admin', 'data_engineer']:
for pattern in dangerous_patterns:
if pattern in traversal_query:
raise PermissionError(f"역할 '{self.user_role}'은 쓰기 작업이 허용되지 않습니다.")
# 쿼리 실행
result = self.client.submit(traversal_query, params or {})
raw_data = result.all().result()
# 결과에 속성 마스킹 적용
return [self.mask_properties(item) for item in raw_data]
@staticmethod
def hash_sensitive_id(node_id, salt='graph_security_salt'):
"""민감한 ID 해싱 (익명화)"""
return hashlib.sha256(f"{node_id}{salt}".encode()).hexdigest()[:16]
# 사용 예시
def get_user_data(user_id, requester_role):
gremlin_client = client.Client('wss://neptune-endpoint:8182/gremlin', 'g')
security = GraphSecurityLayer(gremlin_client, requester_role)
query = f"g.V().hasLabel('User').has('id', '{user_id}').valueMap(true)"
try:
result = security.secure_query(query)
return result
except PermissionError as e:
print(f"접근 거부: {e}")
return None
SQL 인젝션처럼, 그래프 DB에도 Cypher 인젝션이나 Gremlin 인젝션 공격이 존재해. 이걸 방어하는 방법도 꼭 알아야 해!
// ❌ 위험! 사용자 입력을 직접 쿼리에 삽입
const userInput = req.body.username; // 악의적 입력: "' OR 1=1 RETURN n //"
const query = `MATCH (u:User {name: '${userInput}'}) RETURN u`;
// 결과: MATCH (u:User {name: '' OR 1=1 RETURN n //'}) RETURN u
// 모든 사용자 데이터가 노출됨!
// ✅ 안전! 파라미터화된 쿼리 사용
const userInput = req.body.username;
// Neo4j 드라이버의 파라미터 바인딩 사용
const result = await session.run(
'MATCH (u:User {name: $username}) RETURN u',
{ username: userInput } // 자동으로 이스케이프 처리됨
);
// Gremlin에서도 동일하게 파라미터 바인딩 사용
const result = await client.submit(
"g.V().has('User', 'name', username)",
{ username: userInput } // 파라미터로 전달
);
// 그래프 쿼리 입력 검증 유틸리티
class CypherInputValidator {
static FORBIDDEN_PATTERNS = [
/CALL\s+dbms/i, // 시스템 프로시저 호출 차단
/LOAD\s+CSV/i, // 외부 파일 로드 차단
/apoc\./i, // APOC 프로시저 직접 호출 차단 (권한 없는 경우)
/CREATE\s+INDEX/i, // DDL 작업 차단
/DROP\s+/i, // 삭제 작업 차단
/DETACH\s+DELETE/i, // 연쇄 삭제 차단
];
static validate(input) {
if (typeof input !== 'string') {
throw new TypeError('입력값은 문자열이어야 합니다.');
}
// 길이 제한
if (input.length > 1000) {
throw new Error('입력값이 너무 깁니다.');
}
// 위험 패턴 검사
for (const pattern of this.FORBIDDEN_PATTERNS) {
if (pattern.test(input)) {
throw new Error(`허용되지 않는 쿼리 패턴이 감지되었습니다: ${pattern}`);
}
}
// 특수문자 이스케이프
return input.replace(/['"\\]/g, '\\$&');
}
static sanitizeNodeLabel(label) {
// 노드 레이블은 영문자, 숫자, 언더스코어만 허용
if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(label)) {
throw new Error('유효하지 않은 노드 레이블입니다.');
}
return label;
}
}
접근 제어를 구현했다고 끝이 아니야! 누가, 언제, 어떤 데이터에 접근했는지를 기록하고 이상한 패턴을 탐지하는 시스템도 필수야. 이게 바로 감사 로깅(Audit Logging)이야.
// 감사 로그를 그래프 DB 자체에 저장하는 패턴
// (별도의 감사 전용 DB를 사용하는 것이 더 안전하지만, 예시로 같은 DB 사용)
// 접근 이벤트 노드 생성
CREATE (event:AuditEvent {
id: randomUUID(),
eventType: 'NODE_ACCESS',
timestamp: datetime(),
userId: $userId,
sessionId: $sessionId,
ipAddress: $ipAddress,
userAgent: $userAgent,
queryHash: $queryHash,
affectedNodeIds: $nodeIds,
permission: $permission,
result: 'ALLOWED', // 또는 'DENIED'
duration: $queryDurationMs
})
// 사용자와 이벤트 연결
MATCH (u:User {id: $userId}), (event:AuditEvent {id: $eventId})
CREATE (u)-[:PERFORMED]->(event)
// 이상 탐지: 단시간 내 과도한 접근 쿼리
MATCH (u:User {id: $userId})-[:PERFORMED]->(e:AuditEvent)
WHERE e.timestamp > datetime() - duration('PT5M') // 최근 5분
WITH u, COUNT(e) AS accessCount
WHERE accessCount > 100 // 5분에 100회 이상 접근
RETURN u.id, accessCount, '비정상 접근 의심' AS alert
// Python으로 구현하는 그래프 기반 이상 탐지
import asyncio
from datetime import datetime, timedelta
from collections import defaultdict
class GraphAnomalyDetector:
"""그래프 DB 접근 패턴 이상 탐지"""
def __init__(self, alert_callback):
self.access_history = defaultdict(list)
self.alert_callback = alert_callback
# 탐지 규칙 정의
self.rules = [
self.check_rate_limit,
self.check_unusual_traversal_depth,
self.check_sensitive_node_access,
self.check_off_hours_access,
self.check_bulk_data_extraction
]
async def record_access(self, user_id, event):
"""접근 이벤트 기록 및 즉시 분석"""
self.access_history[user_id].append({
'timestamp': datetime.now(),
'node_count': event.get('node_count', 0),
'traversal_depth': event.get('traversal_depth', 0),
'node_labels': event.get('node_labels', []),
'query_type': event.get('query_type', 'READ')
})
# 오래된 기록 정리 (1시간 이상)
cutoff = datetime.now() - timedelta(hours=1)
self.access_history[user_id] = [
e for e in self.access_history[user_id]
if e['timestamp'] > cutoff
]
# 모든 규칙 검사
for rule in self.rules:
alert = await rule(user_id, event)
if alert:
await self.alert_callback(user_id, alert)
async def check_rate_limit(self, user_id, event):
"""분당 접근 횟수 제한 검사"""
one_minute_ago = datetime.now() - timedelta(minutes=1)
recent = [e for e in self.access_history[user_id]
if e['timestamp'] > one_minute_ago]
if len(recent) > 60: # 분당 60회 초과
return {
'type': 'RATE_LIMIT_EXCEEDED',
'severity': 'HIGH',
'message': f'분당 {len(recent)}회 접근 감지 (임계값: 60회)',
'action': 'BLOCK_TEMPORARILY'
}
return None
async def check_unusual_traversal_depth(self, user_id, event):
"""비정상적으로 깊은 그래프 순회 감지"""
depth = event.get('traversal_depth', 0)
if depth > 10: # 10홉 이상 순회
return {
'type': 'DEEP_TRAVERSAL_DETECTED',
'severity': 'MEDIUM',
'message': f'비정상적인 그래프 순회 깊이: {depth}홉',
'action': 'LOG_AND_ALERT'
}
return None
async def check_sensitive_node_access(self, user_id, event):
"""민감한 노드 레이블 접근 감지"""
sensitive_labels = {'FinancialRecord', 'MedicalRecord', 'PersonalInfo', 'SecretDocument'}
accessed_labels = set(event.get('node_labels', []))
if accessed_labels & sensitive_labels:
return {
'type': 'SENSITIVE_DATA_ACCESS',
'severity': 'HIGH',
'message': f'민감 데이터 접근: {accessed_labels & sensitive_labels}',
'action': 'LOG_AND_ALERT'
}
return None
async def check_off_hours_access(self, user_id, event):
"""업무 시간 외 접근 감지"""
hour = datetime.now().hour
if hour < 6 or hour > 22: # 오전 6시 이전, 오후 10시 이후
return {
'type': 'OFF_HOURS_ACCESS',
'severity': 'MEDIUM',
'message': f'업무 시간 외 접근: {hour}시',
'action': 'LOG_AND_NOTIFY'
}
return None
async def check_bulk_data_extraction(self, user_id, event):
"""대량 데이터 추출 시도 감지"""
node_count = event.get('node_count', 0)
if node_count > 10000: # 한 번에 10,000개 이상 노드 접근
return {
'type': 'BULK_EXTRACTION_DETECTED',
'severity': 'CRITICAL',
'message': f'대량 데이터 추출 시도: {node_count}개 노드',
'action': 'BLOCK_AND_ALERT'
}
return None
접근 제어와 함께 반드시 구현해야 하는 게 데이터 암호화야. 그래프 DB에서의 암호화는 두 가지 레벨로 나눌 수 있어.
// Neo4j 드라이버에서 TLS 설정
const driver = neo4j.driver(
'neo4j+s://your-neo4j-host:7687', // +s는 TLS 강제
neo4j.auth.basic('username', 'password'),
{
encrypted: 'ENCRYPTION_ON',
trust: 'TRUST_SYSTEM_CA_SIGNED_CERTIFICATES',
// 또는 자체 서명 인증서 사용 시:
// trust: 'TRUST_CUSTOM_CA_SIGNED_CERTIFICATES',
// trustedCertificates: ['/path/to/ca.crt']
}
);
// Gremlin (TinkerPop) WebSocket TLS 설정
const client = new Client(
'wss://your-neptune-endpoint:8182/gremlin', // wss = WebSocket Secure
{
traversalSource: 'g',
rejectUnauthorized: true,
ca: fs.readFileSync('/path/to/ca.crt')
}
);
// 애플리케이션 레벨 속성 암호화 (AES-256-GCM)
const crypto = require('crypto');
class PropertyEncryptor {
constructor(masterKey) {
this.masterKey = Buffer.from(masterKey, 'hex');
// 암호화할 민감 속성 목록
this.encryptedFields = ['ssn', 'credit_card', 'bank_account', 'medical_record'];
}
encrypt(value) {
const iv = crypto.randomBytes(16);
const cipher = crypto.createCipheriv('aes-256-gcm', this.masterKey, iv);
let encrypted = cipher.update(String(value), 'utf8', 'hex');
encrypted += cipher.final('hex');
const authTag = cipher.getAuthTag();
return {
encrypted: encrypted,
iv: iv.toString('hex'),
authTag: authTag.toString('hex')
};
}
decrypt(encryptedData) {
const decipher = crypto.createDecipheriv(
'aes-256-gcm',
this.masterKey,
Buffer.from(encryptedData.iv, 'hex')
);
decipher.setAuthTag(Buffer.from(encryptedData.authTag, 'hex'));
let decrypted = decipher.update(encryptedData.encrypted, 'hex', 'utf8');
decrypted += decipher.final('utf8');
return decrypted;
}
// 노드 저장 전 민감 속성 자동 암호화
encryptNodeProperties(nodeData) {
const result = { ...nodeData };
for (const field of this.encryptedFields) {
if (result[field]) {
result[`${field}_encrypted`] = this.encrypt(result[field]);
delete result[field]; // 원본 삭제
}
}
return result;
}
}
이론은 충분히 배웠으니, 실제 시나리오로 어떻게 적용하는지 보자. 소셜 네트워크 서비스를 예로 들어볼게. 마치 재능넷처럼 사람들이 서로 연결되고 재능을 공유하는 플랫폼을 생각해봐! 🎯
// 그래프 스키마 정의
// 노드 타입: User, Talent, Review, Message, Payment
// 접근 제어 정책 정의 (YAML 형식)
/*
access_control_policies:
user_node:
public_properties: [username, bio, profile_image, talent_count]
authenticated_properties: [email, phone] # 로그인한 사용자만
owner_only_properties: [payment_info, private_notes, blocked_users]
talent_node:
public_properties: [title, description, price, category, rating]
authenticated_properties: [seller_contact]
owner_only_properties: [revenue_stats, buyer_list, internal_notes]
message_node:
# 메시지는 발신자와 수신자만 접근 가능
access_rule: "MATCH (u:User {id: $userId})-[:SENT|RECEIVED]->(m:Message)"
payment_node:
# 결제 정보는 당사자와 관리자만
access_rule: "MATCH (u:User {id: $userId})-[:MADE|RECEIVED]->(p:Payment) OR u.role = 'admin'"
review_node:
public_properties: [content, rating, created_at]
# 리뷰 작성자 정보는 익명화 옵션 제공
anonymous_option: true
*/
// Neo4j에서 실제 구현
// 1. 사용자 프로필 조회 (접근 제어 적용)
async function getUserProfile(requesterId, targetUserId) {
const session = driver.session();
try {
// 요청자와 대상 사용자의 관계 확인
const relationResult = await session.run(`
MATCH (requester:User {id: $requesterId})
MATCH (target:User {id: $targetUserId})
OPTIONAL MATCH (requester)-[rel:FOLLOWS|FRIENDS_WITH|BLOCKED]->(target)
RETURN
requester.role AS requesterRole,
TYPE(rel) AS relationship,
requester.id = target.id AS isSelf
`, { requesterId, targetUserId });
const record = relationResult.records[0];
const requesterRole = record.get('requesterRole');
const relationship = record.get('relationship');
const isSelf = record.get('isSelf');
// 접근 레벨 결정
let accessLevel = 'public';
if (requesterRole === 'admin') accessLevel = 'admin';
else if (isSelf) accessLevel = 'owner';
else if (relationship === 'FRIENDS_WITH') accessLevel = 'friend';
else if (relationship === 'FOLLOWS') accessLevel = 'follower';
else if (relationship === 'BLOCKED') accessLevel = 'blocked';
if (accessLevel === 'blocked') {
throw new Error('접근이 차단된 사용자입니다.');
}
// 접근 레벨에 따른 속성 반환
const propertyMap = {
admin: '*',
owner: ['username', 'bio', 'email', 'phone', 'payment_info', 'private_notes'],
friend: ['username', 'bio', 'email', 'profile_image'],
follower: ['username', 'bio', 'profile_image'],
public: ['username', 'bio', 'profile_image', 'talent_count']
};
const allowedProps = propertyMap[accessLevel];
const propQuery = allowedProps === '*' ? 'u' :
`{${allowedProps.map(p => `${p}: u.${p}`).join(', ')}}`;
const profileResult = await session.run(`
MATCH (u:User {id: $targetUserId})
RETURN ${propQuery} AS profile
`, { targetUserId });
return {
profile: profileResult.records[0]?.get('profile'),
accessLevel
};
} finally {
await session.close();
}
}
보안을 강화하면 성능이 떨어지는 게 일반적인 트레이드오프야. 하지만 몇 가지 기법으로 이 문제를 최소화할 수 있어!
// Redis를 활용한 권한 캐싱
const redis = require('redis');
const client = redis.createClient();
class PermissionCache {
constructor(ttlSeconds = 300) { // 기본 5분 캐시
this.ttl = ttlSeconds;
}
getCacheKey(userId, resourceId, permission) {
return `perm:${userId}:${resourceId}:${permission}`;
}
async get(userId, resourceId, permission) {
const key = this.getCacheKey(userId, resourceId, permission);
const cached = await client.get(key);
return cached ? JSON.parse(cached) : null;
}
async set(userId, resourceId, permission, result) {
const key = this.getCacheKey(userId, resourceId, permission);
await client.setEx(key, this.ttl, JSON.stringify(result));
}
// 사용자 권한 변경 시 캐시 무효화
async invalidateUser(userId) {
const pattern = `perm:${userId}:*`;
const keys = await client.keys(pattern);
if (keys.length > 0) {
await client.del(keys);
}
}
// 리소스 변경 시 관련 캐시 무효화
async invalidateResource(resourceId) {
const pattern = `perm:*:${resourceId}:*`;
const keys = await client.keys(pattern);
if (keys.length > 0) {
await client.del(keys);
}
}
}
// Neo4j 인덱스 설정 (접근 제어 쿼리 최적화)
// 자주 사용되는 권한 체크 속성에 인덱스 생성
CREATE INDEX user_id_index FOR (u:User) ON (u.id);
CREATE INDEX user_role_index FOR (u:User) ON (u.role);
CREATE INDEX resource_owner_index FOR (n:Resource) ON (n.ownerId);
CREATE INDEX resource_visibility_index FOR (n:Resource) ON (n.visibility);
// 복합 인덱스 (Neo4j 4.4+)
CREATE INDEX user_role_status FOR (u:User) ON (u.role, u.status);
// 접근 제어 관계에 인덱스
CREATE INDEX permission_type FOR ()-[r:GRANTS]-() ON (r.permissionType);
// 감사 로그 시간 기반 인덱스
CREATE INDEX audit_timestamp FOR (a:AuditEvent) ON (a.timestamp);
// ❌ 비효율적인 접근 제어 쿼리 (전체 그래프 스캔)
MATCH (u:User), (r:Resource)
WHERE u.id = $userId AND r.id = $resourceId
AND EXISTS((u)-[:HAS_ROLE]->(:Role)-[:GRANTS]->(:Permission)-[:APPLIES_TO]->(r))
RETURN r
// ✅ 최적화된 쿼리 (인덱스 활용 + 조기 필터링)
MATCH (u:User {id: $userId})-[:HAS_ROLE]->(role:Role)
MATCH (r:Resource {id: $resourceId})
WHERE EXISTS {
MATCH (role)-[:GRANTS]->(p:Permission {type: $permType})-[:APPLIES_TO]->(r)
}
RETURN r
// ✅ 더 나은 방법: 권한을 미리 계산해서 저장 (Materialized Permissions)
// 권한 변경 시 미리 계산된 권한 업데이트
MATCH (u:User {id: $userId})-[:HAS_ROLE]->(role:Role)-[:GRANTS]->(p:Permission)-[:APPLIES_TO]->(r:Resource)
MERGE (u)-[access:HAS_ACCESS]->(r)
SET access.permissionTypes = COLLECT(DISTINCT p.type),
access.updatedAt = datetime()
// 이후 권한 체크는 단순 관계 조회로 처리 (매우 빠름!)
MATCH (u:User {id: $userId})-[access:HAS_ACCESS]->(r:Resource {id: $resourceId})
WHERE $permType IN access.permissionTypes
RETURN r
그래프 DB 보안은 기술적인 구현만으로 끝나지 않아. GDPR, HIPAA, PCI-DSS 같은 규정도 준수해야 해. 각 규정이 그래프 DB에 어떻게 적용되는지 알아보자.
| 규정 | 주요 요구사항 | 그래프 DB 구현 방법 |
|---|---|---|
| GDPR (개인정보보호) |
개인정보 접근 제어, 삭제권, 이동권 | 속성 레벨 암호화, 노드 삭제 시 연결 관계 처리, 데이터 내보내기 API |
| HIPAA (의료정보보호) |
PHI 접근 감사, 최소 권한, 암호화 | 의료 노드 레이블 별도 권한, 모든 접근 로깅, AES-256 암호화 |
| PCI-DSS (결제정보보호) |
카드 데이터 보호, 접근 제한, 모니터링 | 결제 노드 격리, 토큰화, 실시간 이상 탐지 |
| SOC 2 (서비스 신뢰성) |
보안, 가용성, 기밀성, 처리 무결성 | 감사 로그, 백업 암호화, 접근 제어 정책 문서화 |
// GDPR 삭제권 처리 - 그래프에서 개인정보 완전 삭제
async function handleGDPRDeletion(userId) {
const session = driver.session();
try {
// 1. 삭제 전 감사 로그 기록
await session.run(`
CREATE (log:GDPRDeletionLog {
userId: $userId,
requestedAt: datetime(),
status: 'PROCESSING'
})
`, { userId });
// 2. 개인 식별 정보 익명화 (완전 삭제 대신 익명화 권장)
await session.run(`
MATCH (u:User {id: $userId})
SET u.username = 'deleted_user_' + $userId,
u.email = null,
u.phone = null,
u.profile_image = null,
u.bio = '삭제된 사용자',
u.isDeleted = true,
u.deletedAt = datetime()
REMOVE u.ssn, u.address, u.birth_date
`, { userId });
// 3. 비공개 메시지 삭제
await session.run(`
MATCH (u:User {id: $userId})-[:SENT|RECEIVED]->(m:Message)
WHERE m.isPrivate = true
DETACH DELETE m
`, { userId });
// 4. 결제 정보 익명화 (법적 보존 의무 고려)
await session.run(`
MATCH (u:User {id: $userId})-[:MADE]->(p:Payment)
SET p.cardNumber = null,
p.cardHolder = '익명',
p.billingAddress = null
// 거래 금액과 날짜는 회계 목적으로 보존
`, { userId });
// 5. 소셜 관계 삭제
await session.run(`
MATCH (u:User {id: $userId})-[r:FOLLOWS|FRIENDS_WITH|BLOCKS]-()
DELETE r
`, { userId });
// 6. 완료 로그 업데이트
await session.run(`
MATCH (log:GDPRDeletionLog {userId: $userId})
SET log.completedAt = datetime(),
log.status = 'COMPLETED'
`, { userId });
return { success: true, message: 'GDPR 삭제 요청이 처리되었습니다.' };
} catch (error) {
await session.run(`
MATCH (log:GDPRDeletionLog {userId: $userId})
SET log.status = 'FAILED',
log.error = $error
`, { userId, error: error.message });
throw error;
} finally {
await session.close();
}
}
구현한 접근 제어가 제대로 동작하는지 테스트하는 것도 매우 중요해. 그래프 DB 보안 테스트는 일반 DB와는 다른 접근이 필요해.
// Jest를 활용한 그래프 DB 접근 제어 테스트
describe('그래프 DB 접근 제어 테스트', () => {
describe('노드 레벨 접근 제어', () => {
test('일반 사용자는 다른 사용자의 비공개 정보에 접근 불가', async () => {
const result = await getUserProfile(
'user_normal_001', // 요청자
'user_target_002' // 대상
);
expect(result.profile).not.toHaveProperty('email');
expect(result.profile).not.toHaveProperty('phone');
expect(result.profile).not.toHaveProperty('payment_info');
expect(result.profile).toHaveProperty('username');
});
test('관리자는 모든 사용자 정보에 접근 가능', async () => {
const result = await getUserProfile(
'user_admin_001', // 관리자
'user_target_002'
);
expect(result.profile).toHaveProperty('email');
expect(result.profile).toHaveProperty('phone');
expect(result.accessLevel).toBe('admin');
});
test('차단된 사용자는 접근 거부', async () => {
await expect(
getUserProfile('user_blocked_001', 'user_target_002')
).rejects.toThrow('접근이 차단된 사용자입니다.');
});
});
describe('그래프 순회 공격 방어', () => {
test('허용된 노드에서 시작해 권한 없는 노드로 순회 불가', async () => {
// 악의적인 쿼리 시도
const maliciousQuery = `
MATCH (u:User {id: 'user_normal_001'})-[*1..10]->(secret:SecretDocument)
RETURN secret
`;
await expect(
executeWithAccessControl('user_normal_001', maliciousQuery, {}, 'READ')
).rejects.toThrow();
});
test('깊은 순회 쿼리 자동 차단', async () => {
const deepTraversalQuery = `
MATCH path = (u:User)-[*20..]->(n)
RETURN n
`;
const result = await executeWithAccessControl(
'user_normal_001', deepTraversalQuery, {}, 'READ'
);
// 결과가 비어있거나 에러 발생해야 함
expect(result.records.length).toBe(0);
});
});
describe('Cypher 인젝션 방어', () => {
test('악의적인 입력값 이스케이프 처리', async () => {
const maliciousInput = "' OR 1=1 RETURN n //";
// 파라미터화된 쿼리 사용 시 인젝션 불가
const result = await session.run(
'MATCH (u:User {name: $name}) RETURN u',
{ name: maliciousInput }
);
// 결과가 비어있어야 함 (인젝션 성공 시 모든 사용자 반환됨)
expect(result.records.length).toBe(0);
});
});
describe('속성 레벨 접근 제어', () => {
test('분석가 역할은 민감 속성 접근 불가', async () => {
const security = new GraphSecurityLayer(gremlinClient, 'analyst');
const result = await security.secure_query(
"g.V().hasLabel('User').valueMap(true)"
);
result.forEach(user => {
expect(user).not.toHaveProperty('password_hash');
expect(user).not.toHaveProperty('ssn');
expect(user).not.toHaveProperty('credit_card');
});
});
});
});
마지막으로 최신 보안 트렌드인 제로 트러스트(Zero Trust) 아키텍처를 그래프 DB에 어떻게 적용하는지 알아보자. 제로 트러스트의 핵심은 "절대 신뢰하지 말고, 항상 검증하라(Never Trust, Always Verify)"야.
2. 최소 권한 원칙: 그래프 DB에서도 필요한 노드와 엣지에만 접근 권한을 부여. "이 사용자가 이 쿼리를 실행할 이유가 있는가?"를 항상 물어봐.
3. 마이크로 세그멘테이션: 그래프를 논리적인 보안 구역으로 나눠서 한 구역이 침해되어도 다른 구역으로 확산되지 않도록 해.
4. 가정 침해(Assume Breach): 이미 내부 시스템이 침해되었다고 가정하고 설계해. 내부 네트워크라도 그래프 DB 접근 시 완전한 인증과 권한 검사를 수행해.
// 제로 트러스트 컨텍스트 기반 접근 제어
class ZeroTrustGraphAccessor {
async evaluateAccess(context) {
const {
userId,
deviceId,
ipAddress,
userAgent,
requestedResource,
requestedPermission,
timestamp
} = context;
// 1. 사용자 신원 검증
const userTrust = await this.evaluateUserTrust(userId);
// 2. 디바이스 신뢰도 평가
const deviceTrust = await this.evaluateDeviceTrust(deviceId);
// 3. 네트워크 위치 평가
const networkTrust = await this.evaluateNetworkTrust(ipAddress);
// 4. 행동 패턴 분석
const behaviorScore = await this.analyzeBehavior(userId, context);
// 5. 종합 신뢰 점수 계산
const trustScore = (
userTrust * 0.35 +
deviceTrust * 0.25 +
networkTrust * 0.20 +
behaviorScore * 0.20
);
// 6. 리소스 민감도에 따른 임계값 설정
const resourceSensitivity = await this.getResourceSensitivity(requestedResource);
const requiredTrustScore = {
'PUBLIC': 0.3,
'INTERNAL': 0.5,
'CONFIDENTIAL': 0.7,
'SECRET': 0.9
}[resourceSensitivity];
if (trustScore < requiredTrustScore) {
// 추가 인증 요구 또는 접근 거부
if (trustScore >= requiredTrustScore - 0.2) {
return { decision: 'STEP_UP_AUTH', requiredMethod: 'MFA' };
}
return { decision: 'DENY', reason: `신뢰 점수 부족: ${trustScore.toFixed(2)} < ${requiredTrustScore}` };
}
// 7. 그래프 DB 접근 허용 (시간 제한 토큰 발급)
const accessToken = await this.issueTimeLimitedToken(userId, requestedResource, 300); // 5분
return {
decision: 'ALLOW',
trustScore,
accessToken,
expiresIn: 300
};
}
async evaluateUserTrust(userId) {
// 사용자 계정 상태, MFA 여부, 최근 비밀번호 변경 등 평가
const session = driver.session();
const result = await session.run(`
MATCH (u:User {id: $userId})
RETURN
u.mfaEnabled AS mfaEnabled,
u.lastPasswordChange AS lastPasswordChange,
u.accountStatus AS accountStatus,
u.loginFailCount AS loginFailCount
`, { userId });
const user = result.records[0];
let score = 0.5;
if (user.get('mfaEnabled')) score += 0.2;
if (user.get('accountStatus') === 'VERIFIED') score += 0.15;
if (user.get('loginFailCount') === 0) score += 0.15;
return Math.min(score, 1.0);
}
}
자, 이제 그래프 데이터베이스 접근 제어의 전체 그림이 그려졌지? 마지막으로 핵심을 정리해볼게! 🎯
그래프 순회 공격, 추론 공격, 집계 공격은 관계형 DB에서는 없는 그래프 DB 특유의 위협이야. 이걸 먼저 이해해야 제대로 된 방어가 가능해.
RBAC + ReBAC 조합이 그래프 DB에 가장 적합해. DB 레벨, 애플리케이션 레벨, 네트워크 레벨 모두에서 방어해야 해.
"이 노드에 접근 가능"이 아니라 "이 노드의 이 속성만 접근 가능"까지 제어해야 진정한 보안이야.
Cypher/Gremlin 인젝션 방어를 위해 항상 파라미터 바인딩을 사용해. 문자열 연결로 쿼리를 만드는 건 절대 금지!
보안 사고는 언제든 일어날 수 있어. 사후 분석을 위한 감사 로그와 실시간 이상 탐지 시스템은 필수야.
권한 캐싱, 인덱스 최적화, 사전 계산된 권한(Materialized Permissions) 등으로 보안 오버헤드를 최소화해.
GDPR, HIPAA, PCI-DSS 등의 규정은 나중에 추가하기 어려워. 설계 단계부터 고려해야 해.
관련 키워드
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.