happybell80
14ca47ed6e
- 비전 및 철학: 존재형 AI 에이전트 개념 - 윤리 원칙과 안전 기준 - 사용자 시나리오 및 유즈케이스 - 게임화 요소 (레벨업, 스탯, 스킬) - 기술 아키텍처 (기억 시스템, 감정 모델, DB 설계) - 멀티 에이전트 협업 구조 - DID 기반 신원 체계 - 장기 로드맵 (1년, 3년 비전)
409 lines
12 KiB
Markdown
409 lines
12 KiB
Markdown
# 데이터 접근 제어 정책 및 감사 로그 관리
|
|
|
|
## 데이터 분류 체계
|
|
|
|
### 데이터 민감도 레벨
|
|
|
|
```python
|
|
class DataClassification:
|
|
LEVELS = {
|
|
'PUBLIC': {
|
|
'level': 0,
|
|
'description': '공개 정보',
|
|
'encryption': False,
|
|
'access_control': 'open',
|
|
'retention': 'indefinite',
|
|
'examples': ['공개 프로필', '통계 데이터']
|
|
},
|
|
'INTERNAL': {
|
|
'level': 1,
|
|
'description': '내부 사용',
|
|
'encryption': 'at_rest',
|
|
'access_control': 'authenticated',
|
|
'retention': '2_years',
|
|
'examples': ['작업 로그', '성능 메트릭']
|
|
},
|
|
'CONFIDENTIAL': {
|
|
'level': 2,
|
|
'description': '기밀',
|
|
'encryption': 'at_rest_and_transit',
|
|
'access_control': 'role_based',
|
|
'retention': '1_year',
|
|
'examples': ['사용자 대화', '개인 메모']
|
|
},
|
|
'RESTRICTED': {
|
|
'level': 3,
|
|
'description': '제한됨',
|
|
'encryption': 'end_to_end',
|
|
'access_control': 'attribute_based',
|
|
'retention': '6_months',
|
|
'examples': ['금융 정보', '의료 기록']
|
|
},
|
|
'TOP_SECRET': {
|
|
'level': 4,
|
|
'description': '극비',
|
|
'encryption': 'quantum_resistant',
|
|
'access_control': 'zero_trust',
|
|
'retention': '30_days',
|
|
'examples': ['인증 키', '개인정보']
|
|
}
|
|
}
|
|
```
|
|
|
|
## 접근 제어 모델
|
|
|
|
### RBAC + ABAC 하이브리드
|
|
|
|
```python
|
|
class HybridAccessControl:
|
|
def __init__(self):
|
|
self.roles = {}
|
|
self.attributes = {}
|
|
self.policies = []
|
|
|
|
def define_role(self, role_name, permissions):
|
|
"""역할 정의"""
|
|
self.roles[role_name] = {
|
|
'permissions': permissions,
|
|
'created': datetime.now(),
|
|
'constraints': []
|
|
}
|
|
|
|
def define_attribute_policy(self, policy):
|
|
"""속성 기반 정책 정의"""
|
|
|
|
# 예시: 시간 기반 접근 제어
|
|
time_based_policy = {
|
|
'name': 'business_hours_only',
|
|
'conditions': [
|
|
{
|
|
'attribute': 'current_time',
|
|
'operator': 'between',
|
|
'value': ['09:00', '18:00']
|
|
},
|
|
{
|
|
'attribute': 'user_location',
|
|
'operator': 'in',
|
|
'value': ['office', 'home']
|
|
}
|
|
],
|
|
'effect': 'allow'
|
|
}
|
|
|
|
self.policies.append(policy)
|
|
|
|
def evaluate_access(self, subject, resource, action):
|
|
"""접근 권한 평가"""
|
|
|
|
# 1. 역할 기반 체크
|
|
role_check = self.check_role_permissions(subject, resource, action)
|
|
|
|
# 2. 속성 기반 체크
|
|
attribute_check = self.check_attributes(subject, resource, action)
|
|
|
|
# 3. 컨텍스트 체크
|
|
context_check = self.check_context(subject, resource)
|
|
|
|
# 최종 결정
|
|
if role_check and attribute_check and context_check:
|
|
return True, "Access granted"
|
|
else:
|
|
return False, "Access denied"
|
|
```
|
|
|
|
## 감사 로그 시스템
|
|
|
|
### 불변 감사 로그
|
|
|
|
```python
|
|
class AuditLogger:
|
|
def __init__(self):
|
|
self.log_chain = [] # 블록체인 스타일 로그
|
|
self.current_hash = "0"
|
|
|
|
def log_access_attempt(self, event):
|
|
"""접근 시도 로깅"""
|
|
|
|
log_entry = {
|
|
'id': uuid.uuid4().hex,
|
|
'timestamp': datetime.now().isoformat(),
|
|
'event_type': event['type'],
|
|
'subject': {
|
|
'did': event['subject_did'],
|
|
'role': event.get('role'),
|
|
'ip': event.get('ip_address'),
|
|
'device': event.get('device_id')
|
|
},
|
|
'resource': {
|
|
'type': event['resource_type'],
|
|
'id': event['resource_id'],
|
|
'classification': event['data_classification']
|
|
},
|
|
'action': event['action'],
|
|
'result': event['result'],
|
|
'reason': event.get('reason'),
|
|
'previous_hash': self.current_hash
|
|
}
|
|
|
|
# 해시 계산 (불변성 보장)
|
|
log_hash = self.calculate_hash(log_entry)
|
|
log_entry['hash'] = log_hash
|
|
|
|
# 체인에 추가
|
|
self.log_chain.append(log_entry)
|
|
self.current_hash = log_hash
|
|
|
|
# 실시간 모니터링 알림
|
|
if event['result'] == 'denied' or event['data_classification'] >= 3:
|
|
self.send_alert(log_entry)
|
|
|
|
return log_entry
|
|
|
|
def calculate_hash(self, entry):
|
|
"""로그 엔트리 해시 계산"""
|
|
import hashlib
|
|
|
|
entry_string = json.dumps(entry, sort_keys=True)
|
|
return hashlib.sha256(entry_string.encode()).hexdigest()
|
|
```
|
|
|
|
### 감사 로그 분석
|
|
|
|
```python
|
|
class AuditAnalyzer:
|
|
def __init__(self):
|
|
self.anomaly_detector = AnomalyDetector()
|
|
|
|
def analyze_access_patterns(self, time_window='24h'):
|
|
"""접근 패턴 분석"""
|
|
|
|
logs = self.get_logs(time_window)
|
|
|
|
analysis = {
|
|
'total_attempts': len(logs),
|
|
'successful': sum(1 for l in logs if l['result'] == 'granted'),
|
|
'failed': sum(1 for l in logs if l['result'] == 'denied'),
|
|
'suspicious_patterns': [],
|
|
'top_accessors': {},
|
|
'sensitive_data_access': []
|
|
}
|
|
|
|
# 이상 패턴 감지
|
|
for log in logs:
|
|
if self.is_suspicious(log):
|
|
analysis['suspicious_patterns'].append({
|
|
'log_id': log['id'],
|
|
'reason': self.get_suspicion_reason(log)
|
|
})
|
|
|
|
return analysis
|
|
|
|
def is_suspicious(self, log):
|
|
"""의심스러운 활동 감지"""
|
|
|
|
suspicious_indicators = [
|
|
self.check_unusual_time(log),
|
|
self.check_rapid_attempts(log),
|
|
self.check_privilege_escalation(log),
|
|
self.check_data_exfiltration(log)
|
|
]
|
|
|
|
return any(suspicious_indicators)
|
|
```
|
|
|
|
## 암호화 정책
|
|
|
|
### 계층별 암호화
|
|
|
|
```python
|
|
class EncryptionPolicy:
|
|
def __init__(self):
|
|
self.encryption_methods = {
|
|
'at_rest': 'AES-256-GCM',
|
|
'in_transit': 'TLS 1.3',
|
|
'end_to_end': 'NaCl Box',
|
|
'quantum_resistant': 'CRYSTALS-Kyber'
|
|
}
|
|
|
|
def encrypt_data(self, data, classification_level):
|
|
"""데이터 분류에 따른 암호화"""
|
|
|
|
if classification_level == 'PUBLIC':
|
|
return data # 암호화 불필요
|
|
|
|
elif classification_level == 'INTERNAL':
|
|
return self.aes_encrypt(data)
|
|
|
|
elif classification_level == 'CONFIDENTIAL':
|
|
encrypted = self.aes_encrypt(data)
|
|
return self.add_integrity_check(encrypted)
|
|
|
|
elif classification_level == 'RESTRICTED':
|
|
encrypted = self.aes_encrypt(data)
|
|
signed = self.sign_data(encrypted)
|
|
return self.add_access_control_layer(signed)
|
|
|
|
elif classification_level == 'TOP_SECRET':
|
|
# 다중 암호화
|
|
layer1 = self.aes_encrypt(data)
|
|
layer2 = self.chacha20_encrypt(layer1)
|
|
layer3 = self.quantum_resistant_encrypt(layer2)
|
|
return layer3
|
|
```
|
|
|
|
## 데이터 최소화 원칙
|
|
|
|
### 자동 데이터 정제
|
|
|
|
```python
|
|
class DataMinimization:
|
|
def __init__(self):
|
|
self.retention_policies = {}
|
|
self.anonymization_rules = {}
|
|
|
|
def apply_data_minimization(self, data, purpose):
|
|
"""목적에 필요한 최소 데이터만 유지"""
|
|
|
|
minimized = {}
|
|
|
|
# 필요한 필드만 선택
|
|
required_fields = self.get_required_fields(purpose)
|
|
|
|
for field in required_fields:
|
|
if field in data:
|
|
# 민감 데이터 마스킹
|
|
if self.is_sensitive(field):
|
|
minimized[field] = self.mask_data(data[field])
|
|
else:
|
|
minimized[field] = data[field]
|
|
|
|
return minimized
|
|
|
|
def auto_expire_data(self):
|
|
"""데이터 자동 만료"""
|
|
|
|
current_time = datetime.now()
|
|
|
|
for data_id, metadata in self.data_registry.items():
|
|
retention_period = self.get_retention_period(
|
|
metadata['classification']
|
|
)
|
|
|
|
if current_time - metadata['created'] > retention_period:
|
|
# 만료 처리
|
|
if metadata['classification'] >= 3:
|
|
# 안전 삭제 (덮어쓰기)
|
|
self.secure_delete(data_id)
|
|
else:
|
|
# 일반 삭제
|
|
self.delete_data(data_id)
|
|
```
|
|
|
|
## 동의 관리
|
|
|
|
### GDPR 준수 동의 시스템
|
|
|
|
```python
|
|
class ConsentManager:
|
|
def __init__(self):
|
|
self.consents = {}
|
|
|
|
def record_consent(self, user_did, consent_details):
|
|
"""동의 기록"""
|
|
|
|
consent = {
|
|
'id': uuid.uuid4().hex,
|
|
'user': user_did,
|
|
'timestamp': datetime.now().isoformat(),
|
|
'purposes': consent_details['purposes'],
|
|
'data_types': consent_details['data_types'],
|
|
'duration': consent_details.get('duration', '1_year'),
|
|
'withdrawal_method': 'immediate',
|
|
'version': '1.0',
|
|
'signature': self.sign_consent(consent_details)
|
|
}
|
|
|
|
self.consents[user_did] = consent
|
|
|
|
# 블록체인에 해시 저장 (증명용)
|
|
self.store_consent_proof(consent)
|
|
|
|
return consent
|
|
|
|
def check_consent(self, user_did, purpose, data_type):
|
|
"""동의 확인"""
|
|
|
|
if user_did not in self.consents:
|
|
return False
|
|
|
|
consent = self.consents[user_did]
|
|
|
|
# 만료 확인
|
|
if self.is_expired(consent):
|
|
return False
|
|
|
|
# 목적과 데이터 타입 확인
|
|
if purpose in consent['purposes'] and data_type in consent['data_types']:
|
|
return True
|
|
|
|
return False
|
|
|
|
def withdraw_consent(self, user_did):
|
|
"""동의 철회"""
|
|
|
|
if user_did in self.consents:
|
|
# 철회 기록
|
|
withdrawal = {
|
|
'user': user_did,
|
|
'timestamp': datetime.now().isoformat(),
|
|
'consent_id': self.consents[user_did]['id']
|
|
}
|
|
|
|
# 관련 데이터 처리
|
|
self.handle_data_on_withdrawal(user_did)
|
|
|
|
# 동의 제거
|
|
del self.consents[user_did]
|
|
|
|
return withdrawal
|
|
```
|
|
|
|
## 실시간 모니터링
|
|
|
|
### 접근 제어 대시보드
|
|
|
|
```python
|
|
class AccessControlDashboard:
|
|
def __init__(self):
|
|
self.metrics = {}
|
|
self.alerts = []
|
|
|
|
def real_time_monitoring(self):
|
|
"""실시간 모니터링"""
|
|
|
|
dashboard_data = {
|
|
'current_sessions': self.get_active_sessions(),
|
|
'access_attempts': {
|
|
'last_hour': self.count_attempts('1h'),
|
|
'success_rate': self.calculate_success_rate('1h'),
|
|
'denied_attempts': self.get_denied_attempts('1h')
|
|
},
|
|
'data_access': {
|
|
'sensitive_access': self.track_sensitive_access(),
|
|
'unusual_patterns': self.detect_anomalies(),
|
|
'high_volume_users': self.identify_high_volume()
|
|
},
|
|
'compliance': {
|
|
'gdpr_status': self.check_gdpr_compliance(),
|
|
'consent_coverage': self.calculate_consent_coverage(),
|
|
'retention_violations': self.find_retention_violations()
|
|
},
|
|
'security_events': {
|
|
'failed_authentications': self.count_failed_auth(),
|
|
'privilege_escalations': self.detect_escalations(),
|
|
'data_exfiltration_attempts': self.detect_exfiltration()
|
|
}
|
|
}
|
|
|
|
return dashboard_data
|
|
``` |