Mở Đầu: Câu Chuyện Thực Tế Từ Dự Án RAG Doanh Nghiệp
Năm 2025, một công ty thương mại điện tử lớn tại Việt Nam triển khai hệ thống RAG (Retrieval-Augmented Generation) để hỗ trợ khách hàng 24/7. Họ xử lý khoảng 50,000 yêu cầu mỗi ngày với dữ liệu khách hàng nhạy cảm bao gồm địa chỉ, lịch sử mua hàng, và thông tin thanh toán. Chỉ 3 tháng sau khi ra mắt, họ nhận được thông báo GDPR từ một khách hàng châu Âu — dữ liệu của công dân EU đã được lưu trữ và xử lý mà không có cơ chế đồng ý rõ ràng.
Khoản phạt tiềm năng: €20 triệu hoặc 4% doanh thu toàn cầu. Đây là lý do bài viết này ra đời — để giúp bạn tránh những rủi ro pháp lý tương tự khi triển khai AI trong doanh nghiệp.
Tại Sao Compliance AI Là Ưu Tiên Số Một Năm 2026?
Với sự bùng nổ của Large Language Models (LLM) và RAG systems, các quy định bảo vệ dữ liệu đã được thắt chặt đáng kể. Theo báo cáo của Gartner, 60% doanh nghiệp triển khai AI sẽ đối mặt với ít nhất một sự cố compliance trong giai đoạn 2025-2026.
Tỷ lệ tiết kiệm khi sử dụng HolySheheep AI: Với mức giá chỉ từ $0.42/MTok (DeepSeek V3.2), doanh nghiệp có thể triển khai hệ thống AI compliance mà không lo về chi phí. Đăng ký tại đây để nhận tín dụng miễn phí khi bắt đầu.
1. GDPR Cho Hệ Thống AI — Những Điều Bắt Buộc
1.1 Yêu Cầu Cốt Lõi
- Lawful Basis: Mọi xử lý dữ liệu cá nhân phải có cơ sở pháp lý (consent, contract, legitimate interest)
- Data Minimization: Chỉ thu thập dữ liệu thực sự cần thiết
- Purpose Limitation: Dữ liệu chỉ được dùng cho mục đích đã định nghĩa
- Storage Limitation: Không lưu trữ vĩnh viễn — phải có chính sách xóa tự động
- Right to be Forgotten: Người dùng có quyền yêu cầu xóa toàn bộ dữ liệu
- Data Portability: Cung cấp dữ liệu ở định dạng có thể đọc được
1.2 Triển Khai AI Chatbot Tuân Thủ GDPR
"""
AI Customer Service Chatbot - GDPR Compliant Version
Triển khai trên HolySheheep AI API
"""
import requests
import hashlib
import json
from datetime import datetime, timedelta
from typing import Optional, Dict, List
from dataclasses import dataclass, asdict
from enum import Enum
class ProcessingPurpose(Enum):
CUSTOMER_SUPPORT = "customer_support"
ORDER_INQUIRY = "order_inquiry"
PRODUCT_RECOMMENDATION = "product_recommendation"
@dataclass
class GDPRUserConsent:
user_id: str
purposes: List[ProcessingPurpose]
consent_timestamp: datetime
consent_method: str
gdpr lawful_basis: str
data_retention_days: int = 90
@dataclass
class DataSubjectRequest:
request_id: str
user_id: str
request_type: str # access, erasure, portability, rectification
submitted_at: datetime
status: str = "pending"
completed_at: Optional[datetime] = None
class GDPRCompliantAIClient:
"""
AI Client với đầy đủ tính năng GDPR compliance
"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json",
"X-GDPR-Consent-Required": "true",
"X-Data-Retention-Policy": "90days"
}
self.consent_store: Dict[str, GDPRUserConsent] = {}
self.conversation_store: Dict[str, List[Dict]] = {}
self.data_subject_requests: List[DataSubjectRequest] = []
def verify_consent(self, user_id: str, purpose: ProcessingPurpose) -> bool:
"""Kiểm tra người dùng đã đồng ý cho mục đích cụ thể"""
if user_id not in self.consent_store:
return False
consent = self.consent_store[user_id]
return purpose in consent.purposes and \
(datetime.now() - consent.consent_timestamp).days < consent.data_retention_days
def record_consent(self, user_id: str, purposes: List[ProcessingPurpose],
lawful_basis: str = "consent") -> GDPRUserConsent:
"""Ghi nhận sự đồng ý của người dùng với audit trail"""
consent = GDPRUserConsent(
user_id=user_id,
purposes=purposes,
consent_timestamp=datetime.now(),
consent_method="digital_signature",
gdpr_lawful_basis=lawful_basis,
data_retention_days=90
)
self.consent_store[user_id] = consent
print(f"[GDPR] Consent recorded for user {user_id[:8]}... at {consent.consent_timestamp}")
return consent
def generate_anonymized_user_id(self, user_id: str) -> str:
"""Tạo anonymous ID để xử lý không tiết lộ danh tính"""
return hashlib.sha256(
f"{user_id}{datetime.now().strftime('%Y%m%d')}".encode()
).hexdigest()[:16]
def chat_with_gdpr_compliance(
self,
user_id: str,
message: str,
purpose: ProcessingPurpose = ProcessingPurpose.CUSTOMER_SUPPORT
) -> Dict:
"""
Gửi tin nhắn đến AI với đầy đủ compliance checks
"""
# Bước 1: Verify consent
if not self.verify_consent(user_id, purpose):
return {
"error": "CONSENT_REQUIRED",
"message": "User consent is required before processing",
"gdpr_article": "Article 6 - Lawfulness of processing",
"action_required": "obtain_consent"
}
# Bước 2: Anonymize user data trong request
anonymous_id = self.generate_anonymized_user_id(user_id)
# Bước 3: Xây dựng prompt với data minimization
system_prompt = f"""Bạn là AI assistant tuân thủ GDPR.
- KHÔNG lưu trữ thông tin cá nhân từ cuộc hội thoại
- Chỉ trả lời câu hỏi, không ghi nhận dữ liệu nhạy cảm
- Nếu người dùng cung cấp thông tin cá nhân, hãy bỏ qua và không phản hồi
"""
# Bước 4: Gọi API với HolySheheep
payload = {
"model": "deepseek-v3.2",
"messages": [
{"role": "system", "content": system_prompt},
{"role": "user", "content": message}
],
"max_tokens": 500,
"temperature": 0.3,
"metadata": {
"anonymous_user_id": anonymous_id,
"purpose": purpose.value,
"gdpr_compliant": True,
"processing_timestamp": datetime.now().isoformat()
}
}
try:
response = requests.post(
f"{self.BASE_URL}/chat/completions",
headers=self.headers,
json=payload,
timeout=30
)
response.raise_for_status()
result = response.json()
# Bước 5: Lưu conversation với retention policy
self._store_conversation(anonymous_id, message, result.get("choices", [{}])[0].get("message", {}).get("content", ""))
return {
"response": result.get("choices", [{}])[0].get("message", {}).get("content", ""),
"anonymous_session_id": anonymous_id,
"gdpr_compliant": True,
"data_will_be_deleted_after_days": 90
}
except requests.exceptions.RequestException as e:
return {"error": str(e), "gdpr_compliant": False}
def _store_conversation(self, anonymous_id: str, user_message: str, ai_response: str):
"""Lưu trữ với automatic expiration"""
if anonymous_id not in self.conversation_store:
self.conversation_store[anonymous_id] = []
self.conversation_store[anonymous_id].append({
"timestamp": datetime.now().isoformat(),
"expires_at": (datetime.now() + timedelta(days=90)).isoformat(),
"user_message_hash": hashlib.sha256(user_message.encode()).hexdigest()[:16],
"ai_response_hash": hashlib.sha256(ai_response.encode()).hexdigest()[:16]
})
def handle_data_subject_request(self, user_id: str, request_type: str) -> DataSubjectRequest:
"""
Xử lý các yêu cầu của chủ thể dữ liệu theo GDPR Article 15-22
"""
request = DataSubjectRequest(
request_id=hashlib.sha256(f"{user_id}{datetime.now()}".encode()).hexdigest()[:12],
user_id=user_id,
request_type=request_type,
submitted_at=datetime.now()
)
if request_type == "access":
request.status = "completed"
request.completed_at = datetime.now()
# Trả về tất cả dữ liệu đang lưu
elif request_type == "erasure":
# Xóa tất cả dữ liệu liên quan đến user_id
if user_id in self.consent_store:
del self.consent_store[user_id]
# Xóa conversations
keys_to_remove = [k for k in self.conversation_store.keys()
if k.startswith(user_id[:8])]
for key in keys_to_remove:
del self.conversation_store[key]
request.status = "completed"
request.completed_at = datetime.now()
elif request_type == "portability":
# Export dữ liệu ở JSON format
request.status = "completed"
request.completed_at = datetime.now()
self.data_subject_requests.append(request)
print(f"[GDPR] Data subject request {request.request_id} processed: {request.status}")
return request
Sử dụng
client = GDPRCompliantAIClient(api_key="YOUR_HOLYSHEEP_API_KEY")
Ghi nhận consent
client.record_consent(
user_id="user_12345",
purposes=[ProcessingPurpose.CUSTOMER_SUPPORT, ProcessingPurpose.ORDER_INQUIRY],
lawful_basis="contract"
)
Chat với compliance
result = client.chat_with_gdpr_compliance(
user_id="user_12345",
message="Tôi muốn biết đơn hàng #12345 của tôi đang ở đâu?",
purpose=ProcessingPurpose.ORDER_INQUIRY
)
print(result)
2. HIPAA Compliance Cho AI Trong Y Tế
2.1 Phạm Vi Áp Dụng
Nếu bạn xây dựng AI cho bệnh viện, phòng khám, hoặc bất kỳ hệ thống nào xử lý Protected Health Information (PHI), HIPAA là bắt buộc. Vi phạm có thể lên đến $1.5 triệu mỗi violation category.
2.2 RAG System Cho Y Tế Với HIPAA
"""
Medical RAG System - HIPAA Compliant
Xây dựng hệ thống tra cứu tài liệu y khoa với bảo mật tối đa
"""
import requests
import hashlib
import hmac
import base64
from cryptography.fernet import Fernet
from datetime import datetime, timedelta
from typing import List, Dict, Optional
from dataclasses import dataclass
@dataclass
class PHIRecord:
"""Protected Health Information Record"""
patient_id: str
encounter_id: str
encrypted_content: bytes
access_log: List[Dict]
created_at: datetime
last_accessed: datetime
authorized_roles: List[str]
@dataclass
class AuditEntry:
timestamp: datetime
user_id: str
action: str
resource_type: str
resource_id: str
ip_address: str
status: str
class HIPAACompliantMedicalRAG:
"""
RAG System tuân thủ HIPAA cho ngành y tế
"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json",
"X-HIPAA-Compliant": "true",
"X-BAA-Required": "true"
}
self.encryption_key = Fernet.generate_key()
self.cipher = Fernet(self.encryption_key)
self.patient_records: Dict[str, PHIRecord] = {}
self.audit_log: List[AuditEntry] = []
self.user_roles: Dict[str, List[str]] = {}
def _encrypt_phi(self, content: str) -> bytes:
"""Mã hóa PHI trước khi lưu trữ"""
return self.cipher.encrypt(content.encode())
def _decrypt_phi(self, encrypted_content: bytes) -> str:
"""Giải mã PHI khi được authorized"""
return self.cipher.decrypt(encrypted_content).decode()
def _log_audit(self, user_id: str, action: str, resource_id: str,
resource_type: str = "phi_record", status: str = "success"):
"""Ghi log audit trail bắt buộc của HIPAA"""
entry = AuditEntry(
timestamp=datetime.now(),
user_id=user_id,
action=action,
resource_type=resource_type,
resource_id=resource_id,
ip_address="10.0.0.1", # Trong thực tế lấy từ request
status=status
)
self.audit_log.append(entry)
print(f"[HIPAA Audit] {entry.timestamp} | User: {user_id} | Action: {action} | Status: {status}")
def verify_authorization(self, user_id: str, required_role: str) -> bool:
"""Kiểm tra user có quyền truy cập PHI không"""
if user_id not in self.user_roles:
self._log_audit(user_id, "UNAUTHORIZED_ACCESS_ATTEMPT", "", "authorization_check", "denied")
return False
if required_role not in self.user_roles[user_id]:
self._log_audit(user_id, "INSUFFICIENT_PRIVILEGES", "", "authorization_check", "denied")
return False
return True
def store_patient_record(self, user_id: str, patient_id: str,
encounter_id: str, content: str,
authorized_roles: List[str]) -> PHIRecord:
"""
Lưu trữ hồ sơ bệnh nhân với mã hóa
Chỉ personnel được authorized mới có thể truy cập
"""
# Verify user has admin/write permissions
if not self.verify_authorization(user_id, "medical_staff"):
raise PermissionError("User not authorized to store PHI records")
# Encrypt PHI before storage
encrypted = self._encrypt_phi(content)
record = PHIRecord(
patient_id=patient_id,
encounter_id=encounter_id,
encrypted_content=encrypted,
access_log=[],
created_at=datetime.now(),
last_accessed=datetime.now(),
authorized_roles=authorized_roles
)
storage_key = f"{patient_id}_{encounter_id}"
self.patient_records[storage_key] = record
self._log_audit(user_id, "CREATE", storage_key, "phi_record", "success")
print(f"[HIPAA] PHI record created: {storage_key} by {user_id}")
return record
def query_medical_rag(self, user_id: str, patient_id: str,
query: str, context_limit: int = 5) -> Dict:
"""
Query RAG system với đầy đủ HIPAA checks
"""
# Step 1: Verify authorization
if not self.verify_authorization(user_id, "medical_staff"):
return {
"error": "ACCESS_DENIED",
"hipaa_rule": "164.312(a)(1) - Access Control",
"message": "You are not authorized to access this patient's records"
}
# Step 2: Find related records
related_records = [
(key, record) for key, record in self.patient_records.items()
if key.startswith(patient_id)
]
if not related_records:
return {"error": "NO_RECORDS_FOUND", "patient_id": patient_id}
# Step 3: Build context from authorized records
context_parts = []
for key, record in related_records[-context_limit:]:
# Verify specific record authorization
if user_id not in record.authorized_roles:
continue
decrypted_content = self._decrypt_phi(record.encrypted_content)
context_parts.append({
"encounter_id": record.encounter_id,
"content": decrypted_content[:500], # Data minimization
"created_at": record.created_at.isoformat()
})
# Update access log
record.last_accessed = datetime.now()
record.access_log.append({
"accessed_by": user_id,
"timestamp": datetime.now().isoformat(),
"purpose": "treatment"
})
# Step 4: Create RAG prompt
context_text = "\n\n".join([p["content"] for p in context_parts])
rag_prompt = f"""Bạn là trợ lý y khoa tuân thủ HIPAA.
Bối cảnh hồ sơ bệnh nhân (đã được ẩn danh hóa):
{context_text}
Câu hỏi: {query}
Lưu ý:
- KHÔNG tiết lộ thông tin cá nhân trong câu trả lời
- Chỉ cung cấp thông tin y khoa chung
- Không lưu trữ câu hỏi hoặc câu trả lời
"""
# Step 5: Call HolySheheep API
payload = {
"model": "deepseek-v3.2",
"messages": [
{"role": "system", "content": "You are a HIPAA-compliant medical assistant."},
{"role": "user", "content": rag_prompt}
],
"max_tokens": 800,
"temperature": 0.2
}
try:
response = requests.post(
f"{self.BASE_URL}/chat/completions",
headers=self.headers,
json=payload,
timeout=30
)
response.raise_for_status()
result = response.json()
# Step 6: Log successful access
self._log_audit(user_id, "READ", patient_id, "phi_record", "success")
return {
"response": result["choices"][0]["message"]["content"],
"context_provided": len(context_parts),
"hipaa_compliant": True,
"audit_id": hashlib.sha256(f"{user_id}{datetime.now()}".encode()).hexdigest()[:12]
}
except requests.exceptions.RequestException as e:
self._log_audit(user_id, "API_ERROR", patient_id, "phi_record", "failed")
return {"error": str(e), "hipaa_compliant": False}
def generate_hipaa_report(self, start_date: datetime, end_date: datetime) -> Dict:
"""Tạo báo cáo audit cho HIPAA compliance review"""
relevant_logs = [
log for log in self.audit_log
if start_date <= log.timestamp <= end_date
]
return {
"report_period": {
"start": start_date.isoformat(),
"end": end_date.isoformat()
},
"total_access_events": len(relevant_logs),
"access_by_user": {},
"failed_access_attempts": len([l for l in relevant_logs if l.status == "denied"]),
"compliance_status": "COMPLIANT" if len([l for l in relevant_logs if l.status == "success"]) > 0 else "REVIEW_REQUIRED"
}
Sử dụng
hipaa_rag = HIPAACompliantMedicalRAG(api_key="YOUR_HOLYSHEEP_API_KEY")
Gán role cho user (trong thực tế từ IAM system)
hipaa_rag.user_roles["dr_smith"] = ["medical_staff", "physician"]
hipaa_rag.user_roles["nurse_jane"] = ["medical_staff"]
hipaa_rag.user_roles["admin_user"] = ["administrative"]
Lưu hồ sơ bệnh nhân
record = hipaa_rag.store_patient_record(
user_id="admin_system",
patient_id="P12345",
encounter_id="E2026001",
content="Bệnh nhân được chẩn đoán viêm phổi nhẹ. Đã prescrible antibiotics 5 ngày.",
authorized_roles=["dr_smith", "nurse_jane"]
)
Query với authorized user
result = hipaa_rag.query_medical_rag(
user_id="dr_smith",
patient_id="P12345",
query="Tóm tắt tình trạng bệnh nhân và phác đồ điều trị"
)
print(result)
Tạo báo cáo compliance
report = hipaa_rag.generate_hipaa_report(
start_date=datetime.now() - timedelta(days=30),
end_date=datetime.now()
)
print(f"HIPAA Audit Report: {report}")
3. SOC 2 Type II Compliance Cho AI Infrastructure
3.1 Các Trust Service Criteria
SOC 2 yêu cầu kiểm soát nghiêm ngặt trên 5 criteria:
- Security: Bảo vệ chống lại unauthorized access
- Availability: Hệ thống sẵn sàng hoạt động như cam kết
- Processing Integrity: Xử lý hoàn tất, chính xác, kịp thời
- Confidentiality: Bảo vệ thông tin được chỉ định là confidential
- Privacy: Thu thập, sử dụng, lưu trữ theo privacy notice
3.2 Monitoring Dashboard Với SOC 2 Controls
/**
* SOC 2 Compliant AI Monitoring Dashboard
* Triển khai trên HolySheheep AI API
*/
interface SOC2Control {
id: string;
name: string;
category: 'security' | 'availability' | 'integrity' | 'confidentiality' | 'privacy';
status: 'pass' | 'fail' | 'warning' | 'not_tested';
lastChecked: Date;
evidence: ControlEvidence[];
}
interface ControlEvidence {
timestamp: Date;
result: string;
automatedCheck: boolean;
auditor: string;
}
interface APIMetrics {
totalRequests: number;
successfulRequests: number;
failedRequests: number;
averageLatency: number;
p99Latency: number;
errorRate: number;
}
class SOC2CompliantAIMonitoring {
private readonly baseURL = "https://api.holysheep.ai/v1";
private controls: Map = new Map();
private incidentLog: Incident[] = [];
// SOC 2 Controls Registry
private readonly requiredControls: SOC2Control[] = [
{
id: "CC6.1",
name: "Logical and Physical Access Controls",
category: "security",
status: "not_tested",
lastChecked: new Date(),
evidence: []
},
{
id: "CC6.6",
name: "Security for Confidential Information",
category: "confidentiality",
status: "not_tested",
lastChecked: new Date(),
evidence: []
},
{
id: "A1.2",
name: "System Availability Monitoring",
category: "availability",
status: "not_tested",
lastChecked: new Date(),
evidence: []
},
{
id: "PI1.1",
name: "Processing Integrity Controls",
category: "integrity",
status: "not_tested",
lastChecked: new Date(),
evidence: []
},
{
id: "P3.1",
name: "Privacy Notice Compliance",
category: "privacy",
status: "not_tested",
lastChecked: new Date(),
evidence: []
}
];
constructor(private apiKey: string) {
this.initializeControls();
}
private initializeControls(): void {
this.requiredControls.forEach(control => {
this.controls.set(control.id, control);
});
}
// CC6.1: Verify encryption in transit
async checkEncryptionInTransit(): Promise {
const evidence: ControlEvidence = {
timestamp: new Date(),
result: "TLS 1.3 verified - All API endpoints use encryption",
automatedCheck: true,
auditor: "automated_monitoring"
};
// Simulate TLS check
const testResponse = await fetch(this.baseURL, {
method: 'HEAD',
headers: { 'Authorization': Bearer ${this.apiKey} }
});
const tlsVersion = testResponse.headers.get('strict-transport-security');
evidence.result = tlsVersion
? TLS verified, HSTS: ${tlsVersion}
: "TLS verification failed";
return evidence;
}
// A1.2: System availability monitoring
async checkSystemAvailability(): Promise<{ metrics: APIMetrics; status: string }> {
const startTime = Date.now();
const testPayload = {
model: "deepseek-v3.2",
messages: [{ role: "user", content: "ping" }],
max_tokens: 5
};
try {
const response = await fetch(${this.baseURL}/chat/completions, {
method: 'POST',
headers: {
'Authorization': Bearer ${this.apiKey},
'Content-Type': 'application/json'
},
body: JSON.stringify(testPayload)
});
const latency = Date.now() - startTime;
const metrics: APIMetrics = {
totalRequests: 1,
successfulRequests: response.ok ? 1 : 0,
failedRequests: response.ok ? 0 : 1,
averageLatency: latency,
p99Latency: latency,
errorRate: response.ok ? 0 : 100
};
return {
metrics,
status: response.ok ? "AVAILABLE" : "DEGRADED"
};
} catch (error) {
return {
metrics: {
totalRequests: 1,
successfulRequests: 0,
failedRequests: 1,
averageLatency: 0,
p99Latency: 0,
errorRate: 100
},
status: "UNAVAILABLE"
};
}
}
// PI1.1: Processing integrity - verify responses
async verifyProcessingIntegrity(): Promise {
const testQuery = "What is 2+2?";
const expectedKeywords = ["4", "four", "bốn"];
try {
const response = await fetch(${this.baseURL}/chat/completions, {
method: 'POST',
headers: {
'Authorization': Bearer ${this.apiKey},
'Content-Type': 'application/json'
},
body: JSON.stringify({
model: "deepseek-v3.2",
messages: [{ role: "user", content: testQuery }],
max_tokens: 50
})
});
const data = await response.json();
const answer = data.choices?.[0]?.message?.content || "";
const hasCorrectAnswer = expectedKeywords.some(
keyword => answer.toLowerCase().includes(keyword.toLowerCase())
);
return {
timestamp: new Date(),
result: hasCorrectAnswer
? "Processing integrity verified - Correct response received"
: "Processing integrity issue - Unexpected response",
automatedCheck: true,
auditor: "automated_monitoring"
};
} catch (error) {
return {
timestamp: new Date(),
result: Processing integrity check failed: ${error},
automatedCheck: true,
auditor: "automated_monitoring"
};
}
}
// CC6.6: Data confidentiality check
async checkDataConfidentiality(): Promise {
// Verify data is not logged or stored
const evidence: ControlEvidence = {
timestamp: new Date(),
result: "Confidentiality controls verified",
automatedCheck: true,
auditor: "automated_monitoring"
};
// Check API headers for data handling policies
const testResponse = await fetch(this.baseURL + '/models', {
headers: { 'Authorization': Bearer ${this.apiKey} }
});
const dataRetention = testResponse.headers.get('X-Data-Retention-Policy');
const confidentialityLevel = testResponse.headers.get('X-Confidentiality-Level');
if (dataRetention && confidentialityLevel) {
evidence.result = Data retention: ${dataRetention}, Confidentiality: ${confidentialityLevel};
}
return evidence;
}
// Run all SOC 2 control tests
async runSOC2Audit(): Promise<{
auditDate: Date;
controls: SOC2Control[];
overallStatus: string;
recommendations: string[];
}> {
console.log("[SOC 2] Starting automated compliance audit...");
const recommendations: string[] = [];
// CC6.1: Security controls
const securityControl = this.controls.get("CC6.1")!;
securityControl.evidence.push(await this.checkEncryptionInTransit());
securityControl.status = securityControl.evidence[0].result.includes("verified") ? "pass" : "fail";
securityControl.lastChecked = new Date();
// A1.2: Availability controls
const availabilityControl = this.controls.get("A1.2")!;
const availabilityResult = await this.checkSystemAvailability();
availabilityControl.evidence.push({
timestamp: new Date(),
result: System ${availabilityResult.status}, Error rate: ${availabilityResult.metrics.errorRate}%,
automatedCheck: true,
auditor: "automated_monitoring"
});
availabilityControl.status = availabilityResult.status === "AVAILABLE" ? "pass" : "warning";
availabilityControl.lastChecked = new Date();
// PI1.1: Integrity controls
const integrityControl = this.controls.get("PI1.1")!;
integrityControl.evidence.push(await this.verifyProcessingIntegrity());
integrityControl.status = integrityControl.evidence[0].result.includes("verified") ? "pass" : "fail";
integrityControl.lastChecked = new Date();
// CC6.6: Confidentiality controls
const confidentialityControl = this.controls.get("CC6.6")!;
confidentialityControl.evidence.push(await this.checkDataConfidentiality());
confidentialityControl.status = confidentialityControl.evidence[0].result.includes("verified") ? "pass" : "warning";
confidentialityControl.lastChecked = new Date();
// Calculate overall status
const allControls = Array.from(this.controls.values());
const failedControls = allControls.filter(c => c.status === "fail").length;
const warningControls = allControls.filter(c => c.status === "
Tài nguyên liên quan
Bài viết liên quan