security
Как управлять рисками
Процессы идентификации, оценки и управления рисками информационной безопасности
•
#security
#risk-management
#compliance
#governance
Как управлять рисками
Управление рисками — непрерывный процесс выявления, оценки, обработки и мониторинга рисков информационной безопасности.
Процесс управления рисками
1. Идентификация рисков
interface Risk {
id: string;
name: string;
description: string;
category: RiskCategory;
assets: string[];
threats: string[];
vulnerabilities: string[];
}
enum RiskCategory {
TECHNICAL = 'Technical',
OPERATIONAL = 'Operational',
COMPLIANCE = 'Compliance',
STRATEGIC = 'Strategic'
}
class RiskIdentification {
identifyRisks(assets: Asset[]): Risk[] {
const risks: Risk[] = [];
for (const asset of assets) {
// Технические риски
if (asset.hasPublicAPI) {
risks.push({
id: `RISK-${asset.id}-001`,
name: 'Несанкционированный доступ к API',
description: 'API доступен публично без должной защиты',
category: RiskCategory.TECHNICAL,
assets: [asset.id],
threats: ['Атака на API', 'Перебор учетных данных'],
vulnerabilities: ['Отсутствие rate limiting', 'Слабая аутентификация']
});
}
// Операционные риски
if (!asset.hasBackup) {
risks.push({
id: `RISK-${asset.id}-002`,
name: 'Потеря данных',
description: 'Отсутствие резервного копирования',
category: RiskCategory.OPERATIONAL,
assets: [asset.id],
threats: ['Сбой оборудования', 'Удаление данных'],
vulnerabilities: ['Отсутствие backup']
});
}
}
return risks;
}
}
interface Asset {
id: string;
name: string;
type: string;
hasPublicAPI: boolean;
hasBackup: boolean;
}
2. Оценка рисков
class RiskAssessment {
assessRisk(risk: Risk): RiskScore {
const likelihood = this.assessLikelihood(risk);
const impact = this.assessImpact(risk);
const score = this.calculateRiskScore(likelihood, impact);
return {
risk: risk.id,
likelihood,
impact,
score,
level: this.getRiskLevel(score)
};
}
private assessLikelihood(risk: Risk): number {
// 1-5 шкала вероятности
let score = 1;
if (risk.vulnerabilities.length > 3) score += 2;
if (risk.threats.length > 2) score += 1;
if (risk.category === RiskCategory.TECHNICAL) score += 1;
return Math.min(score, 5);
}
private assessImpact(risk: Risk): number {
// 1-5 шкала воздействия
let score = 1;
if (risk.assets.length > 5) score += 2;
if (risk.category === RiskCategory.COMPLIANCE) score += 2;
return Math.min(score, 5);
}
private calculateRiskScore(likelihood: number, impact: number): number {
return likelihood * impact;
}
private getRiskLevel(score: number): RiskLevel {
if (score >= 20) return 'Critical';
if (score >= 15) return 'High';
if (score >= 8) return 'Medium';
return 'Low';
}
}
interface RiskScore {
risk: string;
likelihood: number;
impact: number;
score: number;
level: RiskLevel;
}
type RiskLevel = 'Low' | 'Medium' | 'High' | 'Critical';
3. Обработка рисков
enum RiskTreatment {
MITIGATE = 'Mitigate', // Снижение
TRANSFER = 'Transfer', // Передача
ACCEPT = 'Accept', // Принятие
AVOID = 'Avoid' // Избежание
}
interface RiskTreatmentPlan {
riskId: string;
treatment: RiskTreatment;
controls: Control[];
owner: string;
deadline: Date;
cost: number;
residualRisk: RiskLevel;
}
interface Control {
id: string;
type: 'Preventive' | 'Detective' | 'Corrective';
description: string;
status: 'Planned' | 'In Progress' | 'Implemented';
}
class RiskTreatment {
createTreatmentPlan(risk: Risk, score: RiskScore): RiskTreatmentPlan {
const treatment = this.selectTreatment(score);
const controls = this.identifyControls(risk, treatment);
return {
riskId: risk.id,
treatment,
controls,
owner: 'Security Team',
deadline: this.calculateDeadline(score.level),
cost: this.estimateCost(controls),
residualRisk: this.estimateResidualRisk(score, controls)
};
}
private selectTreatment(score: RiskScore): RiskTreatment {
if (score.level === 'Critical' || score.level === 'High') {
return RiskTreatment.MITIGATE;
}
if (score.level === 'Medium') {
return RiskTreatment.MITIGATE;
}
return RiskTreatment.ACCEPT;
}
private identifyControls(risk: Risk, treatment: RiskTreatment): Control[] {
const controls: Control[] = [];
if (treatment === RiskTreatment.MITIGATE) {
// Превентивные контроли
controls.push({
id: `CTRL-${risk.id}-001`,
type: 'Preventive',
description: 'Внедрить WAF для защиты API',
status: 'Planned'
});
// Детективные контроли
controls.push({
id: `CTRL-${risk.id}-002`,
type: 'Detective',
description: 'Настроить мониторинг и алерты',
status: 'Planned'
});
// Корректирующие контроли
controls.push({
id: `CTRL-${risk.id}-003`,
type: 'Corrective',
description: 'Разработать план реагирования на инциденты',
status: 'Planned'
});
}
return controls;
}
private calculateDeadline(level: RiskLevel): Date {
const now = new Date();
const days = {
'Critical': 7,
'High': 30,
'Medium': 90,
'Low': 180
};
now.setDate(now.getDate() + days[level]);
return now;
}
private estimateCost(controls: Control[]): number {
return controls.length * 10000; // Примерная оценка
}
private estimateResidualRisk(score: RiskScore, controls: Control[]): RiskLevel {
const reduction = controls.length * 2;
const newScore = Math.max(score.score - reduction, 1);
if (newScore >= 20) return 'Critical';
if (newScore >= 15) return 'High';
if (newScore >= 8) return 'Medium';
return 'Low';
}
}
Матрица рисков
class RiskMatrix {
private matrix: number[][] = [
[1, 2, 3, 4, 5],
[2, 4, 6, 8, 10],
[3, 6, 9, 12, 15],
[4, 8, 12, 16, 20],
[5, 10, 15, 20, 25]
];
getRiskScore(likelihood: number, impact: number): number {
return this.matrix[likelihood - 1][impact - 1];
}
visualize(): string {
let output = ' Impact →\n';
output += ' 1 2 3 4 5\n';
output += ' ┌──────────────\n';
for (let i = 4; i >= 0; i--) {
output += `${i + 1} │`;
for (let j = 0; j < 5; j++) {
const score = this.matrix[i][j];
output += ` ${score.toString().padStart(2)} `;
}
output += '\n';
}
output += '↑\nLikelihood';
return output;
}
}
Реестр рисков
class RiskRegister {
private risks: Map<string, RiskEntry> = new Map();
addRisk(risk: Risk, score: RiskScore, treatment: RiskTreatmentPlan): void {
this.risks.set(risk.id, {
risk,
score,
treatment,
status: 'Open',
createdAt: new Date(),
updatedAt: new Date()
});
}
updateRisk(riskId: string, updates: Partial<RiskEntry>): void {
const entry = this.risks.get(riskId);
if (entry) {
Object.assign(entry, updates);
entry.updatedAt = new Date();
}
}
closeRisk(riskId: string, reason: string): void {
const entry = this.risks.get(riskId);
if (entry) {
entry.status = 'Closed';
entry.closedAt = new Date();
entry.closeReason = reason;
}
}
getHighRisks(): RiskEntry[] {
return Array.from(this.risks.values())
.filter(e => e.score.level === 'High' || e.score.level === 'Critical')
.filter(e => e.status === 'Open');
}
getOverdueRisks(): RiskEntry[] {
const now = new Date();
return Array.from(this.risks.values())
.filter(e => e.status === 'Open')
.filter(e => e.treatment.deadline < now);
}
generateReport(): RiskReport {
const entries = Array.from(this.risks.values());
return {
total: entries.length,
open: entries.filter(e => e.status === 'Open').length,
closed: entries.filter(e => e.status === 'Closed').length,
byLevel: {
critical: entries.filter(e => e.score.level === 'Critical').length,
high: entries.filter(e => e.score.level === 'High').length,
medium: entries.filter(e => e.score.level === 'Medium').length,
low: entries.filter(e => e.score.level === 'Low').length
},
overdue: this.getOverdueRisks().length
};
}
}
interface RiskEntry {
risk: Risk;
score: RiskScore;
treatment: RiskTreatmentPlan;
status: 'Open' | 'In Progress' | 'Closed';
createdAt: Date;
updatedAt: Date;
closedAt?: Date;
closeReason?: string;
}
interface RiskReport {
total: number;
open: number;
closed: number;
byLevel: {
critical: number;
high: number;
medium: number;
low: number;
};
overdue: number;
}
Мониторинг рисков
class RiskMonitoring {
async monitorRisks(register: RiskRegister): Promise<MonitoringReport> {
const highRisks = register.getHighRisks();
const overdueRisks = register.getOverdueRisks();
const alerts: Alert[] = [];
// Проверяем критичные риски
for (const entry of highRisks) {
if (entry.score.level === 'Critical') {
alerts.push({
severity: 'Critical',
message: `Критичный риск ${entry.risk.id} требует немедленного внимания`,
riskId: entry.risk.id
});
}
}
// Проверяем просроченные риски
for (const entry of overdueRisks) {
alerts.push({
severity: 'High',
message: `Риск ${entry.risk.id} просрочен на ${this.getDaysOverdue(entry)} дней`,
riskId: entry.risk.id
});
}
return {
timestamp: new Date(),
alerts,
summary: register.generateReport()
};
}
private getDaysOverdue(entry: RiskEntry): number {
const now = new Date();
const diff = now.getTime() - entry.treatment.deadline.getTime();
return Math.floor(diff / (1000 * 60 * 60 * 24));
}
}
interface Alert {
severity: 'Low' | 'Medium' | 'High' | 'Critical';
message: string;
riskId: string;
}
interface MonitoringReport {
timestamp: Date;
alerts: Alert[];
summary: RiskReport;
}
Best Practices
1. Регулярный пересмотр
class RiskReview {
async conductReview(register: RiskRegister): Promise<ReviewResult> {
const entries = Array.from(register['risks'].values());
const updates: RiskUpdate[] = [];
for (const entry of entries) {
// Переоценка рисков каждые 90 дней
const daysSinceUpdate = this.getDaysSince(entry.updatedAt);
if (daysSinceUpdate > 90) {
updates.push({
riskId: entry.risk.id,
reason: 'Scheduled review',
action: 'Reassess'
});
}
}
return {
reviewDate: new Date(),
risksReviewed: entries.length,
updatesRequired: updates
};
}
private getDaysSince(date: Date): number {
const now = new Date();
const diff = now.getTime() - date.getTime();
return Math.floor(diff / (1000 * 60 * 60 * 24));
}
}
interface RiskUpdate {
riskId: string;
reason: string;
action: string;
}
interface ReviewResult {
reviewDate: Date;
risksReviewed: number;
updatesRequired: RiskUpdate[];
}
2. Интеграция с процессами
- Включите оценку рисков в процесс разработки
- Проводите risk assessment для новых проектов
- Обновляйте реестр рисков при изменениях в системе
3. Коммуникация
- Регулярно информируйте руководство о статусе рисков
- Проводите обучение сотрудников
- Документируйте принятые решения
Заключение
Эффективное управление рисками требует:
- Систематического подхода — регулярная идентификация и оценка
- Документирования — ведение реестра рисков
- Мониторинга — отслеживание статуса и сроков
- Коммуникации — информирование заинтересованных сторон
- Непрерывного улучшения — пересмотр и обновление