From 89b0e3a5a53db993456f53b27a7be5cdba96e43c Mon Sep 17 00:00:00 2001 From: Martin Date: Tue, 7 Jul 2026 13:35:59 +0200 Subject: [PATCH] Richtlinien & Verfahren (Phase 1): Import, Rendering-Engine, Bibliothek, Coverage MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fundament des VDA-ISA-2027-Richtlinienmoduls (Spec §1–9): - Datenmodell: PolicyDocument, PolicyRequirement, PolicyVariable (Variablen + Feature-Flags), PolicyBaselineParam, PolicyEvidence — inkl. RLS + Tenant-Guard - Seed-Importer (import-policies.ts): liest die echten .md-Dateien (15 Richtlinien L00/R01–R14 + 11 Verfahren), mapping.json (120 Anforderungen/46 Controls), variables.schema.json (53 Variablen/Flags), Technische-Sicherheits-Baseline (31 BL-Parameter) und Nachweisregister; idempotent pro Mandant - 6 im Vorlagenpaket beschädigte Variablen-Tokens (VA-08/09/10/12/13) repariert (dokumentiert im README des Übergabepakets) - Rendering-Engine (policy-render.ts, Handlebars + marked): verschachtelte {{#if FLAG}}, {{VARIABLE}}, {{LINK:…}}-Deeplinks, Hidden-Anker + BL-Referenzen im Lesemodus entfernt (Wert bleibt), zentral verwaltete Abschnitte unterdrückt, wiederholtes „Umsetzung bei " reduziert (§7a); lenienter Fallback + Residue-Check über alle Flag-Kombinationen (analog _verify.py) - UI: Bibliothek mit Typ-Chips/KPIs, Lesemodus-Popup (einklappbare Info-Tabelle, Control-Chips, Richtlinie↔Verfahren-Verlinkung), Coverage-Matrix (Control → Richtlinie → MUSS/SOLL → Verfahren → Anforderungs-IDs) - Nav-Punkt „Richtlinien" aktiviert; de/en-Übersetzungen Verifiziert: Import 28 Dokumente/120 Anforderungen; Rendering rückstandsfrei über alle Flag-Kombinationen; Bibliothek, Lesemodus (R08 nested flags), Coverage im Browser. Später (Phase 2+): Bearbeiten/Freigabe-Workflow mit Versionierung, verwaltete Tabellen (Krypto-/Risiko-/Klassifizierungsregister), Anwender-Handbuch, DOCX/PDF-Export, Word-Upload, KI-Wizard, zentrale Baseline-/Variablen-Einstellseite. Co-Authored-By: Claude Opus 4.8 --- messages/de.json | 30 + messages/en.json | 30 + package-lock.json | 60 + package.json | 2 + prisma/import-policies.ts | 158 ++ .../20260707132008_policies/migration.sql | 136 ++ prisma/schema.prisma | 110 + prisma/seed.ts | 18 + .../00_Integrationsleitfaden_Wizard.md | 148 ++ .../ISA-Mapping-Matrix.md | 181 ++ .../Nachweisregister_zentral.md | 42 + .../Technische-Sicherheits-Baseline.md | 90 + seed/isms-vorlagenpaket-v2/_enrich.py | 168 ++ seed/isms-vorlagenpaket-v2/_fix.py | 21 + seed/isms-vorlagenpaket-v2/_generate_v2.py | 553 +++++ .../_generate_verfahren.py | 295 +++ seed/isms-vorlagenpaket-v2/_matrix.py | 30 + seed/isms-vorlagenpaket-v2/_verify.py | 51 + seed/isms-vorlagenpaket-v2/mapping.json | 2091 +++++++++++++++++ .../L00_Informationssicherheitsleitlinie.md | 145 ++ .../R01_ISMS-Organisation-und-Rollen.md | 143 ++ ...02_Asset-und-Klassifizierungsrichtlinie.md | 148 ++ ...03_Risikomanagement-und-Auditrichtlinie.md | 127 + ...ent-Notfall-und-Kontinuitaetsrichtlinie.md | 156 ++ .../R05_Personalsicherheit-und-Awareness.md | 119 + ...R06_Mobiles-Arbeiten-und-mobile-Geraete.md | 109 + .../richtlinien/R07_Physische-Sicherheit.md | 100 + .../R08_Identitaets-und-Zugriffsmanagement.md | 148 ++ ...ryptografie-und-Uebertragungsrichtlinie.md | 101 + .../richtlinien/R10_Betriebssicherheit.md | 219 ++ ...chere-Systembeschaffung-und-Entwicklung.md | 117 + .../R12_Cloud-KI-und-externe-IT-Dienste.md | 116 + ..._Lieferanten-und-Dienstleistersteuerung.md | 126 + .../R14_Compliance-und-Datenschutz.md | 102 + .../variables.schema.json | 71 + ...02_IT-Notfall-und-Wiederanlaufverfahren.md | 72 + .../verfahren/VA-03_Berechtigungsverfahren.md | 71 + ...4_Change-und-Patch-Management-Verfahren.md | 71 + ...A-06_Schwachstellenmanagement-Verfahren.md | 69 + ..._Kryptokonzept-und-Schluesselverwaltung.md | 69 + ...-08_Asset-und-Klassifizierungsverfahren.md | 69 + .../VA-09_Risikomanagement-Verfahren.md | 69 + ...10_Lieferanten-Onboarding-und-Bewertung.md | 69 + .../VA-11_Cloud-und-KI-Freigabeverfahren.md | 69 + .../VA-12_Awareness-und-Schulungsverfahren.md | 69 + .../VA-13_Logging-und-Monitoring-Verfahren.md | 69 + src/app/(app)/layout.tsx | 2 +- src/app/(app)/policies/page.tsx | 233 ++ src/app/globals.css | 86 + src/components/policy-modals.tsx | 110 + src/lib/policy-render.ts | 165 ++ src/server/db.ts | 5 + 52 files changed, 7627 insertions(+), 1 deletion(-) create mode 100644 prisma/import-policies.ts create mode 100644 prisma/migrations/20260707132008_policies/migration.sql create mode 100644 seed/isms-vorlagenpaket-v2/00_Integrationsleitfaden_Wizard.md create mode 100644 seed/isms-vorlagenpaket-v2/ISA-Mapping-Matrix.md create mode 100644 seed/isms-vorlagenpaket-v2/Nachweisregister_zentral.md create mode 100644 seed/isms-vorlagenpaket-v2/Technische-Sicherheits-Baseline.md create mode 100644 seed/isms-vorlagenpaket-v2/_enrich.py create mode 100644 seed/isms-vorlagenpaket-v2/_fix.py create mode 100644 seed/isms-vorlagenpaket-v2/_generate_v2.py create mode 100644 seed/isms-vorlagenpaket-v2/_generate_verfahren.py create mode 100644 seed/isms-vorlagenpaket-v2/_matrix.py create mode 100644 seed/isms-vorlagenpaket-v2/_verify.py create mode 100644 seed/isms-vorlagenpaket-v2/mapping.json create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/L00_Informationssicherheitsleitlinie.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R01_ISMS-Organisation-und-Rollen.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R02_Asset-und-Klassifizierungsrichtlinie.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R03_Risikomanagement-und-Auditrichtlinie.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R05_Personalsicherheit-und-Awareness.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R06_Mobiles-Arbeiten-und-mobile-Geraete.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R07_Physische-Sicherheit.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R08_Identitaets-und-Zugriffsmanagement.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R09_Kryptografie-und-Uebertragungsrichtlinie.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R10_Betriebssicherheit.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R11_Sichere-Systembeschaffung-und-Entwicklung.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R12_Cloud-KI-und-externe-IT-Dienste.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R13_Lieferanten-und-Dienstleistersteuerung.md create mode 100644 seed/isms-vorlagenpaket-v2/richtlinien/R14_Compliance-und-Datenschutz.md create mode 100644 seed/isms-vorlagenpaket-v2/variables.schema.json create mode 100644 seed/isms-vorlagenpaket-v2/verfahren/VA-02_IT-Notfall-und-Wiederanlaufverfahren.md create mode 100644 seed/isms-vorlagenpaket-v2/verfahren/VA-03_Berechtigungsverfahren.md create mode 100644 seed/isms-vorlagenpaket-v2/verfahren/VA-04_Change-und-Patch-Management-Verfahren.md create mode 100644 seed/isms-vorlagenpaket-v2/verfahren/VA-06_Schwachstellenmanagement-Verfahren.md create mode 100644 seed/isms-vorlagenpaket-v2/verfahren/VA-07_Kryptokonzept-und-Schluesselverwaltung.md create mode 100644 seed/isms-vorlagenpaket-v2/verfahren/VA-08_Asset-und-Klassifizierungsverfahren.md create mode 100644 seed/isms-vorlagenpaket-v2/verfahren/VA-09_Risikomanagement-Verfahren.md create mode 100644 seed/isms-vorlagenpaket-v2/verfahren/VA-10_Lieferanten-Onboarding-und-Bewertung.md create mode 100644 seed/isms-vorlagenpaket-v2/verfahren/VA-11_Cloud-und-KI-Freigabeverfahren.md create mode 100644 seed/isms-vorlagenpaket-v2/verfahren/VA-12_Awareness-und-Schulungsverfahren.md create mode 100644 seed/isms-vorlagenpaket-v2/verfahren/VA-13_Logging-und-Monitoring-Verfahren.md create mode 100644 src/app/(app)/policies/page.tsx create mode 100644 src/components/policy-modals.tsx create mode 100644 src/lib/policy-render.ts diff --git a/messages/de.json b/messages/de.json index 1986730..fd353f5 100644 --- a/messages/de.json +++ b/messages/de.json @@ -507,5 +507,35 @@ "PROVIDER": "Provider", "US": "Wir", "SHARED": "Geteilt" + }, + "policies": { + "crumb": "ISMS-Dokumentation", + "title": "Richtlinien & Verfahren", + "sub": "VDA-ISA 2027 — Leitlinie, Richtlinien, Verfahrensanweisungen und Register", + "library": "Bibliothek", + "coverage": "Coverage-Matrix", + "all": "Alle", + "code": "Kürzel", + "docTitle": "Titel", + "type": "Typ", + "version": "Version", + "status": "Status", + "coverageCol": "Abdeckung", + "controlsN": "{n} Controls", + "empty": "Keine Dokumente gefunden.", + "close": "Schließen", + "docInfo": "Dokumenteninformationen", + "operationalizes": "Operationalisiert Richtlinie", + "procedures": "Verfahren", + "control": "ISA-Control", + "policy": "Richtlinie", + "reqIds": "Anforderungs-IDs", + "coverageHint": "{controls} Controls · {reqs} Anforderungen (MUSS/SOLL) über Richtlinien und operationalisierende Verfahren.", + "kpiDocs": "Dokumente", + "kpiDocsTrend": "Leitlinie · Richtlinien · Verfahren · Register", + "kpiControls": "Abgedeckte Controls", + "kpiControlsTrend": "VDA-ISA 2027", + "kpiMust": "MUSS-Anforderungen", + "kpiShould": "SOLL-Anforderungen" } } \ No newline at end of file diff --git a/messages/en.json b/messages/en.json index 51684ab..380fb5e 100644 --- a/messages/en.json +++ b/messages/en.json @@ -507,5 +507,35 @@ "PROVIDER": "Provider", "US": "Us", "SHARED": "Shared" + }, + "policies": { + "crumb": "ISMS documentation", + "title": "Policies & Procedures", + "sub": "VDA-ISA 2027 — policy, policies, procedures and registers", + "library": "Library", + "coverage": "Coverage matrix", + "all": "All", + "code": "Code", + "docTitle": "Title", + "type": "Type", + "version": "Version", + "status": "Status", + "coverageCol": "Coverage", + "controlsN": "{n} controls", + "empty": "No documents found.", + "close": "Close", + "docInfo": "Document information", + "operationalizes": "Operationalizes policy", + "procedures": "Procedures", + "control": "ISA control", + "policy": "Policy", + "reqIds": "Requirement IDs", + "coverageHint": "{controls} controls · {reqs} requirements (MUST/SHOULD) across policies and operationalizing procedures.", + "kpiDocs": "Documents", + "kpiDocsTrend": "Policy · policies · procedures · registers", + "kpiControls": "Covered controls", + "kpiControlsTrend": "VDA-ISA 2027", + "kpiMust": "MUST requirements", + "kpiShould": "SHOULD requirements" } } \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index f43ca09..d7ed778 100644 --- a/package-lock.json +++ b/package-lock.json @@ -18,8 +18,10 @@ "class-variance-authority": "^0.7.1", "clsx": "^2.1.1", "dotenv": "^17.4.2", + "handlebars": "^4.7.9", "html-to-image": "^1.11.13", "lucide-react": "^1.23.0", + "marked": "^18.0.5", "next": "16.2.10", "next-auth": "^5.0.0-beta.31", "next-intl": "^4.13.1", @@ -7824,6 +7826,27 @@ "devOptional": true, "license": "MIT" }, + "node_modules/handlebars": { + "version": "4.7.9", + "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.9.tgz", + "integrity": "sha512-4E71E0rpOaQuJR2A3xDZ+GM1HyWYv1clR58tC8emQNeQe3RH7MAzSbat+V0wG78LQBo6m6bzSG/L4pBuCsgnUQ==", + "license": "MIT", + "dependencies": { + "minimist": "^1.2.5", + "neo-async": "^2.6.2", + "source-map": "^0.6.1", + "wordwrap": "^1.0.0" + }, + "bin": { + "handlebars": "bin/handlebars" + }, + "engines": { + "node": ">=0.4.7" + }, + "optionalDependencies": { + "uglify-js": "^3.1.4" + } + }, "node_modules/has-bigints": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz", @@ -9297,6 +9320,18 @@ "@jridgewell/sourcemap-codec": "^1.5.5" } }, + "node_modules/marked": { + "version": "18.0.5", + "resolved": "https://registry.npmjs.org/marked/-/marked-18.0.5.tgz", + "integrity": "sha512-S6GcvALHg6K4ohtu4E7x0a1AqhAjp6cV8KhLSyN9qVapnzJkusVBxZRcIU9AeYsbe6P1hKDusSbEOzGyyuce6w==", + "license": "MIT", + "bin": { + "marked": "bin/marked.js" + }, + "engines": { + "node": ">= 20" + } + }, "node_modules/math-intrinsics": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", @@ -9513,6 +9548,12 @@ "node": ">= 0.6" } }, + "node_modules/neo-async": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz", + "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==", + "license": "MIT" + }, "node_modules/next": { "version": "16.2.10", "resolved": "https://registry.npmjs.org/next/-/next-16.2.10.tgz", @@ -12264,6 +12305,19 @@ "typescript": ">=4.8.4 <6.1.0" } }, + "node_modules/uglify-js": { + "version": "3.19.3", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.19.3.tgz", + "integrity": "sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==", + "license": "BSD-2-Clause", + "optional": true, + "bin": { + "uglifyjs": "bin/uglifyjs" + }, + "engines": { + "node": ">=0.8.0" + } + }, "node_modules/unbox-primitive": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz", @@ -12589,6 +12643,12 @@ "node": ">=0.10.0" } }, + "node_modules/wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==", + "license": "MIT" + }, "node_modules/wrappy": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", diff --git a/package.json b/package.json index 3f54c45..d7ef884 100644 --- a/package.json +++ b/package.json @@ -19,8 +19,10 @@ "class-variance-authority": "^0.7.1", "clsx": "^2.1.1", "dotenv": "^17.4.2", + "handlebars": "^4.7.9", "html-to-image": "^1.11.13", "lucide-react": "^1.23.0", + "marked": "^18.0.5", "next": "16.2.10", "next-auth": "^5.0.0-beta.31", "next-intl": "^4.13.1", diff --git a/prisma/import-policies.ts b/prisma/import-policies.ts new file mode 100644 index 0000000..785fbab --- /dev/null +++ b/prisma/import-policies.ts @@ -0,0 +1,158 @@ +import { readFileSync, readdirSync } from "node:fs"; +import { join } from "node:path"; +import type { PrismaClient } from "@prisma/client"; + +/** + * Importer für das VDA-ISA-2027-Vorlagenpaket (§6 der Spezifikation). + * Liest die echten .md-Dateien, mapping.json, variables.schema.json, + * Technische-Sicherheits-Baseline.md und Nachweisregister_zentral.md in die + * Policy-Tabellen. Idempotent pro Mandant (löscht + legt neu an). + */ + +type DocType = "LEITLINIE" | "RICHTLINIE" | "VERFAHREN" | "REGISTER"; + +function docCodeFromFile(file: string): string { + return file.split("_")[0]; // "R08_…​.md" → "R08", "VA-03_…​.md" → "VA-03" +} +function titleOf(md: string): string { + const m = md.match(/^#\s+(.+?)\s*$/m); + return m ? m[1].trim() : "(ohne Titel)"; +} +function varGroup(key: string): string { + if (key.startsWith("FLAG_")) return "Feature-Flags"; + if (key.startsWith("ORG_") || key.startsWith("ISMS_")) return "Organisation"; + if (key.startsWith("ROLE_")) return "Rollen"; + if (key.startsWith("DOC_")) return "Metadaten"; + if (key.startsWith("TECH_") || key.startsWith("TOOL_")) return "Technik/Werkzeuge"; + if (/^(PW_|MFA_|SESSION_|ACCOUNT_|RECERT_)/.test(key)) return "IAM-Baseline"; + if (key.startsWith("TLS_") || key.startsWith("CRYPTO_")) return "Krypto-Baseline"; + if (/^(PATCH_|VULN_|MALWARE_|LOG_|BACKUP_|PENTEST_)/.test(key)) return "Betriebs-Baseline"; + return "Sonstige"; +} + +interface SchemaProp { + type?: string; + title?: string; + default?: string | boolean; + example?: string; +} + +export async function importPolicies(prisma: PrismaClient, tenantId: string, seedDir: string) { + // Sauberer Neuimport pro Mandant + await prisma.policyRequirement.deleteMany({ where: { tenantId } }); + await prisma.policyDocument.deleteMany({ where: { tenantId } }); + await prisma.policyVariable.deleteMany({ where: { tenantId } }); + await prisma.policyBaselineParam.deleteMany({ where: { tenantId } }); + await prisma.policyEvidence.deleteMany({ where: { tenantId } }); + + // ── 1. mapping.json → FULFILLS-Rückwärtsmapping vorbereiten ────────────── + const mapping = JSON.parse(readFileSync(join(seedDir, "mapping.json"), "utf-8")) as { + anforderungen: Array<{ + id: string; policy: string; control: string; type: string; + condition: string | null; requirement: string; implementation: string; nachweis_link?: string; + }>; + }; + + // ── 2. Dokumente einlesen (Richtlinien + Verfahren) ────────────────────── + const reqToVas = new Map>(); + const docs: Array<{ code: string; type: DocType; title: string; policyCode: string | null; fulfills: string[]; raw: string; orderIdx: number }> = []; + + const richtDir = join(seedDir, "richtlinien"); + for (const file of readdirSync(richtDir).filter((f) => f.endsWith(".md")).sort()) { + const raw = readFileSync(join(richtDir, file), "utf-8"); + const code = docCodeFromFile(file); + const type: DocType = code === "L00" ? "LEITLINIE" : "RICHTLINIE"; + const orderIdx = code === "L00" ? 0 : parseInt(code.replace(/\D/g, ""), 10); + docs.push({ code, type, title: titleOf(raw), policyCode: null, fulfills: [], raw, orderIdx }); + } + + const verfDir = join(seedDir, "verfahren"); + for (const file of readdirSync(verfDir).filter((f) => f.endsWith(".md")).sort()) { + const raw = readFileSync(join(verfDir, file), "utf-8"); + const code = docCodeFromFile(file); + const fh = raw.match(//); + const fulfills = fh ? fh[1].split(",").map((s) => s.trim()).filter(Boolean) : []; + const policyCode = fh ? fh[2].trim() : null; + for (const req of fulfills) { + if (!reqToVas.has(req)) reqToVas.set(req, new Set()); + reqToVas.get(req)!.add(code); + } + const orderIdx = 100 + parseInt(code.replace(/\D/g, ""), 10); + docs.push({ code, type: "VERFAHREN", title: titleOf(raw), policyCode, fulfills, raw, orderIdx }); + } + + // Register-Dokumente (Baseline + Nachweisregister) mitführen + const baselineRaw = readFileSync(join(seedDir, "Technische-Sicherheits-Baseline.md"), "utf-8"); + const nachweisRaw = readFileSync(join(seedDir, "Nachweisregister_zentral.md"), "utf-8"); + docs.push({ code: "BASELINE", type: "REGISTER", title: titleOf(baselineRaw), policyCode: null, fulfills: [], raw: baselineRaw, orderIdx: 900 }); + docs.push({ code: "NACHWEIS", type: "REGISTER", title: titleOf(nachweisRaw), policyCode: null, fulfills: [], raw: nachweisRaw, orderIdx: 901 }); + + for (const d of docs) { + await prisma.policyDocument.create({ + data: { + tenantId, code: d.code, type: d.type, title: d.title, version: "1.0", status: "FREIGEGEBEN", + policyCode: d.policyCode, fulfills: d.fulfills, rawMarkdown: d.raw, orderIdx: d.orderIdx, + }, + }); + } + + // ── 3. Anforderungen (mapping.json) + vaCodes ──────────────────────────── + for (const a of mapping.anforderungen) { + await prisma.policyRequirement.create({ + data: { + tenantId, reqId: a.id, policyCode: a.policy, control: a.control, obligation: a.type, + condition: a.condition, requirement: a.requirement, implementation: a.implementation, + vaCodes: [...(reqToVas.get(a.id) ?? [])].sort(), nachweisLink: a.nachweis_link ?? null, + }, + }); + } + + // ── 4. Variablen + Feature-Flags (variables.schema.json) ───────────────── + const schema = JSON.parse(readFileSync(join(seedDir, "variables.schema.json"), "utf-8")) as { + properties: Record; required?: string[]; + }; + const required = new Set(schema.required ?? []); + let vi = 0; + for (const [key, prop] of Object.entries(schema.properties)) { + const kind = prop.type === "boolean" ? "boolean" : "string"; + const value = prop.default !== undefined ? String(prop.default) : prop.example !== undefined ? String(prop.example) : kind === "boolean" ? "false" : ""; + await prisma.policyVariable.create({ + data: { tenantId, key, title: prop.title ?? key, kind, groupName: varGroup(key), value, required: required.has(key), orderIdx: vi++ }, + }); + } + + // ── 5. Baseline-Parameter (Technische-Sicherheits-Baseline.md) ─────────── + let section = ""; + let bi = 0; + for (const line of baselineRaw.split("\n")) { + const h = line.match(/^##\s+(.+?)\s*$/); + if (h) { section = h[1].trim(); continue; } + const row = line.match(/^\|\s*(BL-[A-Z]+-\d+)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*$/); + if (row) { + await prisma.policyBaselineParam.create({ + data: { tenantId, blId: row[1], section, name: row[2].trim(), vorgabe: row[3].trim(), orderIdx: bi++ }, + }); + } + } + + // ── 6. Nachweisregister (Nachweisregister_zentral.md) ──────────────────── + for (const line of nachweisRaw.split("\n")) { + const row = line.match(/^\|\s*(\d+)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*$/); + if (!row) continue; + const policyMatch = row[2].match(/\{\{LINK:([^}]+)\}\}/); + await prisma.policyEvidence.create({ + data: { + tenantId, nr: parseInt(row[1], 10), policyCode: policyMatch ? policyMatch[1] : row[2].trim(), + nachweis: row[3].trim(), quelle: row[4].trim(), verantwortlich: row[5].trim(), turnus: row[6].trim(), + }, + }); + } + + const counts = { + documents: docs.length, + requirements: mapping.anforderungen.length, + variables: Object.keys(schema.properties).length, + baseline: bi, + }; + return counts; +} diff --git a/prisma/migrations/20260707132008_policies/migration.sql b/prisma/migrations/20260707132008_policies/migration.sql new file mode 100644 index 0000000..0175d0a --- /dev/null +++ b/prisma/migrations/20260707132008_policies/migration.sql @@ -0,0 +1,136 @@ +-- CreateEnum +CREATE TYPE "PolicyDocType" AS ENUM ('LEITLINIE', 'RICHTLINIE', 'VERFAHREN', 'REGISTER', 'HANDBUCH', 'EIGENES'); + +-- CreateEnum +CREATE TYPE "PolicyStatus" AS ENUM ('ENTWURF', 'IN_FREIGABE', 'FREIGEGEBEN', 'ARCHIVIERT'); + +-- CreateTable +CREATE TABLE "policy_documents" ( + "id" TEXT NOT NULL, + "tenant_id" TEXT NOT NULL, + "code" TEXT NOT NULL, + "type" "PolicyDocType" NOT NULL, + "title" TEXT NOT NULL, + "version" TEXT NOT NULL DEFAULT '1.0', + "status" "PolicyStatus" NOT NULL DEFAULT 'FREIGEGEBEN', + "owner" TEXT, + "policy_code" TEXT, + "fulfills" TEXT[] DEFAULT ARRAY[]::TEXT[], + "raw_markdown" TEXT NOT NULL, + "order_idx" INTEGER NOT NULL DEFAULT 0, + "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + "updated_at" TIMESTAMP(3) NOT NULL, + + CONSTRAINT "policy_documents_pkey" PRIMARY KEY ("id") +); + +-- CreateTable +CREATE TABLE "policy_requirements" ( + "id" TEXT NOT NULL, + "tenant_id" TEXT NOT NULL, + "req_id" TEXT NOT NULL, + "policy_code" TEXT NOT NULL, + "control" TEXT NOT NULL, + "obligation" TEXT NOT NULL, + "condition" TEXT, + "requirement" TEXT NOT NULL, + "implementation" TEXT NOT NULL, + "va_codes" TEXT[] DEFAULT ARRAY[]::TEXT[], + "nachweis_link" TEXT, + "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + + CONSTRAINT "policy_requirements_pkey" PRIMARY KEY ("id") +); + +-- CreateTable +CREATE TABLE "policy_variables" ( + "id" TEXT NOT NULL, + "tenant_id" TEXT NOT NULL, + "key" TEXT NOT NULL, + "title" TEXT NOT NULL, + "kind" TEXT NOT NULL, + "group_name" TEXT, + "value" TEXT NOT NULL, + "required" BOOLEAN NOT NULL DEFAULT false, + "order_idx" INTEGER NOT NULL DEFAULT 0, + "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + "updated_at" TIMESTAMP(3) NOT NULL, + + CONSTRAINT "policy_variables_pkey" PRIMARY KEY ("id") +); + +-- CreateTable +CREATE TABLE "policy_baseline_params" ( + "id" TEXT NOT NULL, + "tenant_id" TEXT NOT NULL, + "bl_id" TEXT NOT NULL, + "section" TEXT NOT NULL, + "name" TEXT NOT NULL, + "vorgabe" TEXT NOT NULL, + "order_idx" INTEGER NOT NULL DEFAULT 0, + "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + + CONSTRAINT "policy_baseline_params_pkey" PRIMARY KEY ("id") +); + +-- CreateTable +CREATE TABLE "policy_evidence" ( + "id" TEXT NOT NULL, + "tenant_id" TEXT NOT NULL, + "nr" INTEGER NOT NULL, + "policy_code" TEXT NOT NULL, + "nachweis" TEXT NOT NULL, + "quelle" TEXT NOT NULL, + "verantwortlich" TEXT NOT NULL, + "turnus" TEXT NOT NULL, + "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + + CONSTRAINT "policy_evidence_pkey" PRIMARY KEY ("id") +); + +-- CreateIndex +CREATE INDEX "policy_documents_tenant_id_idx" ON "policy_documents"("tenant_id"); + +-- CreateIndex +CREATE UNIQUE INDEX "policy_documents_tenant_id_code_key" ON "policy_documents"("tenant_id", "code"); + +-- CreateIndex +CREATE INDEX "policy_requirements_tenant_id_idx" ON "policy_requirements"("tenant_id"); + +-- CreateIndex +CREATE INDEX "policy_requirements_tenant_id_control_idx" ON "policy_requirements"("tenant_id", "control"); + +-- CreateIndex +CREATE UNIQUE INDEX "policy_requirements_tenant_id_req_id_key" ON "policy_requirements"("tenant_id", "req_id"); + +-- CreateIndex +CREATE INDEX "policy_variables_tenant_id_idx" ON "policy_variables"("tenant_id"); + +-- CreateIndex +CREATE UNIQUE INDEX "policy_variables_tenant_id_key_key" ON "policy_variables"("tenant_id", "key"); + +-- CreateIndex +CREATE INDEX "policy_baseline_params_tenant_id_idx" ON "policy_baseline_params"("tenant_id"); + +-- CreateIndex +CREATE UNIQUE INDEX "policy_baseline_params_tenant_id_bl_id_key" ON "policy_baseline_params"("tenant_id", "bl_id"); + +-- CreateIndex +CREATE INDEX "policy_evidence_tenant_id_idx" ON "policy_evidence"("tenant_id"); + + +-- RLS-Policies für die Richtlinien-Tabellen +DO $$ +DECLARE t text; +BEGIN + FOREACH t IN ARRAY ARRAY[ + 'policy_documents','policy_requirements','policy_variables', + 'policy_baseline_params','policy_evidence' + ] LOOP + EXECUTE format('ALTER TABLE %I ENABLE ROW LEVEL SECURITY', t); + EXECUTE format( + 'CREATE POLICY tenant_isolation ON %I USING (tenant_id = current_setting(''app.tenant_id'', true))', + t + ); + END LOOP; +END $$; diff --git a/prisma/schema.prisma b/prisma/schema.prisma index 3226939..598eb0a 100644 --- a/prisma/schema.prisma +++ b/prisma/schema.prisma @@ -655,3 +655,113 @@ model AuditLog { @@index([tenantId, createdAt]) @@map("audit_logs") } + +// ── Richtlinien & Verfahren (VDA-ISA 2027 Vorlagenpaket) ────────────────────── +// Dokumente werden aus ihrer echten Markdown-Vorlage gerendert; Variablen, +// Feature-Flags und Baseline-Parameter sind die eine Pflegestelle (§7). + +enum PolicyDocType { + LEITLINIE // L00 + RICHTLINIE // R01–R14 + VERFAHREN // VA-01–VA-13 + REGISTER // verwaltete Tabellen (Baseline, Nachweisregister, …) + HANDBUCH // Anwender-Handbuch + EIGENES // Word-Upload +} + +enum PolicyStatus { + ENTWURF + IN_FREIGABE + FREIGEGEBEN + ARCHIVIERT +} + +model PolicyDocument { + id String @id @default(cuid()) + tenantId String @map("tenant_id") + code String // L00 | R01..R14 | VA-01..VA-13 | BASELINE | NACHWEIS | ISA_MAPPING + type PolicyDocType + title String + version String @default("1.0") + status PolicyStatus @default(FREIGEGEBEN) + owner String? + policyCode String? @map("policy_code") // bei VA: operationalisierte Richtlinie (R..) + fulfills String[] @default([]) // bei VA: erfüllte Anforderungs-IDs + rawMarkdown String @map("raw_markdown") // Vorlagen-Markdown mit Platzhaltern + orderIdx Int @default(0) @map("order_idx") + createdAt DateTime @default(now()) @map("created_at") + updatedAt DateTime @updatedAt @map("updated_at") + + @@unique([tenantId, code]) + @@index([tenantId]) + @@map("policy_documents") +} + +model PolicyRequirement { + id String @id @default(cuid()) + tenantId String @map("tenant_id") + reqId String @map("req_id") // z. B. 4.1.2-M1 + policyCode String @map("policy_code") // R08 + control String // 4.1.2 + obligation String // MUSS | SOLL + condition String? // FLAG_… oder null + requirement String + implementation String + vaCodes String[] @default([]) @map("va_codes") // operationalisierende Verfahren + nachweisLink String? @map("nachweis_link") + createdAt DateTime @default(now()) @map("created_at") + + @@unique([tenantId, reqId]) + @@index([tenantId]) + @@index([tenantId, control]) + @@map("policy_requirements") +} + +// Wizard-Variablen und Feature-Flags (variables.schema.json) — eine Pflegestelle +model PolicyVariable { + id String @id @default(cuid()) + tenantId String @map("tenant_id") + key String // UPPER_SNAKE, z. B. PW_MIN_LENGTH / FLAG_CLOUD_USED + title String + kind String // string | boolean + groupName String? @map("group_name") + value String // aktueller Wert (Default aus Schema); Flags als "true"/"false" + required Boolean @default(false) + orderIdx Int @default(0) @map("order_idx") + createdAt DateTime @default(now()) @map("created_at") + updatedAt DateTime @updatedAt @map("updated_at") + + @@unique([tenantId, key]) + @@index([tenantId]) + @@map("policy_variables") +} + +model PolicyBaselineParam { + id String @id @default(cuid()) + tenantId String @map("tenant_id") + blId String @map("bl_id") // BL-IAM-01 + section String // "1. Identitäts- und Zugriffsmanagement" + name String + vorgabe String // Vorlagentext (kann {{VARIABLE}} enthalten) + orderIdx Int @default(0) @map("order_idx") + createdAt DateTime @default(now()) @map("created_at") + + @@unique([tenantId, blId]) + @@index([tenantId]) + @@map("policy_baseline_params") +} + +model PolicyEvidence { + id String @id @default(cuid()) + tenantId String @map("tenant_id") + nr Int + policyCode String @map("policy_code") + nachweis String + quelle String + verantwortlich String + turnus String + createdAt DateTime @default(now()) @map("created_at") + + @@index([tenantId]) + @@map("policy_evidence") +} diff --git a/prisma/seed.ts b/prisma/seed.ts index ce73ecc..3e31f5e 100644 --- a/prisma/seed.ts +++ b/prisma/seed.ts @@ -2,7 +2,9 @@ import "dotenv/config"; import { PrismaClient } from "@prisma/client"; import { PrismaPg } from "@prisma/adapter-pg"; import { hash } from "@node-rs/argon2"; +import { join } from "node:path"; import { PERMISSIONS, ROLE_DEFS } from "../src/server/rbac"; +import { importPolicies } from "./import-policies"; /** * Seed: global permission catalog + demo tenant with roles and users. @@ -504,6 +506,22 @@ async function main() { } console.log("✔ 1 Demo-IT-Service mit RACI-Matrix angelegt"); } + + // 10. Richtlinien & Verfahren aus dem VDA-ISA-2027-Vorlagenpaket importieren + const seedDir = join(__dirname, "..", "seed", "isms-vorlagenpaket-v2"); + const pc = await importPolicies(prisma, tenant.id, seedDir); + // Demo-Werte für Variablen ohne Schema-Default (damit die Doku vollständig wirkt) + const demoVars: Record = { + ORG_NAME: "GEFIM Demo GmbH", + ORG_SHORT: "GEFIM", + ISMS_SCOPE: "IT-Betrieb & Softwareentwicklung", + ISMS_SCOPE_DESCRIPTION: "IT-Betrieb, Softwareentwicklung und zugehörige Unterstützungsprozesse am Standort Zentrale", + DOC_DATE: "2026-07-07", + }; + for (const [key, value] of Object.entries(demoVars)) { + await prisma.policyVariable.updateMany({ where: { tenantId: tenant.id, key }, data: { value } }); + } + console.log(`✔ Richtlinienpaket importiert: ${pc.documents} Dokumente, ${pc.requirements} Anforderungen, ${pc.variables} Variablen, ${pc.baseline} Baseline-Parameter`); } main() diff --git a/seed/isms-vorlagenpaket-v2/00_Integrationsleitfaden_Wizard.md b/seed/isms-vorlagenpaket-v2/00_Integrationsleitfaden_Wizard.md new file mode 100644 index 0000000..b6c88fc --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/00_Integrationsleitfaden_Wizard.md @@ -0,0 +1,148 @@ +# Integrationsleitfaden für den Programmierer – ISMS-Vorlagenpaket v2 + +Dieses Dokument beschreibt, wie die Richtlinien-Templates, Variablen, das versteckte Anforderungs-Mapping und die Verlinkungen in den Wizard/das Tool eingebaut werden. Zielgruppe: die Person, die den Wizard implementiert. + +## 1. Paketstruktur + +``` +ISMS-Vorlagenpaket-v2/ +├── 00_Integrationsleitfaden_Wizard.md ← dieses Dokument +├── variables.schema.json ← alle Wizard-Variablen (Single Source of Truth) +├── mapping.json ← Anforderungs-Mapping (REQ/IMPL ↔ ISA-Control ↔ Richtlinie) +├── ISA-Mapping-Matrix.md ← menschenlesbare ISA-Matrix (ersetzt "Bezug zu VDA ISA") +├── Technische-Sicherheits-Baseline.md ← zentrale konkrete Parameter (BL-IDs), einzige Pflegestelle +├── Nachweisregister_zentral.md ← zentrales Nachweis-Template +├── richtlinien/ +│ ├── L00_Informationssicherheitsleitlinie.md +│ └── R01 … R14 +└── verfahren/ + └── VA-01 … VA-13 ← Verfahrensanweisungen (Abläufe zu den Richtlinien) +``` + +**Richtlinie vs. Verfahren:** Die Richtlinie (R01–R14) sagt *was* gilt und *wie* es grundsätzlich umgesetzt ist. Die Verfahrensanweisung (VA-01–VA-13) beschreibt den konkreten *Ablauf* (Auslöser → Schritte → RACI → Ergebnis/Nachweis). Jedes Verfahren trägt einen Hidden-Anker ``; die erfüllten Anforderungen sind zusätzlich je Eintrag in `mapping.json` (`verfahren`-Liste) und je Anforderung (`verfahren`-Feld) hinterlegt. So fließen Verfahren automatisch in die Nachweisdokumentation ein. + +## 2. Vier Bausteine im Überblick + +1. **Variablen** (`{{NAME}}`, UPPER_SNAKE) – organisationsspezifische Werte, aus `variables.schema.json`. +2. **Bedingungsblöcke** (`{{#if FLAG_X}} … {{/if}}`) – blenden Anforderungen/Abschnitte je nach Feature-Flag und Reifegrad ein/aus. +3. **Hidden-Anker** (`` / ``) – unsichtbare IDs je Einzelanforderung; Grundlage für Nachweis-Mapping und Deep-Links. +4. **Link-Platzhalter** (`{{LINK:ZIEL}}`) – Verweise zwischen Dokumenten und zu Nachweisen, die das Tool zur Laufzeit auflöst. + +## 3. Templating-Konvention (Handlebars-kompatibel) + +| Konstrukt | Bedeutung | +|-----------|-----------| +| `{{ORG_NAME}}` | Variablen-Einsetzung | +| `{{#if FLAG_CLOUD_USED}} … {{/if}}` | bedingter Block (Feature-Flag) | +| `{{#if FLAG_INCLUDE_SHOULD}} … {{/if}}` | SOLL-Anforderungen ein-/ausblenden (Reifegrad) | +| `[MUSS]` / `[SOLL]` | Text-Kennzeichnung der Anforderungsstufe | +| `` | Hidden-Anker vor einer Anforderung | +| `` | Hidden-Anker vor dem zugehörigen Umsetzungstext | +| `{{LINK:R02}}` | Link-Platzhalter (siehe Abschnitt 6) | + +Beim Rendern: Variablen einsetzen, `{{#if}}`-Blöcke nach Kontext auflösen, `{{LINK:…}}` in echte Links übersetzen. Die ``-Anker **im Dokument belassen** (sie sind im Lesemodus unsichtbar) – das Tool braucht sie zur Laufzeit für Deep-Links und Nachweiszuordnung. Für den PDF-/Druckexport können sie entfernt werden. + +## 4. Aufbau einer thematischen Richtlinie (R01–R14) + +``` +### 3.1 (ISA 1.2.1) + +**Anforderung** + +- **[MUSS]** +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +``` + +Jede Anforderung (`REQ`) hat genau eine Umsetzung (`IMPL`) mit identischer ID. Ausnahme **L00** (Leitlinie): kombiniertes Dokument, dort ist `IMPL`-Anker = `REQ`-Anker (in `mapping.json` bereits so hinterlegt). + +**ID-Schema:** `-`, z. B. `1.2.1-M1`, `5.2.9-S1`. MUSS und SOLL werden getrennt nummeriert. + +## 5. `mapping.json` – das versteckte Anforderungs-Mapping + +Zentrale Datei, die je Einzelanforderung Metadaten bündelt. Aufbau je Eintrag: + +```json +{ + "id": "1.2.1-M1", + "policy": "R01", + "policy_file": "R01_ISMS-Organisation-und-Rollen.md", + "control": "1.2.1", + "type": "MUSS", + "req_anchor": "REQ 1.2.1-M1", + "impl_anchor": "IMPL 1.2.1-M1", + "condition": null, + "requirement": "Der Geltungsbereich des ISMS … ist bestimmt und dokumentiert.", + "implementation": "Der ISMS-Geltungsbereich ist im ISMS-Tool … dokumentiert.", + "link": "{{LINK:R01#1.2.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}" +} +``` + +- `condition` = `null` (immer aktiv), `"FLAG_INCLUDE_SHOULD"` (nur bei SOLL) oder ein Feature-Flag. Anforderungen, deren Bedingung im Kontext `false` ist, erscheinen im Dokument nicht und werden in der Nachweisdoku übersprungen. +- **Reading-Mode:** Der Anwender sieht nur Anforderung + Umsetzung, keine IDs. Das Tool blendet je Anforderung eine dezente Verlinkung („Nachweise") ein, die über `nachweis_link` bzw. die ID auf den Nachweiseintrag zeigt. + +## 6. Link-Platzhalter `{{LINK:ZIEL}}` auflösen + +Das Tool ersetzt Platzhalter durch echte Deep-Links (unabhängig von Dateipfaden): + +| Platzhalter | Ziel | +|-------------|------| +| `{{LINK:L00}}` … `{{LINK:R14}}` | jeweiliges Richtlinien-Dokument | +| `{{LINK:R01#1.2.1}}` | Sprungziel auf Control-Abschnitt (Anker aus ID ableitbar) | +| `{{LINK:NACHWEISREGISTER}}` | zentrales Nachweisregister | +| `{{LINK:ISA_MAPPING}}` | ISA-Mapping-Matrix | +| `{{LINK:BASELINE}}` | Technische Sicherheits-Baseline | +| `{{LINK:VA-01}}` … `{{LINK:VA-13}}` | Verfahrensanweisungen | + +**Konkrete Parameter (Passwort, Fristen, Krypto …):** liegen ausschließlich in `Technische-Sicherheits-Baseline.md` und im Schema (Variablen wie `PW_MIN_LENGTH`, `LOG_RETENTION`). Die Umsetzungstexte referenzieren die Baseline-IDs (`BL-IAM-01` …) und rendern die Werte über dieselben Variablen – so gibt es genau eine Pflegestelle je Wert. + +Empfehlung: eine Auflösungstabelle `DOC_ID → interne Tool-URL` pflegen; unbekannte Ziele als Warnung loggen. + +## 7. Wizard-Ablauf (empfohlen) + +1. **Schema laden** (`variables.schema.json`) → Eingabemasken erzeugen. Reihenfolge: Organisation → Geltungsbereich → Rollen → ISMS-Tool → Feature-Flags → Reifegrad → tech. Lösungen (TECH_*) → Metadaten. +2. **Kontext validieren** (Pflichtfelder `required`, Defaults übernehmen). +3. **Rendern** je Dokument: Variablen einsetzen, `{{#if}}` auflösen, `{{LINK}}` übersetzen, Hidden-Anker belassen. +4. **Mapping filtern**: aus `mapping.json` alle Anforderungen entfernen, deren `condition` im Kontext `false` ist → ergibt die **aktive Anforderungsliste** dieses Mandanten. +5. **Speichern/Verknüpfen** im Tool. + +### Minimal-Render (Node/Handlebars) + +```js +import Handlebars from "handlebars"; +const render = (tpl, ctx) => + Handlebars.compile(tpl, { noEscape: true })(ctx) // Hidden-Anker bleiben erhalten + .replace(/\{\{LINK:([^}]+)\}\}/g, (_, id) => resolveLink(id)); +``` + +## 8. Nachweisdokumentation aus dem Mapping bauen + +Genau der Zweck des Mappings: Aus `mapping.json` + Nachweiseinträgen lässt sich per Knopfdruck eine Nachweisdoku erzeugen. Vorgehen: + +1. Aktive Anforderungen ermitteln (Abschnitt 7, Schritt 4). +2. Je Anforderung: `id`, `type`, `requirement`, `implementation`, Link zur Richtlinie (`link`) und zum Nachweis (`nachweis_link`) zusammenstellen. +3. Nachweise aus {{TOOL_NAME}} anhängen (Owner/Turnus aus `Nachweisregister_zentral.md`). +4. Ausgabe als Tabelle/Export (z. B. für das VDA-ISA-Assessment: Spalten „Implementation description" = `implementation`, „Reference documentation" = Nachweis-Link). + +So entsteht die Assessment-Sicht, ohne dass der Anwender im Lesemodus mit IDs konfrontiert wird. + +## 9. Cross-Links zwischen Dokumenten + +Jede Richtlinie enthält einen Abschnitt **„Verwandte Dokumente"** mit `{{LINK:…}}` auf Leitlinie, ISA-Matrix, Nachweisregister und thematisch verwandte Richtlinien. Innerhalb der Umsetzungstexte stehen zusätzlich kontextbezogene Verweise (z. B. R08 verweist bei Zugriffsrechten auf R10). Das Tool löst alle Platzhalter einheitlich auf. + +## 10. Pflege & Konsistenz + +- **Neue Variable:** zuerst in `variables.schema.json`, dann im Template verwenden. +- **Neue Anforderung/Control:** Anforderung + Umsetzung im Template ergänzen (mit `REQ`/`IMPL`-Ankern) **und** Eintrag in `mapping.json`; ISA-Matrix neu erzeugen. +- **Konsistenzcheck vor Auslieferung (empfohlen):** (a) jeder `{{NAME}}` existiert im Schema; (b) jeder `REQ`/`IMPL`-Anker im Dokument hat einen `mapping.json`-Eintrag und umgekehrt; (c) jedes `{{LINK:…}}`-Ziel ist auflösbar. Die mitgelieferten Generatoren (`_generate_v2.py`, `_matrix.py`) sind die Referenzimplementierung dieser Regeln. + +## 11. Reifegrad + +`FLAG_INCLUDE_SHOULD = true` → Reifegrad 3 (MUSS + SOLL). `false` → reines MUSS-Set. Höhere Reifegrade (4/5) lassen sich später als zusätzliche `condition`-Stufe (z. B. `FLAG_LEVEL_4`) ergänzen, ohne die Struktur zu ändern. diff --git a/seed/isms-vorlagenpaket-v2/ISA-Mapping-Matrix.md b/seed/isms-vorlagenpaket-v2/ISA-Mapping-Matrix.md new file mode 100644 index 0000000..540adbe --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/ISA-Mapping-Matrix.md @@ -0,0 +1,181 @@ +# ISA-Mapping-Matrix - VDA ISA 2027 (Information Security) + +Zentrale Zuordnung: **ISA-Control -> Richtlinie -> einzelne Anforderungen (MUSS/SOLL)**. Ersetzt den früheren Abschnitt 'Bezug zu VDA ISA' in den einzelnen Richtlinien. Das Tool verlinkt von jeder Anforderung (Hidden-Anker, siehe `mapping.json`) auf diese Matrix und auf das Nachweisregister ({{LINK:NACHWEISREGISTER}}). + +| ISA | Richtlinie | MUSS | SOLL | Anforderungs-IDs | +|-----|-----------|------|------|------------------| +| 1.1.1 | {{LINK:L00}} Informationssicherheitsleitlinie | 5 | 2 | M1, M2, M3, M4, M5, S1, S4 | +| 1.2.1 | {{LINK:R01}} ISMS-Organisation und Rollen | 3 | 1 | M1, M2, M3, S1 | +| 1.2.2 | {{LINK:R01}} ISMS-Organisation und Rollen | 2 | 2 | M1, M2, S1, S2 | +| 1.2.3 | {{LINK:R01}} ISMS-Organisation und Rollen | 2 | 1 | M1, M2, S1 | +| 1.3.1 | {{LINK:R02}} Asset- und Klassifizierung | 2 | 1 | M1, M2, S1 | +| 1.3.2 | {{LINK:R02}} Asset- und Klassifizierung | 2 | 1 | M1, M2, S1 | +| 1.3.3 | {{LINK:R02}} Asset- und Klassifizierung | 1 | 1 | M1, S1 | +| 1.3.4 | {{LINK:R02}} Asset- und Klassifizierung | 1 | 1 | M1, S1 | +| 1.4.1 | {{LINK:R03}} Risikomanagement und Audit | 3 | 1 | M1, M2, M3, S1 | +| 1.5.1 | {{LINK:R03}} Risikomanagement und Audit | 1 | 1 | M1, S1 | +| 1.5.2 | {{LINK:R03}} Risikomanagement und Audit | 1 | 1 | M1, S1 | +| 1.6.1 | {{LINK:R04}} Incident, Notfall und Kontinuität | 2 | 1 | M1, M2, S1 | +| 1.6.2 | {{LINK:R04}} Incident, Notfall und Kontinuität | 2 | 2 | M1, M2, S1, S2 | +| 1.6.3 | {{LINK:R04}} Incident, Notfall und Kontinuität | 1 | 1 | M1, S1 | +| 5.2.8 | {{LINK:R04}} Incident, Notfall und Kontinuität | 1 | 1 | M1, S1 | +| 2.1.1 | {{LINK:R05}} Personalsicherheit und Awareness | 1 | 1 | M1, S1 | +| 2.1.2 | {{LINK:R05}} Personalsicherheit und Awareness | 1 | 1 | M1, S1 | +| 2.1.3 | {{LINK:R05}} Personalsicherheit und Awareness | 1 | 1 | M1, S1 | +| 2.1.4 | {{LINK:R06}} Mobiles Arbeiten und mobile Geräte | 2 | 1 | M1, M2, S1 | +| 3.1.4 | {{LINK:R06}} Mobiles Arbeiten und mobile Geräte | 2 | 1 | M1, M2, S1 | +| 3.1.1 | {{LINK:R07}} Physische Sicherheit | 2 | 1 | M1, M2, S1 | +| 3.1.3 | {{LINK:R07}} Physische Sicherheit | 1 | 1 | M1, S1 | +| 4.1.1 | {{LINK:R08}} Identitäts- und Zugriffsmanagement | 1 | 1 | M1, S1 | +| 4.1.2 | {{LINK:R08}} Identitäts- und Zugriffsmanagement | 2 | 1 | M1, M2, S1 | +| 4.1.3 | {{LINK:R08}} Identitäts- und Zugriffsmanagement | 1 | 1 | M1, S1 | +| 4.2.1 | {{LINK:R08}} Identitäts- und Zugriffsmanagement | 2 | 1 | M1, M2, S1 | +| 5.1.1 | {{LINK:R09}} Kryptografie und Übertragung | 2 | 1 | M1, M2, S1 | +| 5.1.2 | {{LINK:R09}} Kryptografie und Übertragung | 1 | 1 | M1, S1 | +| 5.2.1 | {{LINK:R10}} Betriebssicherheit | 1 | 0 | M1 | +| 5.2.2 | {{LINK:R10}} Betriebssicherheit | 1 | 1 | M1, S1 | +| 5.2.3 | {{LINK:R10}} Betriebssicherheit | 1 | 1 | M1, S1 | +| 5.2.4 | {{LINK:R10}} Betriebssicherheit | 1 | 1 | M1, S1 | +| 5.2.5 | {{LINK:R10}} Betriebssicherheit | 1 | 1 | M1, S1 | +| 5.2.6 | {{LINK:R10}} Betriebssicherheit | 1 | 0 | M1 | +| 5.2.7 | {{LINK:R10}} Betriebssicherheit | 2 | 1 | M1, M2, S1 | +| 5.2.9 | {{LINK:R10}} Betriebssicherheit | 2 | 1 | M1, M2, S1 | +| 5.3.1 | {{LINK:R11}} Sichere Beschaffung und Entwicklung | 2 | 1 | M1, M2, S1 | +| 5.3.2 | {{LINK:R11}} Sichere Beschaffung und Entwicklung | 1 | 0 | M1 | +| 5.3.3 | {{LINK:R11}} Sichere Beschaffung und Entwicklung | 1 | 1 | M1, S1 | +| 5.3.4 | {{LINK:R12}} Cloud-, KI- und externe IT-Dienste | 2 | 1 | M1, M2, S1 | +| 5.3.4-KI | {{LINK:R12}} Cloud-, KI- und externe IT-Dienste | 3 | 1 | KI-M1, KI-M2, KI-M3, KI-S1 | +| 6.1.1 | {{LINK:R13}} Lieferanten- und Dienstleistersteuerung | 2 | 1 | M1, M2, S1 | +| 6.1.2 | {{LINK:R13}} Lieferanten- und Dienstleistersteuerung | 1 | 1 | M1, S1 | +| 6.1.3 | {{LINK:R13}} Lieferanten- und Dienstleistersteuerung | 1 | 1 | M1, S1 | +| 7.1.1 | {{LINK:R14}} Compliance und Datenschutz | 1 | 1 | M1, S1 | +| 7.1.2 | {{LINK:R14}} Compliance und Datenschutz | 2 | 1 | M1, M2, S1 | + +**Summe:** 120 Anforderungen (MUSS 74, SOLL 46) ueber 46 Controls und 15 Dokumente. + +> Hinweis zu 3.1.2: In der ISA 2027 als 'Superseded by 1.6.3, 5.2.8 und 5.2.9' entfallen - abgedeckt ueber {{LINK:R04}} und {{LINK:R10}}. + +## Detailzuordnung je Anforderung + +| ID | Typ | Richtlinie | Anforderung (Kurz) | Bedingung | +|----|-----|-----------|--------------------|-----------| +| 1.1.1-M1 | MUSS | L00 | Die Anforderungen der Informationssicherheit sind bestimmt, dokumentiert und an ... | - | +| 1.1.1-M2 | MUSS | L00 | Eine Leitlinie existiert und ist durch die Leitung genehmigt. | - | +| 1.1.1-M3 | MUSS | L00 | Die Leitlinie benennt Ziele und die Bedeutung der Informationssicherheit. | - | +| 1.1.1-M4 | MUSS | L00 | Die Leitlinie wird den Mitarbeitenden in geeigneter Form zur Verfügung gestellt. | - | +| 1.1.1-M5 | MUSS | L00 | Mitarbeitende und externe Partner werden über relevante Änderungen informiert. | - | +| 1.1.1-S1 | SOLL | L00 | Die Anforderungen basieren auf der Strategie der Organisation; Gesetze und Vertr... | FLAG_INCLUDE_SHOULD | +| 1.1.1-S4 | SOLL | L00 | Regelmaessige Überprüfung und ggf. Revision der Leitlinie. | FLAG_INCLUDE_SHOULD | +| 1.2.1-M1 | MUSS | R01 | Der Geltungsbereich des ISMS (Organisation, Standorte, Prozesse) ist bestimmt un... | - | +| 1.2.1-M2 | MUSS | R01 | Das ISMS wird durch die Leitung initiiert, gesteuert und überwacht; erforderlich... | - | +| 1.2.1-M3 | MUSS | R01 | Die Wirksamkeit des ISMS wird regelmäßig durch die Leitung bewertet (Managementb... | - | +| 1.2.1-S1 | SOLL | R01 | Informationssicherheitsziele sind messbar formuliert und werden nachverfolgt (KP... | FLAG_INCLUDE_SHOULD | +| 1.2.2-M1 | MUSS | R01 | Verantwortlichkeiten für Informationssicherheit sind definiert, zugewiesen und d... | - | +| 1.2.2-M2 | MUSS | R01 | Eine für Informationssicherheit verantwortliche Rolle ist benannt, verfügt über ... | - | +| 1.2.2-S1 | SOLL | R01 | In Konflikt stehende Aufgaben und Verantwortungsbereiche sind getrennt (Funktion... | FLAG_INCLUDE_SHOULD | +| 1.2.2-S2 | SOLL | R01 | Kontakte zu relevanten Behörden und Interessengruppen werden gepflegt. | FLAG_INCLUDE_SHOULD | +| 1.2.3-M1 | MUSS | R01 | Projekte werden unter Berücksichtigung ihres Informationssicherheitsbedarfs klas... | - | +| 1.2.3-M2 | MUSS | R01 | In Projekten werden Informationssicherheitsanforderungen ermittelt und berücksic... | - | +| 1.2.3-S1 | SOLL | R01 | Verfahren und Kriterien zur Klassifizierung von Projekten sind dokumentiert und ... | FLAG_INCLUDE_SHOULD | +| 1.3.1-M1 | MUSS | R02 | Informationswerte und weitere Assets, die Informationen verarbeiten, sind identi... | - | +| 1.3.1-M2 | MUSS | R02 | Für jedes Asset ist ein Verantwortlicher (Owner) benannt. | - | +| 1.3.1-S1 | SOLL | R02 | Ein Katalog der relevanten Informationswerte wird gepflegt und regelmäßig aktual... | FLAG_INCLUDE_SHOULD | +| 1.3.2-M1 | MUSS | R02 | Informationswerte sind nach Schutzbedarf (Vertraulichkeit, Integrität, Verfügbar... | - | +| 1.3.2-M2 | MUSS | R02 | Abhängig von der Klassifizierung sind Vorgaben zu Kennzeichnung, Handhabung, Spe... | - | +| 1.3.2-S1 | SOLL | R02 | Die Klassifizierung wird bei wesentlichen Aenderungen überprüft und angepasst. | FLAG_INCLUDE_SHOULD | +| 1.3.3-M1 | MUSS | R02 | Es ist sichergestellt, dass nur bewertete und freigegebene externe Hardware/IT-K... | - | +| 1.3.3-S1 | SOLL | R02 | Nicht freigegebene Geräte werden technisch unterbunden. | FLAG_INCLUDE_SHOULD | +| 1.3.4-M1 | MUSS | R02 | Es ist sichergestellt, dass nur bewertete und freigegebene Software eingesetzt w... | - | +| 1.3.4-S1 | SOLL | R02 | Die Installation nicht freigegebener Software wird technisch eingeschränkt. | FLAG_INCLUDE_SHOULD | +| 1.4.1-M1 | MUSS | R03 | Es existiert ein dokumentiertes Verfahren zur Identifikation, Analyse, Bewertung... | - | +| 1.4.1-M2 | MUSS | R03 | Risiken werden in einem Risikoregister erfasst; Behandlungsoptionen und Maßnahme... | - | +| 1.4.1-M3 | MUSS | R03 | Die Risikobewertung wird regelmäßig und anlassbezogen aktualisiert; die Risikoak... | - | +| 1.4.1-S1 | SOLL | R03 | Kriterien für Eintrittswahrscheinlichkeit, Schadenshöhe und Akzeptanzschwellen s... | FLAG_INCLUDE_SHOULD | +| 1.5.1-M1 | MUSS | R03 | Die Einhaltung der Informationssicherheitsvorgaben wird regelmäßig geprüft. | - | +| 1.5.1-S1 | SOLL | R03 | Ein Auditprogramm mit Umfang, Turnus und Verantwortlichkeiten ist etabliert; Fes... | FLAG_INCLUDE_SHOULD | +| 1.5.2-M1 | MUSS | R03 | Das ISMS wird durch eine unabhängige Stelle überprüft. | - | +| 1.5.2-S1 | SOLL | R03 | Ergebnisse fließen in die Managementbewertung und den Verbesserungsprozess ein. | FLAG_INCLUDE_SHOULD | +| 1.6.1-M1 | MUSS | R04 | Sicherheitsrelevante Ereignisse und Beobachtungen können über einen definierten ... | - | +| 1.6.1-M2 | MUSS | R04 | Der Meldeweg ist bekannt gemacht und niedrigschwellig erreichbar. | - | +| 1.6.1-S1 | SOLL | R04 | Meldungen werden zentral erfasst und kategorisiert. | FLAG_INCLUDE_SHOULD | +| 1.6.2-M1 | MUSS | R04 | Gemeldete Sicherheitsereignisse werden bewertet, priorisiert, behandelt und doku... | - | +| 1.6.2-M2 | MUSS | R04 | Verantwortlichkeiten und Eskalationswege für die Vorfallsbehandlung sind definie... | - | +| 1.6.2-S1 | SOLL | R04 | Erkenntnisse aus Vorfällen werden ausgewertet (Lessons Learned) und führen zu Ve... | FLAG_INCLUDE_SHOULD | +| 1.6.2-S2 | SOLL | R04 | Meldepflichten (z. B. an Kunden/OEM, Behörden) sind berücksichtigt. | FLAG_INCLUDE_SHOULD | +| 1.6.3-M1 | MUSS | R04 | Die Organisation ist auf die Bewältigung von Krisensituationen vorbereitet (Roll... | - | +| 1.6.3-S1 | SOLL | R04 | Krisen-/Notfallpläne werden regelmäßig geübt und aktualisiert. | FLAG_INCLUDE_SHOULD | +| 5.2.8-M1 | MUSS | R04 | Für kritische IT-Dienste besteht eine Kontinuitätsplanung (Wiederanlaufziele, Ve... | - | +| 5.2.8-S1 | SOLL | R04 | Wiederanlaufmaßnahmen werden regelmäßig getestet; Ergebnisse werden dokumentiert... | FLAG_INCLUDE_SHOULD | +| 2.1.1-M1 | MUSS | R05 | Für sicherheitsrelevante/sensible Tätigkeiten ist die erforderliche Qualifikatio... | - | +| 2.1.1-S1 | SOLL | R05 | Anforderungen an Positionen sind beschrieben; angemessene Überprüfungen erfolgen... | FLAG_INCLUDE_SHOULD | +| 2.1.2-M1 | MUSS | R05 | Alle Beschäftigten sind vertraglich zur Einhaltung der Informationssicherheit un... | - | +| 2.1.2-S1 | SOLL | R05 | Verpflichtungen gelten auch nach Beendigung des Arbeitsverhältnisses fort und um... | FLAG_INCLUDE_SHOULD | +| 2.1.3-M1 | MUSS | R05 | Beschäftigte werden hinsichtlich Informationssicherheit sensibilisiert und gesch... | - | +| 2.1.3-S1 | SOLL | R05 | Schulungsinhalte sind rollenspezifisch; die Wirksamkeit wird überprüft (z. B. Ph... | FLAG_INCLUDE_SHOULD | +| 2.1.4-M1 | MUSS | R06 | Mobiles Arbeiten ist geregelt (zulässige Orte, Umgang mit Informationen, Absiche... | - | +| 2.1.4-M2 | MUSS | R06 | Der Zugriff auf Unternehmensinformationen erfolgt ausschließlich über gesicherte... | - | +| 2.1.4-S1 | SOLL | R06 | Sichtschutz, Clean-Desk/Clean-Screen und Regeln für öffentliche Umgebungen sind ... | FLAG_INCLUDE_SHOULD | +| 3.1.4-M1 | MUSS | R06 | Der Umgang mit mobilen IT-Geräten und mobilen Datenträgern ist geregelt (Verschl... | - | +| 3.1.4-M2 | MUSS | R06 | Mobile Geräte sind verschlüsselt und können bei Verlust gesperrt/gelöscht werden... | - | +| 3.1.4-S1 | SOLL | R06 | Der Einsatz privater Geräte (BYOD) ist geregelt oder untersagt; Wechseldatenträg... | FLAG_INCLUDE_SHOULD | +| 3.1.1-M1 | MUSS | R07 | Sicherheitszonen sind definiert und der Zutritt zu schützenswerten Bereichen ist... | - | +| 3.1.1-M2 | MUSS | R07 | Zutrittsrechte werden nach Bedarf vergeben, dokumentiert und bei Wegfall entzoge... | - | +| 3.1.1-S1 | SOLL | R07 | Zutritte werden protokolliert; Besucher werden begleitet; technische Schutzmaßna... | FLAG_INCLUDE_SHOULD | +| 3.1.3-M1 | MUSS | R07 | Der Umgang mit unterstützenden Assets (z. B. Verkabelung, Strom-/Klimaversorgung... | - | +| 3.1.3-S1 | SOLL | R07 | Versorgungseinrichtungen werden gewartet und überwacht; Redundanzen bestehen für... | FLAG_INCLUDE_SHOULD | +| 4.1.1-M1 | MUSS | R08 | Der Einsatz von Identifikationsmitteln (Benutzerkennungen, Token, Zertifikate) i... | - | +| 4.1.1-S1 | SOLL | R08 | Ausgabe, Rücknahme und Sperrung von Identifikationsmitteln sind dokumentiert. | FLAG_INCLUDE_SHOULD | +| 4.1.2-M1 | MUSS | R08 | Der Zugang zu IT-Diensten und IT-Systemen ist durch sichere Authentifizierungsve... | - | +| 4.1.2-M2 | MUSS | R08 | Für erhöhten Schutzbedarf und Fernzugriffe wird Mehr-Faktor-Authentifizierung (M... | - | +| 4.1.2-S1 | SOLL | R08 | Passwortanforderungen, Sperrmechanismen und Sitzungsverwaltung sind definiert. | FLAG_INCLUDE_SHOULD | +| 4.1.3-M1 | MUSS | R08 | Benutzerkonten und Anmeldeinformationen werden sicher verwaltet (Erstellung, Aen... | - | +| 4.1.3-S1 | SOLL | R08 | Privilegierte und technische Konten werden gesondert verwaltet und überwacht. | FLAG_INCLUDE_SHOULD | +| 4.2.1-M1 | MUSS | R08 | Zugriffsrechte werden nach dem Minimalprinzip (need-to-know / least privilege) v... | - | +| 4.2.1-M2 | MUSS | R08 | Zugriffsrechte werden bei Wegfall des Bedarfs entzogen und regelmäßig überprüft ... | - | +| 4.2.1-S1 | SOLL | R08 | Berechtigungen werden über Rollen vergeben; normale Konten erhalten keine privil... | FLAG_INCLUDE_SHOULD | +| 5.1.1-M1 | MUSS | R09 | Der Einsatz von Kryptografie ist geregelt; zulässige Verfahren und Schlüsselläng... | - | +| 5.1.1-M2 | MUSS | R09 | Schlüssel werden über ihren gesamten Lebenszyklus sicher verwaltet. | - | +| 5.1.1-S1 | SOLL | R09 | Ein Kryptokonzept ist dokumentiert und eine PKI/Zertifikatsverwaltung ist etabli... | FLAG_INCLUDE_SHOULD | +| 5.1.2-M1 | MUSS | R09 | Informationen werden abhängig vom Schutzbedarf bei der Übertragung geschützt (z... | - | +| 5.1.2-S1 | SOLL | R09 | Regeln für sichere Übertragungswege (E-Mail-Verschlüsselung, sichere Dateiübert... | FLAG_INCLUDE_SHOULD | +| 5.2.1-M1 | MUSS | R10 | Aenderungen an IT-Systemen werden geregelt beantragt, bewertet, getestet, genehm... | - | +| 5.2.2-M1 | MUSS | R10 | Entwicklungs-, Test- und Produktionsumgebungen sind getrennt. | - | +| 5.2.2-S1 | SOLL | R10 | Produktivdaten werden nicht ungeschützt in Test-/Entwicklungsumgebungen verwende... | FLAG_INCLUDE_SHOULD | +| 5.2.3-M1 | MUSS | R10 | Anforderungen zum Schutz vor Schadsoftware sind bestimmt; technische und organis... | - | +| 5.2.3-S1 | SOLL | R10 | Schutzsoftware wird automatisch aktualisiert; unnötige Netzwerkdienste sind deak... | FLAG_INCLUDE_SHOULD | +| 5.2.4-M1 | MUSS | R10 | Sicherheitsrelevante Ereignisse werden protokolliert und ausgewertet. | - | +| 5.2.4-S1 | SOLL | R10 | Protokolle sind vor Manipulation geschützt; Aufbewahrungsfristen sind definiert. | FLAG_INCLUDE_SHOULD | +| 5.2.5-M1 | MUSS | R10 | Schwachstellen werden identifiziert und risikoorientiert behoben (Patch-Manageme... | - | +| 5.2.5-S1 | SOLL | R10 | Es besteht ein regelmäßiges Schwachstellen-Scanning; kritische Patches werden pr... | FLAG_INCLUDE_SHOULD | +| 5.2.6-M1 | MUSS | R10 | IT-Systeme und Dienste werden technisch überprüft (z. B. Systemhärtung, Penetrat... | - | +| 5.2.7-M1 | MUSS | R10 | Das Netzwerk wird gesteuert und abgesichert (Segmentierung, Zugangskontrolle, Ab... | - | +| 5.2.7-M2 | MUSS | R10 | Produktions-/OT-Netze sind von Office-Netzen getrennt und besonders abgesichert. | FLAG_OT_USED | +| 5.2.7-S1 | SOLL | R10 | Ein aktueller Netzplan und ein Segmentierungskonzept liegen vor. | FLAG_INCLUDE_SHOULD | +| 5.2.9-M1 | MUSS | R10 | Daten und IT-Dienste werden gesichert; Wiederherstellung ist geregelt. | - | +| 5.2.9-M2 | MUSS | R10 | Wiederherstellungstests werden regelmäßig durchgeführt. | - | +| 5.2.9-S1 | SOLL | R10 | Backups werden geschützt/ausgelagert aufbewahrt (z. B. offline/immutable). | FLAG_INCLUDE_SHOULD | +| 5.3.1-M1 | MUSS | R11 | Bei Beschaffung oder Weiterentwicklung von IT-Systemen werden Informationssicher... | - | +| 5.3.1-M2 | MUSS | R11 | Für die Eigenentwicklung gelten Vorgaben für sichere Entwicklung (Secure Coding,... | FLAG_DEV_INHOUSE | +| 5.3.1-S1 | SOLL | R11 | Sicherheitsanforderungen sind Bestandteil des Beschaffungs-/Entwicklungsprozesse... | FLAG_INCLUDE_SHOULD | +| 5.3.2-M1 | MUSS | R11 | Sicherheitsanforderungen an Netzdienste (intern und extern) sind definiert. | - | +| 5.3.3-M1 | MUSS | R11 | Rückgabe und sichere Entfernung/Löschung von Informationen und Assets sind gereg... | - | +| 5.3.3-S1 | SOLL | R11 | Löschverfahren entsprechen dem Schutzbedarf; Löschungen werden nachgewiesen. | FLAG_INCLUDE_SHOULD | +| 5.3.4-M1 | MUSS | R12 | Bei geteilten externen IT-Diensten ist durch wirksame Mandantentrennung sicherge... | - | +| 5.3.4-M2 | MUSS | R12 | Cloud-Dienste werden vor Nutzung bewertet und freigegeben; nur freigegebene Dien... | FLAG_CLOUD_USED | +| 5.3.4-S1 | SOLL | R12 | Das Segregationskonzept des Anbieters ist dokumentiert und wird bei Aenderungen ... | FLAG_INCLUDE_SHOULD | +| 5.3.4-KI-M1 | MUSS | R12 | Der Einsatz von KI-/GenAI-Diensten ist geregelt; es werden nur freigegebene Dien... | - | +| 5.3.4-KI-M2 | MUSS | R12 | Die Eingabe vertraulicher oder personenbezogener Informationen in nicht freigege... | - | +| 5.3.4-KI-M3 | MUSS | R12 | Bei freigegebenen KI-Diensten ist geklärt, ob Eingaben zum Training genutzt werd... | - | +| 5.3.4-KI-S1 | SOLL | R12 | Ergebnisse werden vor geschäftskritischer Verwendung geprüft (Human-in-the-Loop)... | FLAG_INCLUDE_SHOULD | +| 6.1.1-M1 | MUSS | R13 | Informationssicherheitsanforderungen an Auftragnehmer/Lieferanten sind ermittelt... | - | +| 6.1.1-M2 | MUSS | R13 | Lieferanten werden risikoorientiert bewertet. | - | +| 6.1.1-S1 | SOLL | R13 | Die Einhaltung der Anforderungen wird regelmäßig überprüft (z. B. Nachweise, Aud... | FLAG_INCLUDE_SHOULD | +| 6.1.2-M1 | MUSS | R13 | Der Austausch von Informationen mit Externen ist durch Vertraulichkeitsvereinbar... | - | +| 6.1.2-S1 | SOLL | R13 | NDA-Vorlagen sind standardisiert; Geltungsdauer und Rückgabe-/Löschpflichten sin... | FLAG_INCLUDE_SHOULD | +| 6.1.3-M1 | MUSS | R13 | Verantwortlichkeiten zwischen der Organisation und externen IT-Dienstleistern si... | FLAG_EXTERNAL_IT | +| 6.1.3-S1 | SOLL | R13 | Schnittstellen, Eskalations- und Meldewege mit Dienstleistern sind vereinbart. | FLAG_INCLUDE_SHOULD | +| 7.1.1-M1 | MUSS | R14 | Relevante gesetzliche, regulatorische und vertragliche Anforderungen an die Info... | - | +| 7.1.1-S1 | SOLL | R14 | Ein Compliance-/Rechtsregister wird gepflegt und regelmäßig aktualisiert; Verant... | FLAG_INCLUDE_SHOULD | +| 7.1.2-M1 | MUSS | R14 | Beim Umgang mit personenbezogenen Daten werden die datenschutzrechtlichen Anford... | - | +| 7.1.2-M2 | MUSS | R14 | Ein Verzeichnis der Verarbeitungstätigkeiten wird geführt. | - | +| 7.1.2-S1 | SOLL | R14 | Technische und organisatorische Maßnahmen (TOM), Löschkonzepte und Betroffenenre... | FLAG_INCLUDE_SHOULD | \ No newline at end of file diff --git a/seed/isms-vorlagenpaket-v2/Nachweisregister_zentral.md b/seed/isms-vorlagenpaket-v2/Nachweisregister_zentral.md new file mode 100644 index 0000000..53b91b4 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/Nachweisregister_zentral.md @@ -0,0 +1,42 @@ +# Zentrales Nachweisregister – ISMS {{ORG_NAME}} + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Nachweisregister (gilt für alle Richtlinien) | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | +| Verantwortlich | {{ROLE_ISB}} | + +## Zweck + +Dieses Dokument bündelt **alle Nachweise** für das ISMS an einer Stelle. Die einzelnen Richtlinien enthalten keine Nachweislisten, sondern verweisen hierauf ({{LINK:NACHWEISREGISTER}}). Register mit laufenden Datensätzen (Asset-Inventar, Risikoregister, Lieferanten-/NDA-Verzeichnis, Awareness-Nachweise, Verzeichnis der Verarbeitungstätigkeiten) werden in **{{TOOL_NAME}}** gepflegt; dieses Register verweist darauf. + +Die feingranulare Zuordnung Nachweis ↔ einzelne MUSS/SOLL-Anforderung erfolgt über `mapping.json` (Hidden-Anker `REQ`/`IMPL`) und ist im Lesemodus nicht sichtbar. Das Tool erzeugt daraus je Anforderung einen Nachweis-Link. + +## Nachweisübersicht + +| # | Richtlinie | Nachweis | Quelle | Verantwortlich | Turnus | +|---|-----------|----------|--------|----------------|--------| +| 1 | {{LINK:L00}} | Freigegebene, versionierte IS-Leitlinie inkl. Kommunikationsbeleg | Dok | {{ROLE_MANAGEMENT}} | {{REVIEW_CYCLE}} | +| 2 | {{LINK:R01}} | ISMS-Scope, Rollen-/Verantwortungsmatrix, Managementbewertung | Tool/Dok | {{ROLE_ISB}} | jährlich | +| 3 | {{LINK:R02}} | Asset-Inventar & Klassifizierungsmatrix; Liste zugelassener Hard-/Software | Tool | {{ROLE_IT_LEAD}} | laufend | +| 4 | {{LINK:R03}} | Risikoregister & Behandlungsplan; interne/unabhängige Prüfberichte | Tool/Dok | {{ROLE_ISB}} | ≤ jährlich | +| 5 | {{LINK:R04}} | Incident-Aufzeichnungen; Krisen-/Notfallplan; Wiederanlauftests | Tool/Dok | {{ROLE_ISB}} | laufend | +| 6 | {{LINK:R05}} | Vertraulichkeitsverpflichtungen; Schulungs-/Awareness-Nachweise | Tool | {{ROLE_HR_LEAD}} | bei Eintritt / jährlich | +| 7 | {{LINK:R06}} | Regelung & Genehmigungen mobiles Arbeiten / mobile Geräte | Dok/Tool | {{ROLE_ISB}} | laufend | +| 8 | {{LINK:R07}} | Zutrittskonzept, Zonenplan, Zutrittsprotokolle | Dok | {{ROLE_IT_LEAD}} | laufend | +| 9 | {{LINK:R08}} | Berechtigungskonzept & Rezertifizierungsnachweise | Tool | {{ROLE_IT_LEAD}} | ≤ jährlich | +| 10 | {{LINK:R09}} | Kryptokonzept, Schlüssel-/Zertifikatsverwaltung | Dok | {{ROLE_IT_LEAD}} | laufend | +| 11 | {{LINK:R10}} | Change-/Patch-/Schwachstellenberichte, Malware-Status, Logging, Backup-/Recovery-Tests | Tool/Aufz. | {{ROLE_IT_LEAD}} | laufend | +| 12 | {{LINK:R11}} | Sicherheitsanforderungen Beschaffung/Entwicklung; Löschnachweise | Dok/Aufz. | {{ROLE_IT_LEAD}} | laufend | +| 13 | {{LINK:R12}} | Freigabeliste Cloud-/KI-Dienste, Segregations-/Datenflussnachweise | Tool/Dok | {{ROLE_ISB}} | laufend | +| 14 | {{LINK:R13}} | Lieferantenverzeichnis, NDAs, Verantwortungsabgrenzung | Tool | {{ROLE_ISB}} | laufend | +| 15 | {{LINK:R14}} | Compliance-/Rechtsregister; Verzeichnis der Verarbeitungstätigkeiten | Tool | {{ROLE_DPO}} | ≤ jährlich | + +> **Wizard-Hinweis:** Zeilen mit Quelle `Tool` werden nicht als Dokument erzeugt, sondern verlinken auf den Datensatz in {{TOOL_NAME}}. Bedingte Nachweise werden anhand der Feature-Flags ein-/ausgeblendet (z. B. Zeile 13 nur bei Flag `FLAG_CLOUD_USED` / `FLAG_AI_USED`, Zeile 10 nur bei Flag `FLAG_CRYPTO_PKI`). + +## Verwandte Dokumente + +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Informationssicherheitsleitlinie: {{LINK:L00}} diff --git a/seed/isms-vorlagenpaket-v2/Technische-Sicherheits-Baseline.md b/seed/isms-vorlagenpaket-v2/Technische-Sicherheits-Baseline.md new file mode 100644 index 0000000..13666ba --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/Technische-Sicherheits-Baseline.md @@ -0,0 +1,90 @@ +# Technische Sicherheits-Baseline + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Vorgabedokument (Baseline) | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_ISB}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + +## Zweck + +Dieses Dokument legt die **konkreten technischen Mindestparameter** der Informationssicherheit fest. Es ist die zentrale Pflegestelle für alle messbaren Werte (Passwortlängen, Fristen, Verfahren). Die Richtlinien R01–R14 verweisen für exakte Werte auf die hier vergebenen **Baseline-IDs** (z. B. `BL-IAM-01`) und wiederholen die Kernaussage konkret im jeweiligen Umsetzungstext. + +Änderungen an Parametern erfolgen ausschließlich hier und werden von {{ROLE_ISB}} freigegeben. Die Werte sind als anpassbare Defaults (Variablen) hinterlegt; sie entsprechen dem Stand der Technik (Orientierung u. a. an BSI IT-Grundschutz und aktuellen NIST-Empfehlungen). + +## 1. Identitäts- und Zugriffsmanagement + +| ID | Parameter | Vorgabe | +|----|-----------|---------| +| BL-IAM-01 | Passwortvorgaben | Mindestlänge {{PW_MIN_LENGTH}} Zeichen; {{PW_COMPLEXITY}}; Prüfung gegen bekannte/kompromittierte Passwörter; {{PW_ROTATION}} | +| BL-IAM-02 | Mehr-Faktor-Authentifizierung (MFA) | Verpflichtend für {{MFA_SCOPE}} | +| BL-IAM-03 | Sitzungsverwaltung | Automatische Sperre bei Inaktivität: {{SESSION_TIMEOUT}} | +| BL-IAM-04 | Kontosperrung | {{ACCOUNT_LOCKOUT}} | +| BL-IAM-05 | Rezertifizierung von Berechtigungen | {{RECERT_FREQ}}; privilegierte Rechte zusätzlich anlassbezogen | +| BL-IAM-06 | Privilegierte/technische Konten | Getrennte Verwaltung, Einzelzuordnung, verstärkte Protokollierung; Verwaltung über {{TOOL_IAM}} | +| BL-IAM-07 | Dokumentationsort IAM | Anträge/Freigaben/Sperrungen im {{TOOL_TICKET}}; Kontenverwaltung in {{TOOL_IAM}} | + +## 2. Kryptographie und Übertragung + +| ID | Parameter | Vorgabe | +|----|-----------|---------| +| BL-CRY-01 | Transportverschlüsselung | Mindestens {{TLS_MIN}}; unsichere Protokolle deaktiviert | +| BL-CRY-02 | Zulässige Algorithmen/Schlüssellängen | {{CRYPTO_ALGO}} | +| BL-CRY-03 | Datenträgerverschlüsselung | Vollverschlüsselung mobiler Geräte und Datenträger (AES-256) | +| BL-CRY-04 | E-Mail-/Dateiaustausch | Verschlüsselung schutzbedürftiger Inhalte; sichere Austauschwege vorgegeben | +| BL-CRY-05 | Schlüsselverwaltung | Definierter Lebenszyklus (Erzeugung, Verteilung, Speicherung, Sperrung, Vernichtung){{#if FLAG_CRYPTO_PKI}}; PKI/Zertifikatsverwaltung etabliert{{/if}} | + +## 3. Betriebssicherheit + +| ID | Parameter | Vorgabe | +|----|-----------|---------| +| BL-OPS-01 | Patch-SLA | Kritisch: {{PATCH_SLA_CRIT}}; hoch: {{PATCH_SLA_HIGH}}; standard: {{PATCH_SLA_STD}} | +| BL-OPS-02 | Schwachstellen-Scanning | {{VULN_SCAN_FREQ}}; Nachverfolgung im {{TOOL_TICKET}} | +| BL-OPS-03 | Malware-Schutz | {{TECH_MALWARE}} auf allen Endpunkten/Servern; Signatur-/Engine-Update {{MALWARE_UPDATE}} | +| BL-OPS-04 | Protokollierung & Aufbewahrung | Zentrale Protokollierung ({{TECH_SIEM}}); Aufbewahrung {{LOG_RETENTION}}; manipulationsgeschützt | +| BL-OPS-05 | Datensicherung | Schema {{BACKUP_SCHEME}} über {{TECH_BACKUP}}; Aufbewahrung {{BACKUP_RETENTION}} | +| BL-OPS-06 | Wiederherstellungstests | {{BACKUP_TEST_FREQ}}; Ergebnis dokumentiert | +| BL-OPS-07 | Systemhärtung | Härtungsvorgaben (z. B. CIS-Benchmarks) für Standardsysteme | +| BL-OPS-08 | Technische Prüfung / Penetrationstest | {{PENTEST_FREQ}} bzw. risikoorientiert | +| BL-OPS-09 | Change-Management | Antrag/Bewertung/Test/Genehmigung/Doku im {{TOOL_TICKET}} | + +## 4. Netzwerksicherheit + +| ID | Parameter | Vorgabe | +|----|-----------|---------| +| BL-NET-01 | Segmentierung | Trennung nach Schutzbedarf; {{#if FLAG_OT_USED}}Produktions-/OT-Netze getrennt und besonders abgesichert; {{/if}}Gäste-/Fremdnetze isoliert | +| BL-NET-02 | Perimeter & Fernzugriff | Firewall mit Default-Deny; Fernzugriff nur über {{TECH_VPN}} mit MFA (BL-IAM-02) | + +## 5. Endpoint und mobile Nutzung + +| ID | Parameter | Vorgabe | +|----|-----------|---------| +| BL-EP-01 | Geräteverwaltung | Verwaltung über {{TECH_MDM}}; nur freigegebene Geräte | +| BL-EP-02 | Geräteverschlüsselung/Fernlöschung | Vollverschlüsselung (BL-CRY-03); Sperre/Löschung bei Verlust über {{TECH_MDM}} | +| BL-EP-03 | Wechseldatenträger | Nur verschlüsselt und freigegeben; Nutzung kontrolliert | + +## 6. Physische Sicherheit + +| ID | Parameter | Vorgabe | +|----|-----------|---------| +| BL-PHY-01 | Sicherheitszonen | Definierte Zonen; Zutritt bedarfsorientiert, dokumentiert, bei Wegfall entzogen | +| BL-PHY-02 | Zutrittsprotokollierung | Protokollierung zu schutzbedürftigen Bereichen; Besucher registriert und begleitet | + +## 7. Personal und Lieferanten + +| ID | Parameter | Vorgabe | +|----|-----------|---------| +| BL-HR-01 | Awareness/Schulung | Bei Eintritt und danach mindestens {{REVIEW_CYCLE}}; Nachweis im {{TOOL_NAME}} | +| BL-SUP-01 | Lieferanten-Risikoklassen | Einstufung nach Schutzbedarf und Zugriff; Prüfung der Einhaltung (Nachweise/TISAX) | +| BL-DEL-01 | Sichere Löschung | Schutzbedarfsgerechtes Löschen/Vernichten (z. B. nach anerkannten Standards); Löschnachweis | + +## Änderungshistorie + +| Version | Datum | Autor | Änderung | +|---------|-------|-------|----------| +| {{DOC_VERSION}} | {{DOC_DATE}} | {{ROLE_IT_LEAD}} | Erstellung | diff --git a/seed/isms-vorlagenpaket-v2/_enrich.py b/seed/isms-vorlagenpaket-v2/_enrich.py new file mode 100644 index 0000000..2057bc2 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/_enrich.py @@ -0,0 +1,168 @@ +# -*- coding: utf-8 -*- +"""Ersetzt die Umsetzungstexte (IMPL) durch auditfeste, konkrete Fassungen mit +Baseline-Referenzen (BL-*), Werten (als Variablen) und Dokumentationsort. +Patcht die .md-Dateien und aktualisiert mapping.json. Fuegt {{LINK:BASELINE}} ein.""" +import json, re, glob, os +BASE=os.path.dirname(__file__) + +IMPL={ +# R01 +"1.2.1-M1":"Der ISMS-Geltungsbereich (Organisation, Standorte, Prozesse) ist im ISMS-Tool ({{TOOL_NAME}}) dokumentiert, versioniert und wird dort gepflegt; wesentliche Änderungen gibt {{ROLE_ISB}} frei.", +"1.2.1-M2":"Die {{ROLE_MANAGEMENT}} hat das ISMS per Managementbeschluss beauftragt, stellt Personal- und Budgetressourcen bereit und trägt die Gesamtverantwortung; die operative Steuerung liegt bei {{ROLE_ISB}}.", +"1.2.1-M3":"Die Wirksamkeit wird mindestens {{REVIEW_CYCLE}} in einer dokumentierten Managementbewertung anhand von Zielen, Kennzahlen sowie Audit- und Vorfallsergebnissen geprüft; Protokoll und Maßnahmen werden im ISMS-Tool ({{TOOL_NAME}}) abgelegt.", +"1.2.1-S1":"Messbare Informationssicherheitsziele und KPI (z. B. Schulungsquote, offene Maßnahmen, Patch-Compliance) sind definiert und werden im ISMS-Tool ({{TOOL_NAME}}) nachverfolgt.", +"1.2.2-M1":"Verantwortlichkeiten sind in der Rollen-/Verantwortungsmatrix (Abschnitt 5) und im ISMS-Tool ({{TOOL_NAME}}) dokumentiert und den Rolleninhabern kommuniziert.", +"1.2.2-M2":"Die Rolle {{ROLE_ISB}} ist schriftlich benannt, mit Zeit-/Budgetressourcen und Weisungsrechten ausgestattet und berichtet direkt an die {{ROLE_MANAGEMENT}}.", +"1.2.2-S1":"In Konflikt stehende Tätigkeiten (Umsetzung vs. Kontrolle, Beantragung vs. Genehmigung) sind getrennt; unvermeidbare Doppelrollen werden dokumentiert und durch kompensierende Kontrollen (Vier-Augen-Prinzip) abgesichert.", +"1.2.2-S2":"Kontakte zu Behörden, CERT/CSIRT und relevanten Branchengremien werden von {{ROLE_ISB}} gepflegt und im ISMS-Tool hinterlegt.", +"1.2.3-M1":"Projekte werden zu Beginn anhand eines Kriterienkatalogs hinsichtlich Informationssicherheitsbedarf bewertet und klassifiziert; die Einstufung wird im {{TOOL_TICKET}} bzw. ISMS-Tool dokumentiert.", +"1.2.3-M2":"Bei erhöhtem Schutzbedarf wird {{ROLE_ISB}} verbindlich eingebunden; ermittelte Sicherheitsanforderungen werden als Aufgaben im {{TOOL_TICKET}} nachgehalten und vor Projektabschluss geprüft.", +"1.2.3-S1":"Der Kriterienkatalog zur Projekteinstufung ist dokumentiert und wird einheitlich angewandt.", +# R02 +"1.3.1-M1":"Informationswerte und Assets werden im ISMS-Tool ({{TOOL_NAME}}) im Asset-Inventar mit Attributen (Owner, Standort, Schutzbedarf) erfasst; Zu-/Abgänge werden über {{TOOL_TICKET}} ausgelöst.", +"1.3.1-M2":"Jedem Asset ist im Inventar ein verantwortlicher Owner zugeordnet, der Klassifizierung und Aktualität verantwortet.", +"1.3.1-S1":"Das Asset-Inventar wird laufend gepflegt und mindestens {{REVIEW_CYCLE}} vollständig auf Aktualität geprüft (Review durch {{ROLE_IT_LEAD}}).", +"1.3.2-M1":"Es gilt ein vierstufiges Klassifizierungsschema (Öffentlich / Intern / Vertraulich / Streng vertraulich); die Einstufung nach Vertraulichkeit, Integrität und Verfügbarkeit erfolgt durch den Asset Owner im ISMS-Tool.", +"1.3.2-M2":"Je Schutzklasse sind Handhabungsvorgaben zu Kennzeichnung, Speicherung, Übertragung (BL-CRY-01/04) und Löschung (BL-DEL-01) definiert und den Mitarbeitenden bekannt gemacht.", +"1.3.2-S1":"Bei wesentlichen Änderungen wird die Klassifizierung durch den Asset Owner überprüft und im ISMS-Tool aktualisiert.", +"1.3.3-M1":"Externe Hardware/IT-Komponenten werden vor Einsatz technisch und sicherheitsseitig bewertet und freigegeben; die Freigabeliste wird im ISMS-Tool ({{TOOL_NAME}}) geführt.", +"1.3.3-S1":"Der Anschluss nicht freigegebener Geräte wird soweit möglich technisch unterbunden (z. B. Portkontrolle, {{TECH_MDM}}).", +"1.3.4-M1":"Software wird vor Einsatz freigegeben; eine Liste zugelassener Software (Whitelist) wird im ISMS-Tool gepflegt, Beschaffung/Freigabe läuft über {{TOOL_TICKET}}.", +"1.3.4-S1":"Die Installation von Software ist für Standardnutzer technisch eingeschränkt (keine lokalen Adminrechte); Ausnahmen werden im {{TOOL_TICKET}} genehmigt.", +# R03 +"1.4.1-M1":"Das Risikomanagement-Verfahren (Identifikation, Analyse, Bewertung, Behandlung) ist dokumentiert; Risiken werden im ISMS-Tool ({{TOOL_NAME}}) im Risikoregister geführt.", +"1.4.1-M2":"Je Risiko sind Eintrittswahrscheinlichkeit, Schadenshöhe, Behandlungsoption (reduzieren/vermeiden/übertragen/akzeptieren), Maßnahmen, Verantwortlicher und Termin hinterlegt.", +"1.4.1-M3":"Die Bewertung wird mindestens {{REVIEW_CYCLE}} und anlassbezogen (neue Systeme, Vorfälle, Änderungen) aktualisiert; Restrisiken werden von der {{ROLE_MANAGEMENT}} dokumentiert akzeptiert.", +"1.4.1-S1":"Bewertungsskalen und Akzeptanzschwellen sind definiert und im ISMS-Tool hinterlegt.", +"1.5.1-M1":"Die Einhaltung wird durch interne Audits und stichprobenartige Kontrollen (nach Auditplan) geprüft; Feststellungen werden im ISMS-Tool als Maßnahmen nachverfolgt.", +"1.5.1-S1":"Ein jährliches Auditprogramm mit Umfang, Turnus und Verantwortlichkeiten ist etabliert.", +"1.5.2-M1":"Das ISMS wird durch eine unabhängige Stelle (interne Revision oder externe Auditierung, z. B. TISAX) überprüft.", +"1.5.2-S1":"Die Ergebnisse werden in der Managementbewertung behandelt und fließen in den kontinuierlichen Verbesserungsprozess ein.", +# R04 +"1.6.1-M1":"Sicherheitsereignisse können über einen definierten Meldeweg (Meldebutton/Formular im {{TOOL_TICKET}} bzw. ISMS-Tool sowie per E-Mail an {{ROLE_ISB}}) gemeldet werden.", +"1.6.1-M2":"Der Meldeweg ist allen Beschäftigten über Onboarding und Awareness (BL-HR-01) bekannt und niedrigschwellig, auch anonym, erreichbar.", +"1.6.1-S1":"Meldungen werden zentral im ISMS-Tool erfasst, kategorisiert und einem Schweregrad zugeordnet.", +"1.6.2-M1":"Ereignisse werden nach einem definierten Incident-Verfahren bewertet, priorisiert, eingedämmt, behoben und dokumentiert; die Bearbeitung erfolgt im {{TOOL_TICKET}}.", +"1.6.2-M2":"Verantwortlichkeiten und Eskalationsstufen sind definiert; {{ROLE_ISB}} koordiniert, {{ROLE_IT_LEAD}} setzt technische Maßnahmen um.", +"1.6.2-S1":"Nach relevanten Vorfällen erfolgt eine Nachbereitung (Lessons Learned) mit Ableitung und Nachverfolgung von Verbesserungsmaßnahmen.", +"1.6.2-S2":"Vertragliche und gesetzliche Meldepflichten (Kunden/OEM, Aufsichtsbehörden, bei personenbezogenen Daten binnen 72 Stunden) sind im Verfahren berücksichtigt.", +"1.6.3-M1":"Ein Krisenmanagement mit Krisenstab, Rollen, Kommunikations- und Entscheidungswegen ist definiert; der Krisenstab wird durch die {{ROLE_MANAGEMENT}} einberufen.", +"1.6.3-S1":"Krisen- und Notfallpläne werden mindestens {{REVIEW_CYCLE}} geübt (z. B. Tabletop-Übung) und aktualisiert.", +"5.2.8-M1":"Für kritische IT-Dienste bestehen Wiederanlaufziele (RTO/RPO), Verantwortliche und Maßnahmen; {{ROLE_IT_LEAD}} verantwortet die Kontinuitätsplanung.", +"5.2.8-S1":"Wiederanlaufmaßnahmen werden mindestens {{BACKUP_TEST_FREQ}} getestet (BL-OPS-06); Ergebnisse werden dokumentiert.", +# R05 +"2.1.1-M1":"Für sensible Tätigkeiten werden Qualifikation und Zuverlässigkeit im rechtlich zulässigen Rahmen sichergestellt (z. B. Qualifikationsnachweise, bei besonders schutzbedürftigen Rollen ggf. Führungszeugnis).", +"2.1.1-S1":"Sicherheitsanforderungen an Positionen sind in Stellenbeschreibungen hinterlegt; Überprüfungen erfolgen anlass- und rollenbezogen.", +"2.1.2-M1":"Alle Beschäftigten werden bei Eintritt vertraglich zur Vertraulichkeit und Einhaltung der Informationssicherheit verpflichtet ({{ROLE_HR_LEAD}}); der Nachweis wird in der Personalakte geführt.", +"2.1.2-S1":"Die Vertraulichkeitsverpflichtung gilt nachvertraglich fort; Rückgabe von Assets und Entzug von Berechtigungen beim Austritt sind über {{TOOL_TICKET}} geregelt (Leaver-Prozess).", +"2.1.3-M1":"Beschäftigte werden bei Eintritt und danach mindestens {{REVIEW_CYCLE}} geschult (BL-HR-01); Teilnahmenachweise werden im {{TOOL_NAME}} geführt.", +"2.1.3-S1":"Schulungen sind rollenspezifisch; die Wirksamkeit wird durch Phishing-Simulationen und gezielte Nachschulungen überprüft.", +# R06 +"2.1.4-M1":"Mobiles Arbeiten ist in einer Regelung festgelegt; der Zugriff erfolgt ausschließlich über {{TECH_VPN}} mit MFA (BL-IAM-02) und freigegebene, verschlüsselte Geräte (BL-CRY-03).", +"2.1.4-M2":"Der Zugriff auf Unternehmensinformationen ist auf verwaltete Geräte ({{TECH_MDM}}) beschränkt; die Nutzung ist an die Einhaltung der Regelung gebunden.", +"2.1.4-S1":"Regeln zu Sichtschutz, Clean-Desk/Clean-Screen und zum Arbeiten in öffentlichen Umgebungen sind definiert und Teil der Awareness (BL-HR-01).", +"3.1.4-M1":"Mobile Geräte sind vollverschlüsselt (BL-CRY-03) und über {{TECH_MDM}} zentral verwaltet; Verlustmeldung erfolgt über den Meldeweg (R04) und {{TOOL_TICKET}}.", +"3.1.4-M2":"Bei Verlust können Geräte über {{TECH_MDM}} gesperrt und aus der Ferne gelöscht werden (BL-EP-02).", +"3.1.4-S1":"Der Einsatz privater Geräte (BYOD) ist geregelt bzw. untersagt; Wechseldatenträger werden nur verschlüsselt und freigegeben zugelassen (BL-EP-03).", +# R07 +"3.1.1-M1":"Sicherheitszonen sind definiert (BL-PHY-01); der Zutritt zu schutzbedürftigen Bereichen (z. B. Serverraum) ist reglementiert und wird protokolliert (BL-PHY-02).", +"3.1.1-M2":"Zutrittsrechte werden bedarfsorientiert über {{TOOL_TICKET}} vergeben, dokumentiert und bei Wegfall (Austritt/Rollenwechsel) entzogen.", +"3.1.1-S1":"Besucher werden registriert und begleitet; technische Schutzmaßnahmen (Zutrittskontrolle, Alarm, Videoüberwachung im rechtlichen Rahmen) sind vorhanden.", +"3.1.3-M1":"Serverräume und Versorgungseinrichtungen (Strom, Klima, Verkabelung) sind zutrittsgeschützt und gegen Ausfall abgesichert.", +"3.1.3-S1":"Versorgungseinrichtungen werden gewartet und überwacht; für kritische Bereiche bestehen Redundanzen (z. B. USV, Klimaredundanz).", +# R08 +"4.1.1-M1":"Identifikationsmittel (Benutzerkennungen, Token, Zertifikate) werden eindeutig personenbezogen über {{TOOL_IAM}} vergeben; Sammelkonten werden vermieden bzw. dokumentiert und begründet.", +"4.1.1-S1":"Ausgabe, Rücknahme und Sperrung von Identifikationsmitteln werden im {{TOOL_TICKET}} beantragt, genehmigt und dokumentiert (BL-IAM-07).", +"4.1.2-M1":"Der Zugang ist durch sichere Authentifizierung geschützt; die Passwortvorgaben nach BL-IAM-01 (mind. {{PW_MIN_LENGTH}} Zeichen, {{PW_COMPLEXITY}}, {{PW_ROTATION}}) werden zentral über {{TOOL_IAM}} erzwungen.", +"4.1.2-M2":"Für Fernzugriffe, administrative Zugänge und Cloud-Dienste wird MFA gemäß BL-IAM-02 über {{TECH_MFA}} durchgesetzt.", +"4.1.2-S1":"Sperrmechanismen (BL-IAM-04) und Sitzungs-Timeouts (BL-IAM-03) sind zentral konfiguriert.", +"4.1.3-M1":"Konten werden über einen definierten Lebenszyklus (Joiner/Mover/Leaver) verwaltet; Auslöser sind {{TOOL_TICKET}}-Aufträge aus HR-/Vorgesetztenmeldungen.", +"4.1.3-S1":"Privilegierte und technische Konten werden gesondert verwaltet, einzeln zugeordnet und verstärkt protokolliert (BL-IAM-06).", +"4.2.1-M1":"Zugriffsrechte werden nach dem Minimalprinzip (need-to-know/least privilege) vergeben; Antrag, fachliche Prüfung und Genehmigung erfolgen im {{TOOL_TICKET}}.", +"4.2.1-M2":"Berechtigungen werden beim Wegfall entzogen und mindestens {{RECERT_FREQ}} rezertifiziert (BL-IAM-05){{#if FLAG_CUSTOMER_SYSTEMS}}, auch für Zugriffe in Kundensystemen{{/if}}.", +"4.2.1-S1":"Berechtigungen werden rollenbasiert (RBAC) über {{TOOL_IAM}} vergeben; Standardkonten erhalten keine privilegierten Rechte.", +# R09 +"5.1.1-M1":"Zulässige Verfahren und Schlüssellängen nach BL-CRY-02 ({{CRYPTO_ALGO}}) sind vorgegeben; veraltete Verfahren sind untersagt.", +"5.1.1-M2":"Schlüssel werden über ihren Lebenszyklus (Erzeugung, Verteilung, Speicherung, Sperrung, Vernichtung) sicher verwaltet (BL-CRY-05).", +"5.1.1-S1":"Ein Kryptokonzept ist dokumentiert{{#if FLAG_CRYPTO_PKI}}; eine PKI/Zertifikatsverwaltung ist etabliert{{/if}}.", +"5.1.2-M1":"Informationen werden schutzbedarfsgerecht bei der Übertragung geschützt: mindestens {{TLS_MIN}} (BL-CRY-01) und gesicherte Kanäle.", +"5.1.2-S1":"Regeln für E-Mail-Verschlüsselung und sichere Dateiübertragung sind definiert (BL-CRY-04).", +# R10 +"5.2.1-M1":"Änderungen durchlaufen ein Change-Verfahren mit Antrag, Risikobewertung, Test, Genehmigung und Dokumentation im {{TOOL_TICKET}} (BL-OPS-09).", +"5.2.2-M1":"Entwicklung, Test und Produktion sind getrennt betrieben.", +"5.2.2-S1":"Produktivdaten werden in Test-/Entwicklungsumgebungen nur anonymisiert/pseudonymisiert genutzt.", +"5.2.3-M1":"Malware-Schutz ist über {{TECH_MALWARE}} auf allen Endpunkten und Servern umgesetzt (BL-OPS-03).", +"5.2.3-S1":"Signaturen/Engines werden {{MALWARE_UPDATE}} aktualisiert; unnötige Netzwerkdienste sind deaktiviert.", +"5.2.4-M1":"Sicherheitsrelevante Ereignisse werden zentral über {{TECH_SIEM}} protokolliert und ausgewertet (BL-OPS-04).", +"5.2.4-S1":"Protokolle sind manipulationsgeschützt; die Aufbewahrung beträgt {{LOG_RETENTION}}.", +"5.2.5-M1":"Schwachstellen werden erfasst und nach BL-OPS-01 risikoorientiert gepatcht (kritisch {{PATCH_SLA_CRIT}}); die Nachverfolgung erfolgt im {{TOOL_TICKET}}.", +"5.2.5-S1":"Ein Schwachstellen-Scanning ({{VULN_SCAN_FREQ}}, BL-OPS-02) ist etabliert.", +"5.2.6-M1":"Systeme werden nach Härtungsvorgaben (BL-OPS-07, z. B. CIS-Benchmarks) konfiguriert und risikoorientiert technisch geprüft (Penetrationstest {{PENTEST_FREQ}}, BL-OPS-08).", +"5.2.7-M1":"Das Netzwerk ist nach Schutzbedarf segmentiert (BL-NET-01), zugangskontrolliert und nach außen über Firewall (Default-Deny, BL-NET-02) abgesichert.", +"5.2.7-M2":"Produktions-/OT-Netze sind von Office-Netzen getrennt und besonders abgesichert (BL-NET-01).", +"5.2.7-S1":"Ein aktueller Netzplan und ein Segmentierungskonzept werden gepflegt.", +"5.2.9-M1":"Daten und Dienste werden nach Schema {{BACKUP_SCHEME}} über {{TECH_BACKUP}} gesichert (BL-OPS-05); die Wiederherstellung ist geregelt.", +"5.2.9-M2":"Wiederherstellungstests werden mindestens {{BACKUP_TEST_FREQ}} durchgeführt und dokumentiert (BL-OPS-06).", +"5.2.9-S1":"Backups werden geschützt und ausgelagert aufbewahrt (offline/immutable), Aufbewahrung {{BACKUP_RETENTION}}.", +# R11 +"5.3.1-M1":"Sicherheitsanforderungen sind fester Bestandteil von Beschaffungs- und Änderungsprozessen (Security by Design); die Prüfung erfolgt vor Freigabe im {{TOOL_TICKET}}.", +"5.3.1-M2":"Für die Eigenentwicklung gelten Secure-Coding-Vorgaben mit Code-Reviews, automatisierten Sicherheitstests (SAST/Dependency-Scan) und dokumentierten Freigaben.", +"5.3.1-S1":"Sicherheitsanforderungen werden dokumentiert und ihre Umsetzung vor Produktivsetzung geprüft.", +"5.3.2-M1":"Für genutzte Netzdienste (intern/extern) sind Sicherheitsanforderungen definiert und vertraglich bzw. technisch vereinbart.", +"5.3.3-M1":"Rückgabe und sichere Löschung/Vernichtung (bei Vertragsende, Geräteausmusterung) sind nach BL-DEL-01 geregelt und werden nachgewiesen.", +"5.3.3-S1":"Löschverfahren richten sich nach dem Schutzbedarf; Löschungen werden dokumentiert (Löschprotokoll).", +# R12 +"5.3.4-M1":"Bei geteilten externen Diensten wird eine wirksame Mandantentrennung gefordert und vertraglich zugesichert; die Prüfung erfolgt vor Freigabe.", +"5.3.4-M2":"Cloud-Dienste werden vor Nutzung bewertet (Schutzbedarf, Datenlokation/EU, Verschlüsselung, Exit) und von {{ROLE_ISB}} freigegeben; die Freigabeliste wird im ISMS-Tool ({{TOOL_NAME}}) geführt.", +"5.3.4-S1":"Das Segregationskonzept des Anbieters wird dokumentiert und bei Änderungen aktualisiert.", +"5.3.4-KI-M1":"Der Einsatz von KI-/GenAI-Diensten ist geregelt; nur von {{ROLE_ISB}} freigegebene Dienste (Freigabeliste im ISMS-Tool) dürfen genutzt werden.", +"5.3.4-KI-M2":"Zulässige Datenklassen je KI-Dienst sind definiert; die Eingabe vertraulicher oder personenbezogener Daten in nicht freigegebene Dienste ist untersagt (Awareness BL-HR-01).", +"5.3.4-KI-M3":"Bei Freigabe wird geprüft und vertraglich sichergestellt, dass Eingaben nicht zum Training genutzt oder an Dritte weitergegeben werden (Opt-out bzw. Enterprise-Vertrag).", +"5.3.4-KI-S1":"KI-Ergebnisse werden vor geschäftskritischer Verwendung durch Menschen geprüft (Human-in-the-Loop); der KI-Einsatz wird dokumentiert und regulatorische Anforderungen (EU AI Act) berücksichtigt.", +# R13 +"6.1.1-M1":"Sicherheitsanforderungen an Lieferanten werden ermittelt, vertraglich vereinbart und überwacht; das Lieferantenverzeichnis wird im ISMS-Tool ({{TOOL_NAME}}) geführt.", +"6.1.1-M2":"Lieferanten werden risikoorientiert nach BL-SUP-01 (Schutzbedarf, Zugriff) klassifiziert.", +"6.1.1-S1":"Die Einhaltung wird risikobasiert überprüft (Selbstauskunft, Nachweise, Audits, TISAX-Label).", +"6.1.2-M1":"Vor dem Austausch schutzbedürftiger Informationen werden Vertraulichkeitsvereinbarungen (NDA) abgeschlossen und im ISMS-Tool hinterlegt.", +"6.1.2-S1":"Standardisierte NDA-Vorlagen mit Geltungsdauer sowie Rückgabe-/Löschpflichten werden verwendet.", +"6.1.3-M1":"Die Verantwortlichkeiten mit externen IT-Dienstleistern (Betriebs-, Sicherheits-, Melde- und Mitwirkungspflichten) sind abgegrenzt und vertraglich dokumentiert.", +"6.1.3-S1":"Schnittstellen sowie Eskalations- und Meldewege sind vertraglich vereinbart (Anbindung an R04).", +# R14 +"7.1.1-M1":"Relevante gesetzliche, regulatorische und vertragliche Anforderungen werden in einem Compliance-/Rechtsregister im ISMS-Tool ({{TOOL_NAME}}) erfasst und ihre Einhaltung nachverfolgt.", +"7.1.1-S1":"Das Register wird mindestens {{REVIEW_CYCLE}} aktualisiert; je Anforderung ist ein Verantwortlicher benannt.", +"7.1.2-M1":"Datenschutzrechtliche Anforderungen (DSGVO) werden berücksichtigt; {{ROLE_DPO}} ist eingebunden und bei relevanten Vorhaben (Datenschutz-Folgenabschätzung) beteiligt.", +"7.1.2-M2":"Das Verzeichnis der Verarbeitungstätigkeiten wird im ISMS-Tool ({{TOOL_NAME}}) geführt und gepflegt.", +"7.1.2-S1":"Technische und organisatorische Maßnahmen (TOM), Löschkonzepte (BL-DEL-01) und Prozesse für Betroffenenrechte sind geregelt.", +} + +def clean(s): + s=re.sub(r"\{\{#if \w+\}\}","",s); s=re.sub(r"\{\{/if\}\}","",s) + s=re.sub(r"\s+"," ",s).strip().replace(" .",".").replace(" ,",",") + return s + +# --- Patch .md-Dateien: Zeile nach ersetzen --- +patched=0 +for fp in glob.glob(os.path.join(BASE,"richtlinien/*.md")): + lines=open(fp,encoding="utf-8").read().split("\n") + out=[]; i=0 + while i\s*$", lines[i]) + if m and m.group(1) in IMPL and i+1- und Hidden-Anker. +# --------------------------------------------------------------------------- + +POLICIES = [] + +def pol(**k): POLICIES.append(k) + +pol(id="R01", fn="R01_ISMS-Organisation-und-Rollen", + title="ISMS-Organisation und Rollen", owner="ROLE_ISB", + purpose="Diese Richtlinie regelt Aufbau, Steuerung und Verantwortlichkeiten des Informationssicherheits-Managementsystems (ISMS) der {{ORG_NAME}} sowie die Beruecksichtigung der Informationssicherheit in Projekten.", + related=["L00","R03","R13"], + roles=[("{{ROLE_MANAGEMENT}}","Beauftragung und Gesamtverantwortung ISMS, Ressourcen, Managementbewertung"), + ("{{ROLE_ISB}}","Operative Steuerung des ISMS, Pflege der Verantwortlichkeiten"), + ("{{ROLE_IT_LEAD}}","Technische Umsetzung ISMS-relevanter Massnahmen"), + ("Asset Owner / Prozessverantwortliche","Pflege zugeordneter Assets/Prozesse im ISMS-Tool")], + controls=[ + {"num":"1.2.1","title":"Steuerung der Informationssicherheit","reqs":[ + {"t":"M","req":"Der Geltungsbereich des ISMS (Organisation, Standorte, Prozesse) ist bestimmt und dokumentiert.", + "impl":"Der ISMS-Geltungsbereich ist im ISMS-Tool ({{TOOL_NAME}}) dokumentiert und wird dort gepflegt."}, + {"t":"M","req":"Das ISMS wird durch die Leitung initiiert, gesteuert und ueberwacht; erforderliche Ressourcen werden bereitgestellt.", + "impl":"Die {{ROLE_MANAGEMENT}} hat das ISMS beauftragt, stellt die erforderlichen Ressourcen bereit und traegt die Gesamtverantwortung; die operative Steuerung liegt bei {{ROLE_ISB}}."}, + {"t":"M","req":"Die Wirksamkeit des ISMS wird regelmaessig durch die Leitung bewertet (Managementbewertung).", + "impl":"Die Wirksamkeit des ISMS wird mindestens {{REVIEW_CYCLE}} in einer dokumentierten Managementbewertung geprueft; die Ergebnisse werden im ISMS-Tool festgehalten."}, + {"t":"S","req":"Informationssicherheitsziele sind messbar formuliert und werden nachverfolgt (KPI).", + "impl":"Informationssicherheitsziele und Kennzahlen (KPI) sind definiert und werden im ISMS-Tool nachverfolgt."}, + ]}, + {"num":"1.2.2","title":"Organisation der Verantwortlichkeiten","reqs":[ + {"t":"M","req":"Verantwortlichkeiten fuer Informationssicherheit sind definiert, zugewiesen und dokumentiert.", + "impl":"Die Verantwortlichkeiten sind in der Rollenuebersicht (Abschnitt 5) und im ISMS-Tool ({{TOOL_NAME}}) dokumentiert und bekannt gemacht."}, + {"t":"M","req":"Eine fuer Informationssicherheit verantwortliche Rolle ist benannt, verfuegt ueber ausreichende Kompetenzen und einen direkten Berichtsweg zur Leitung.", + "impl":"Die Rolle {{ROLE_ISB}} ist benannt und berichtet direkt an die {{ROLE_MANAGEMENT}}."}, + {"t":"S","req":"In Konflikt stehende Aufgaben und Verantwortungsbereiche sind getrennt (Funktionstrennung).", + "impl":"In Konflikt stehende Taetigkeiten (z. B. Umsetzung und Kontrolle) werden getrennt; unvermeidbare Doppelrollen werden durch kompensierende Kontrollen abgesichert."}, + {"t":"S","req":"Kontakte zu relevanten Behoerden und Interessengruppen werden gepflegt.", + "impl":"Relevante externe Kontakte (Behoerden, CERT, Branchengremien) werden durch {{ROLE_ISB}} gepflegt."}, + ]}, + {"num":"1.2.3","title":"Informationssicherheit in Projekten","reqs":[ + {"t":"M","req":"Projekte werden unter Beruecksichtigung ihres Informationssicherheitsbedarfs klassifiziert.", + "impl":"Projekte werden zu Beginn hinsichtlich ihres Informationssicherheitsbedarfs bewertet und klassifiziert."}, + {"t":"M","req":"In Projekten werden Informationssicherheitsanforderungen ermittelt und beruecksichtigt.", + "impl":"Bei erhoehtem Schutzbedarf wird {{ROLE_ISB}} eingebunden; die Anforderungen werden ermittelt und im ISMS-Tool nachgehalten."}, + {"t":"S","req":"Verfahren und Kriterien zur Klassifizierung von Projekten sind dokumentiert und werden angewandt.", + "impl":"Die Kriterien fuer die Projekteinstufung sind dokumentiert und werden einheitlich angewandt."}, + ]}, + ]) + +pol(id="R02", fn="R02_Asset-und-Klassifizierungsrichtlinie", + title="Asset- und Klassifizierungsrichtlinie", owner="ROLE_IT_LEAD", + purpose="Diese Richtlinie regelt Identifikation, Inventarisierung, Klassifizierung und den geschuetzten Umgang mit Informationswerten und Assets der {{ORG_NAME}} sowie die Zulassung von Hard- und Software.", + related=["R01","R08","R11"], + roles=[("{{ROLE_IT_LEAD}}","Pflege des Asset-Inventars, Zulassung Hard-/Software"), + ("{{ROLE_ISB}}","Vorgabe des Klassifizierungsschemas"), + ("Asset Owner","Bewertung und Pflege einzelner Assets im ISMS-Tool")], + controls=[ + {"num":"1.3.1","title":"Identifikation von Assets","reqs":[ + {"t":"M","req":"Informationswerte und weitere Assets, die Informationen verarbeiten, sind identifiziert und erfasst.", + "impl":"Informationswerte und Assets werden im ISMS-Tool ({{TOOL_NAME}}) im Asset-Inventar erfasst."}, + {"t":"M","req":"Fuer jedes Asset ist ein Verantwortlicher (Owner) benannt.", + "impl":"Jedem Asset ist im ISMS-Tool ein Owner zugeordnet."}, + {"t":"S","req":"Ein Katalog der relevanten Informationswerte wird gepflegt und regelmaessig aktualisiert.", + "impl":"Das Asset-Inventar wird laufend gepflegt und mindestens {{REVIEW_CYCLE}} auf Aktualitaet geprueft."}, + ]}, + {"num":"1.3.2","title":"Klassifizierung","reqs":[ + {"t":"M","req":"Informationswerte sind nach Schutzbedarf (Vertraulichkeit, Integritaet, Verfuegbarkeit) klassifiziert.", + "impl":"Es gilt ein vierstufiges Klassifizierungsschema (Oeffentlich / Intern / Vertraulich / Streng vertraulich); die Einstufung erfolgt im ISMS-Tool."}, + {"t":"M","req":"Abhaengig von der Klassifizierung sind Vorgaben zu Kennzeichnung, Handhabung, Speicherung, Uebertragung und Loeschung definiert.", + "impl":"Handhabungsvorgaben je Schutzklasse sind definiert und den Mitarbeitenden bekannt gemacht."}, + {"t":"S","req":"Die Klassifizierung wird bei wesentlichen Aenderungen ueberprueft und angepasst.", + "impl":"Bei wesentlichen Aenderungen wird die Klassifizierung durch den Asset Owner ueberprueft."}, + ]}, + {"num":"1.3.3","title":"Zugelassene Hardware","reqs":[ + {"t":"M","req":"Es ist sichergestellt, dass nur bewertete und freigegebene externe Hardware/IT-Komponenten eingesetzt werden.", + "impl":"Externe Hardware wird vor Einsatz bewertet und freigegeben; eine Freigabeliste wird im ISMS-Tool gefuehrt."}, + {"t":"S","req":"Nicht freigegebene Geraete werden technisch unterbunden.", + "impl":"Der Anschluss nicht freigegebener Geraete wird soweit moeglich technisch unterbunden."}, + ]}, + {"num":"1.3.4","title":"Zugelassene Software","reqs":[ + {"t":"M","req":"Es ist sichergestellt, dass nur bewertete und freigegebene Software eingesetzt wird.", + "impl":"Software wird vor Einsatz freigegeben; eine Liste zugelassener Software wird gepflegt."}, + {"t":"S","req":"Die Installation nicht freigegebener Software wird technisch eingeschraenkt.", + "impl":"Die Installation von Software ist fuer Standardnutzer technisch eingeschraenkt."}, + ]}, + ]) + +pol(id="R03", fn="R03_Risikomanagement-und-Auditrichtlinie", + title="Risikomanagement- und Auditrichtlinie", owner="ROLE_ISB", + purpose="Diese Richtlinie regelt Identifikation, Bewertung und Behandlung von Informationssicherheitsrisiken sowie die interne und unabhaengige Ueberpruefung des ISMS.", + related=["R01","R04"], + roles=[("{{ROLE_ISB}}","Steuerung des Risikomanagements, Pflege des Risikoregisters"), + ("{{ROLE_MANAGEMENT}}","Entscheidung ueber Risikoakzeptanz"), + ("Asset/Prozessverantwortliche","Mitwirkung bei Risikobewertung")], + controls=[ + {"num":"1.4.1","title":"Risikomanagement","reqs":[ + {"t":"M","req":"Es existiert ein dokumentiertes Verfahren zur Identifikation, Analyse, Bewertung und Behandlung von Informationssicherheitsrisiken.", + "impl":"Das Risikomanagement-Verfahren ist dokumentiert; Risiken werden im ISMS-Tool ({{TOOL_NAME}}) bewertet und nachverfolgt."}, + {"t":"M","req":"Risiken werden in einem Risikoregister erfasst; Behandlungsoptionen und Massnahmen sind festgelegt.", + "impl":"Alle Risiken werden im Risikoregister erfasst; je Risiko sind Behandlungsoption (reduzieren/vermeiden/uebertragen/akzeptieren) und Massnahmen hinterlegt."}, + {"t":"M","req":"Die Risikobewertung wird regelmaessig und anlassbezogen aktualisiert; die Risikoakzeptanz erfolgt durch die Leitung.", + "impl":"Die Bewertung wird mindestens {{REVIEW_CYCLE}} und anlassbezogen aktualisiert; die {{ROLE_MANAGEMENT}} akzeptiert Restrisiken dokumentiert."}, + {"t":"S","req":"Kriterien fuer Eintrittswahrscheinlichkeit, Schadenshoehe und Akzeptanzschwellen sind definiert.", + "impl":"Bewertungs- und Akzeptanzkriterien sind definiert und im ISMS-Tool hinterlegt."}, + ]}, + {"num":"1.5.1","title":"Compliance-Pruefung im IS-Betrieb","reqs":[ + {"t":"M","req":"Die Einhaltung der Informationssicherheitsvorgaben wird regelmaessig geprueft.", + "impl":"Die Einhaltung wird durch interne Audits und Kontrollen regelmaessig geprueft."}, + {"t":"S","req":"Ein Auditprogramm mit Umfang, Turnus und Verantwortlichkeiten ist etabliert; Feststellungen werden nachverfolgt.", + "impl":"Ein Auditprogramm ist etabliert; Feststellungen werden im ISMS-Tool nachverfolgt."}, + ]}, + {"num":"1.5.2","title":"Unabhaengige Ueberpruefung","reqs":[ + {"t":"M","req":"Das ISMS wird durch eine unabhaengige Stelle ueberprueft.", + "impl":"Das ISMS wird durch eine unabhaengige Stelle (interne Revision oder externe Auditierung) ueberprueft."}, + {"t":"S","req":"Ergebnisse fliessen in die Managementbewertung und den Verbesserungsprozess ein.", + "impl":"Die Ergebnisse werden in der Managementbewertung behandelt und fliessen in Verbesserungsmassnahmen ein."}, + ]}, + ]) + +pol(id="R04", fn="R04_Incident-Notfall-und-Kontinuitaetsrichtlinie", + title="Incident-, Notfall- und Kontinuitaetsrichtlinie", owner="ROLE_ISB", + purpose="Diese Richtlinie regelt Meldung und Behandlung von Sicherheitsereignissen, das Krisenmanagement sowie die Notfall- und Kontinuitaetsplanung fuer IT-Dienste.", + related=["R03","R10"], + roles=[("{{ROLE_ISB}}","Koordination der Vorfallsbehandlung"), + ("{{ROLE_IT_LEAD}}","IT-Notfall- und Wiederanlaufplanung"), + ("{{ROLE_MANAGEMENT}}","Einberufung Krisenstab")], + controls=[ + {"num":"1.6.1","title":"Meldung von Ereignissen","reqs":[ + {"t":"M","req":"Sicherheitsrelevante Ereignisse und Beobachtungen koennen ueber einen definierten Meldeweg gemeldet werden.", + "impl":"Ein Meldeweg fuer Sicherheitsereignisse ist eingerichtet (z. B. im ISMS-Tool {{TOOL_NAME}}) und bekannt gemacht."}, + {"t":"M","req":"Der Meldeweg ist bekannt gemacht und niedrigschwellig erreichbar.", + "impl":"Der Meldeweg ist allen Mitarbeitenden bekannt und niedrigschwellig erreichbar."}, + {"t":"S","req":"Meldungen werden zentral erfasst und kategorisiert.", + "impl":"Meldungen werden zentral im ISMS-Tool erfasst und kategorisiert."}, + ]}, + {"num":"1.6.2","title":"Behandlung von Sicherheitsereignissen","reqs":[ + {"t":"M","req":"Gemeldete Sicherheitsereignisse werden bewertet, priorisiert, behandelt und dokumentiert.", + "impl":"Ereignisse werden nach einem definierten Verfahren bewertet, priorisiert, behandelt und im ISMS-Tool dokumentiert."}, + {"t":"M","req":"Verantwortlichkeiten und Eskalationswege fuer die Vorfallsbehandlung sind definiert.", + "impl":"Verantwortlichkeiten und Eskalationswege sind definiert; {{ROLE_ISB}} koordiniert die Behandlung."}, + {"t":"S","req":"Erkenntnisse aus Vorfaellen werden ausgewertet (Lessons Learned) und fuehren zu Verbesserungen.", + "impl":"Nach relevanten Vorfaellen erfolgt eine Auswertung (Lessons Learned) mit Ableitung von Verbesserungen."}, + {"t":"S","req":"Meldepflichten (z. B. an Kunden/OEM, Behoerden) sind beruecksichtigt.", + "impl":"Bestehende Meldepflichten gegenueber Kunden/OEM und Behoerden werden im Behandlungsprozess beruecksichtigt."}, + ]}, + {"num":"1.6.3","title":"Krisenmanagement","reqs":[ + {"t":"M","req":"Die Organisation ist auf die Bewaeltigung von Krisensituationen vorbereitet (Rollen, Kommunikation, Entscheidungswege).", + "impl":"Ein Krisenmanagement mit Rollen, Kommunikations- und Entscheidungswegen ist definiert; der Krisenstab wird durch die {{ROLE_MANAGEMENT}} einberufen."}, + {"t":"S","req":"Krisen-/Notfallplaene werden regelmaessig geuebt und aktualisiert.", + "impl":"Krisen- und Notfallplaene werden mindestens {{REVIEW_CYCLE}} geuebt und aktualisiert."}, + ]}, + {"num":"5.2.8","title":"Kontinuitaetsplanung IT","reqs":[ + {"t":"M","req":"Fuer kritische IT-Dienste besteht eine Kontinuitaetsplanung (Wiederanlaufziele, Verantwortliche, Massnahmen).", + "impl":"Fuer kritische IT-Dienste bestehen Wiederanlaufziele, Verantwortliche und Massnahmen; {{ROLE_IT_LEAD}} verantwortet die Planung."}, + {"t":"S","req":"Wiederanlaufmassnahmen werden regelmaessig getestet; Ergebnisse werden dokumentiert.", + "impl":"Wiederanlaufmassnahmen werden mindestens {{REVIEW_CYCLE}} getestet; Ergebnisse werden dokumentiert."}, + ]}, + ]) + +pol(id="R05", fn="R05_Personalsicherheit-und-Awareness", + title="Personalsicherheit und Awareness", owner="ROLE_HR_LEAD", + purpose="Diese Richtlinie regelt Eignung und Qualifikation fuer sicherheitsrelevante Taetigkeiten, die vertragliche Verpflichtung des Personals sowie Schulung und Sensibilisierung.", + related=["R01","R06"], + roles=[("{{ROLE_HR_LEAD}}","Vertragliche Verpflichtung, Eignungspruefungen"), + ("{{ROLE_ISB}}","Inhalte und Nachweis von Schulung und Awareness"), + ("Fuehrungskraefte","Umsetzung im Verantwortungsbereich")], + controls=[ + {"num":"2.1.1","title":"Qualifikation fuer sensible Taetigkeiten","reqs":[ + {"t":"M","req":"Fuer sicherheitsrelevante/sensible Taetigkeiten ist die erforderliche Qualifikation und Zuverlaessigkeit der Beschaeftigten sichergestellt.", + "impl":"Fuer sensible Taetigkeiten werden Qualifikation und Zuverlaessigkeit im rechtlich zulaessigen Rahmen sichergestellt."}, + {"t":"S","req":"Anforderungen an Positionen sind beschrieben; angemessene Ueberpruefungen erfolgen im rechtlich zulaessigen Rahmen.", + "impl":"Sicherheitsanforderungen an Positionen sind beschrieben; Ueberpruefungen erfolgen anlassbezogen."}, + ]}, + {"num":"2.1.2","title":"Vertragliche Verpflichtung","reqs":[ + {"t":"M","req":"Alle Beschaeftigten sind vertraglich zur Einhaltung der Informationssicherheit und zur Vertraulichkeit verpflichtet.", + "impl":"Alle Beschaeftigten werden bei Eintritt vertraglich zur Vertraulichkeit und Einhaltung der Informationssicherheit verpflichtet."}, + {"t":"S","req":"Verpflichtungen gelten auch nach Beendigung des Arbeitsverhaeltnisses fort und umfassen Rueckgabepflichten.", + "impl":"Die Vertraulichkeitsverpflichtung gilt nachvertraglich fort; Rueckgabepflichten sind geregelt."}, + ]}, + {"num":"2.1.3","title":"Sensibilisierung und Schulung","reqs":[ + {"t":"M","req":"Beschaeftigte werden hinsichtlich Informationssicherheit sensibilisiert und geschult.", + "impl":"Beschaeftigte werden bei Eintritt und danach mindestens {{REVIEW_CYCLE}} geschult; Nachweise werden im ISMS-Tool ({{TOOL_NAME}}) gefuehrt."}, + {"t":"S","req":"Schulungsinhalte sind rollenspezifisch; die Wirksamkeit wird ueberprueft (z. B. Phishing-Tests).", + "impl":"Schulungen sind rollenspezifisch; die Wirksamkeit wird z. B. durch Phishing-Simulationen ueberprueft."}, + ]}, + ]) + +pol(id="R06", fn="R06_Mobiles-Arbeiten-und-mobile-Geraete", + title="Mobiles Arbeiten und mobile Geraete", owner="ROLE_ISB", + purpose="Diese Richtlinie regelt mobiles Arbeiten (Homeoffice/Telearbeit) sowie den sicheren Umgang mit mobilen IT-Geraeten und Datentraegern.", + related=["R05","R07","R08"], + roles=[("{{ROLE_ISB}}","Festlegung der Sicherheitsanforderungen"), + ("{{ROLE_IT_LEAD}}","Technische Umsetzung (VPN, MDM)"), + ("Mitarbeitende","Einhaltung der Vorgaben")], + controls=[ + {"num":"2.1.4","title":"Mobiles Arbeiten","flag":"FLAG_MOBILE_WORK","reqs":[ + {"t":"M","req":"Mobiles Arbeiten ist geregelt (zulaessige Orte, Umgang mit Informationen, Absicherung der Verbindung).", + "impl":"Mobiles Arbeiten ist geregelt; der Zugriff erfolgt ueber gesicherte Verbindungen ({{TECH_VPN}}) und freigegebene Geraete."}, + {"t":"M","req":"Der Zugriff auf Unternehmensinformationen erfolgt ausschliesslich ueber gesicherte Verbindungen und freigegebene Geraete.", + "impl":"Der Zugriff auf Unternehmensinformationen ist auf freigegebene, abgesicherte Geraete beschraenkt."}, + {"t":"S","req":"Sichtschutz, Clean-Desk/Clean-Screen und Regeln fuer oeffentliche Umgebungen sind definiert.", + "impl":"Regeln zu Sichtschutz, Clean-Desk/Clean-Screen und zum Arbeiten in oeffentlichen Umgebungen sind definiert."}, + ]}, + {"num":"3.1.4","title":"Mobile Geraete und Datentraeger","flag":"FLAG_MOBILE_DEVICES","reqs":[ + {"t":"M","req":"Der Umgang mit mobilen IT-Geraeten und mobilen Datentraegern ist geregelt (Verschluesselung, Verlustmeldung, Freigabe).", + "impl":"Mobile Geraete sind verschluesselt und ueber {{TECH_MDM}} verwaltet; Verlustmeldung und Freigabe sind geregelt."}, + {"t":"M","req":"Mobile Geraete sind verschluesselt und koennen bei Verlust gesperrt/geloescht werden.", + "impl":"Bei Verlust koennen Geraete ueber {{TECH_MDM}} gesperrt und geloescht werden."}, + {"t":"S","req":"Der Einsatz privater Geraete (BYOD) ist geregelt oder untersagt; Wechseldatentraeger werden kontrolliert.", + "impl":"Der Einsatz privater Geraete ist geregelt; Wechseldatentraeger werden kontrolliert und nur verschluesselt zugelassen."}, + ]}, + ]) + +pol(id="R07", fn="R07_Physische-Sicherheit", + title="Physische Sicherheit", owner="ROLE_IT_LEAD", + purpose="Diese Richtlinie regelt den physischen Schutz von Informationen und informationsverarbeitenden Einrichtungen durch Sicherheitszonen, Zutrittsschutz und den Umgang mit unterstuetzenden Betriebsmitteln.", + related=["R02","R06"], + roles=[("{{ROLE_IT_LEAD}}","Zonenkonzept, Zutrittsschutz, Betriebsmittel"), + ("{{ROLE_ISB}}","Vorgabe der Anforderungen")], + controls=[ + {"num":"3.1.1","title":"Sicherheitszonen und Zutritt","reqs":[ + {"t":"M","req":"Sicherheitszonen sind definiert und der Zutritt zu schuetzenswerten Bereichen ist reglementiert und nachvollziehbar.", + "impl":"Sicherheitszonen sind definiert; der Zutritt zu schuetzenswerten Bereichen ist reglementiert und wird protokolliert."}, + {"t":"M","req":"Zutrittsrechte werden nach Bedarf vergeben, dokumentiert und bei Wegfall entzogen.", + "impl":"Zutrittsrechte werden bedarfsorientiert vergeben, dokumentiert und bei Wegfall entzogen."}, + {"t":"S","req":"Zutritte werden protokolliert; Besucher werden begleitet; technische Schutzmassnahmen sind vorhanden.", + "impl":"Besucher werden registriert und begleitet; technische Schutzmassnahmen (z. B. Alarm/Video im rechtlichen Rahmen) sind vorhanden."}, + ]}, + {"num":"3.1.3","title":"Umgang mit unterstuetzenden Betriebsmitteln","reqs":[ + {"t":"M","req":"Der Umgang mit unterstuetzenden Assets (z. B. Verkabelung, Strom-/Klimaversorgung, Serverraeume) ist geregelt und schuetzt vor Ausfall und unbefugtem Zugriff.", + "impl":"Serverraeume und Versorgungseinrichtungen sind zutrittsgeschuetzt und gegen Ausfall abgesichert."}, + {"t":"S","req":"Versorgungseinrichtungen werden gewartet und ueberwacht; Redundanzen bestehen fuer kritische Bereiche.", + "impl":"Versorgungseinrichtungen werden gewartet und ueberwacht; fuer kritische Bereiche bestehen Redundanzen (z. B. USV)."}, + ]}, + ]) + +pol(id="R08", fn="R08_Identitaets-und-Zugriffsmanagement", + title="Identitaets- und Zugriffsmanagement", owner="ROLE_IT_LEAD", + purpose="Diese Richtlinie regelt Identifikationsmittel, die sichere Anmeldung, die Verwaltung von Benutzerkonten und Anmeldeinformationen sowie die Vergabe und Kontrolle von Zugriffsrechten.", + related=["R02","R05","R10"], + roles=[("{{ROLE_IT_LEAD}}","Technische Umsetzung IAM"), + ("Fachbereiche","Fachliche Freigabe von Berechtigungen"), + ("{{ROLE_ISB}}","Ueberwachung der Einhaltung")], + controls=[ + {"num":"4.1.1","title":"Identifikationsmittel","reqs":[ + {"t":"M","req":"Der Einsatz von Identifikationsmitteln (Benutzerkennungen, Token, Zertifikate) ist geregelt und eindeutig personenbezogen.", + "impl":"Identifikationsmittel werden eindeutig personenbezogen vergeben; Sammelkonten werden vermieden."}, + {"t":"S","req":"Ausgabe, Ruecknahme und Sperrung von Identifikationsmitteln sind dokumentiert.", + "impl":"Ausgabe, Ruecknahme und Sperrung werden dokumentiert."}, + ]}, + {"num":"4.1.2","title":"Sichere Anmeldung","reqs":[ + {"t":"M","req":"Der Zugang zu IT-Diensten und IT-Systemen ist durch sichere Authentifizierungsverfahren geschuetzt.", + "impl":"Der Zugang ist durch sichere Authentifizierung geschuetzt; Passwortanforderungen sind zentral vorgegeben."}, + {"t":"M","req":"Fuer erhoehten Schutzbedarf und Fernzugriffe wird Mehr-Faktor-Authentifizierung (MFA) eingesetzt.", + "impl":"Fuer Fernzugriffe und erhoehten Schutzbedarf wird MFA ueber {{TECH_MFA}} durchgesetzt."}, + {"t":"S","req":"Passwortanforderungen, Sperrmechanismen und Sitzungsverwaltung sind definiert.", + "impl":"Passwortrichtlinie, Sperrmechanismen und Sitzungs-Timeouts sind zentral konfiguriert."}, + ]}, + {"num":"4.1.3","title":"Konten und Anmeldeinformationen","reqs":[ + {"t":"M","req":"Benutzerkonten und Anmeldeinformationen werden sicher verwaltet (Erstellung, Aenderung, Sperrung, Loeschung).", + "impl":"Konten werden ueber einen definierten Lebenszyklus (Joiner/Mover/Leaver) verwaltet."}, + {"t":"S","req":"Privilegierte und technische Konten werden gesondert verwaltet und ueberwacht.", + "impl":"Privilegierte und technische Konten werden gesondert verwaltet und ihre Nutzung ueberwacht."}, + ]}, + {"num":"4.2.1","title":"Zugriffsrechte","reqs":[ + {"t":"M","req":"Zugriffsrechte werden nach dem Minimalprinzip (need-to-know / least privilege) vergeben; Verfahren fuer Antrag, Pruefung und Genehmigung bestehen.", + "impl":"Zugriffsrechte werden nach dem Minimalprinzip vergeben; Antrag, Pruefung und Genehmigung erfolgen ueber ein definiertes Verfahren."}, + {"t":"M","req":"Zugriffsrechte werden bei Wegfall des Bedarfs entzogen und regelmaessig ueberprueft (Rezertifizierung){{IF_CUSTOMER}}.", + "impl":"Berechtigungen werden bei Wegfall entzogen und mindestens {{REVIEW_CYCLE}} rezertifiziert{{IF_CUSTOMER_IMPL}}."}, + {"t":"S","req":"Berechtigungen werden ueber Rollen vergeben; normale Konten erhalten keine privilegierten Rechte.", + "impl":"Berechtigungen werden rollenbasiert vergeben; Standardkonten erhalten keine privilegierten Rechte."}, + ]}, + ]) + +pol(id="R09", fn="R09_Kryptografie-und-Uebertragungsrichtlinie", + title="Kryptografie- und Uebertragungsrichtlinie", owner="ROLE_IT_LEAD", + purpose="Diese Richtlinie regelt den Einsatz kryptografischer Verfahren, die Schluesselverwaltung sowie den Schutz von Informationen bei der Uebertragung.", + related=["R08","R10","R12"], + roles=[("{{ROLE_IT_LEAD}}","Verfahren und Schluesselverwaltung"), + ("{{ROLE_ISB}}","Vorgabe zulaessiger Algorithmen/Staerken")], + controls=[ + {"num":"5.1.1","title":"Einsatz kryptografischer Verfahren","reqs":[ + {"t":"M","req":"Der Einsatz von Kryptografie ist geregelt; zulaessige Verfahren und Schluessellaengen entsprechen dem Stand der Technik.", + "impl":"Zulaessige Verfahren und Schluessellaengen entsprechen dem Stand der Technik ({{TECH_CRYPTO}}) und sind vorgegeben."}, + {"t":"M","req":"Schluessel werden ueber ihren gesamten Lebenszyklus sicher verwaltet.", + "impl":"Schluessel werden ueber ihren Lebenszyklus (Erzeugung, Verteilung, Speicherung, Sperrung, Vernichtung) sicher verwaltet."}, + {"t":"S","req":"Ein Kryptokonzept ist dokumentiert{{IF_PKI}}.", + "impl":"Ein Kryptokonzept ist dokumentiert{{IF_PKI_IMPL}}."}, + ]}, + {"num":"5.1.2","title":"Schutz bei Uebertragung","reqs":[ + {"t":"M","req":"Informationen werden abhaengig vom Schutzbedarf bei der Uebertragung geschuetzt (z. B. Transportverschluesselung, gesicherte Kanaele).", + "impl":"Informationen werden schutzbedarfsgerecht per Transportverschluesselung (z. B. TLS) und gesicherte Kanaele geschuetzt."}, + {"t":"S","req":"Regeln fuer sichere Uebertragungswege (E-Mail-Verschluesselung, sichere Dateiuebertragung) sind definiert.", + "impl":"Regeln fuer E-Mail-Verschluesselung und sichere Dateiuebertragung sind definiert."}, + ]}, + ]) + +pol(id="R10", fn="R10_Betriebssicherheit", + title="Betriebssicherheit", owner="ROLE_IT_LEAD", + purpose="Diese Richtlinie regelt den sicheren IT-Betrieb: Change-Management, Trennung von Umgebungen, Malware-Schutz, Protokollierung, Schwachstellen- und Patch-Management, technische Pruefungen, Netzwerksicherheit sowie Datensicherung und Wiederherstellung.", + related=["R04","R08","R11"], + roles=[("{{ROLE_IT_LEAD}}","Sicherer IT-Betrieb"), + ("{{ROLE_ISB}}","Ueberwachung der Einhaltung")], + controls=[ + {"num":"5.2.1","title":"Change-Management","reqs":[ + {"t":"M","req":"Aenderungen an IT-Systemen werden geregelt beantragt, bewertet, getestet, genehmigt und dokumentiert.", + "impl":"Aenderungen durchlaufen ein Change-Verfahren mit Bewertung, Test, Genehmigung und Dokumentation."}]}, + {"num":"5.2.2","title":"Trennung der Umgebungen","reqs":[ + {"t":"M","req":"Entwicklungs-, Test- und Produktionsumgebungen sind getrennt.", + "impl":"Entwicklung, Test und Produktion sind getrennt betrieben."}, + {"t":"S","req":"Produktivdaten werden nicht ungeschuetzt in Test-/Entwicklungsumgebungen verwendet.", + "impl":"Produktivdaten werden in Test-/Entwicklungsumgebungen nur anonymisiert/pseudonymisiert genutzt."}]}, + {"num":"5.2.3","title":"Schutz vor Malware","reqs":[ + {"t":"M","req":"Anforderungen zum Schutz vor Schadsoftware sind bestimmt; technische und organisatorische Massnahmen sind umgesetzt.", + "impl":"Malware-Schutz ist ueber {{TECH_MALWARE}} auf allen relevanten Systemen umgesetzt."}, + {"t":"S","req":"Schutzsoftware wird automatisch aktualisiert; unnoetige Netzwerkdienste sind deaktiviert.", + "impl":"Schutzsoftware aktualisiert sich automatisch; unnoetige Netzwerkdienste sind deaktiviert."}]}, + {"num":"5.2.4","title":"Protokollierung und Auswertung","reqs":[ + {"t":"M","req":"Sicherheitsrelevante Ereignisse werden protokolliert und ausgewertet.", + "impl":"Sicherheitsrelevante Ereignisse werden protokolliert und ueber {{TECH_SIEM}} ausgewertet."}, + {"t":"S","req":"Protokolle sind vor Manipulation geschuetzt; Aufbewahrungsfristen sind definiert.", + "impl":"Protokolle sind manipulationsgeschuetzt; Aufbewahrungsfristen sind definiert."}]}, + {"num":"5.2.5","title":"Schwachstellen- und Patch-Management","reqs":[ + {"t":"M","req":"Schwachstellen werden identifiziert und risikoorientiert behoben (Patch-Management).", + "impl":"Schwachstellen werden erfasst und risikoorientiert gepatcht; kritische Patches werden priorisiert."}, + {"t":"S","req":"Es besteht ein regelmaessiges Schwachstellen-Scanning; kritische Patches werden priorisiert.", + "impl":"Ein regelmaessiges Schwachstellen-Scanning ist etabliert."}]}, + {"num":"5.2.6","title":"Technische Ueberpruefung","reqs":[ + {"t":"M","req":"IT-Systeme und Dienste werden technisch ueberprueft (z. B. Systemhaertung, Penetrationstests).", + "impl":"Systeme werden gehaertet und risikoorientiert technisch geprueft (z. B. Penetrationstests)."}]}, + {"num":"5.2.7","title":"Netzwerksicherheit","reqs":[ + {"t":"M","req":"Das Netzwerk wird gesteuert und abgesichert (Segmentierung, Zugangskontrolle, Absicherung nach aussen).", + "impl":"Das Netzwerk ist segmentiert, zugangskontrolliert und nach aussen abgesichert (Firewall)."}, + {"t":"M","req":"{{IF_OT}}Produktions-/OT-Netze sind von Office-Netzen getrennt und besonders abgesichert.", + "impl":"{{IF_OT}}Produktions-/OT-Netze sind von Office-Netzen getrennt und besonders abgesichert.","cond":"FLAG_OT_USED"}, + {"t":"S","req":"Ein aktueller Netzplan und ein Segmentierungskonzept liegen vor.", + "impl":"Ein aktueller Netzplan und ein Segmentierungskonzept werden gepflegt."}]}, + {"num":"5.2.9","title":"Backup und Wiederherstellung","reqs":[ + {"t":"M","req":"Daten und IT-Dienste werden gesichert; Wiederherstellung ist geregelt.", + "impl":"Daten und Dienste werden ueber {{TECH_BACKUP}} gesichert; die Wiederherstellung ist geregelt."}, + {"t":"M","req":"Wiederherstellungstests werden regelmaessig durchgefuehrt.", + "impl":"Wiederherstellungstests werden mindestens {{REVIEW_CYCLE}} durchgefuehrt und dokumentiert."}, + {"t":"S","req":"Backups werden geschuetzt/ausgelagert aufbewahrt (z. B. offline/immutable).", + "impl":"Backups werden geschuetzt und ausgelagert (offline/immutable) aufbewahrt."}]}, + ]) + +pol(id="R11", fn="R11_Sichere-Systembeschaffung-und-Entwicklung", + title="Sichere Systembeschaffung und Entwicklung", owner="ROLE_IT_LEAD", + purpose="Diese Richtlinie regelt die Beruecksichtigung der Informationssicherheit bei Beschaffung und Weiterentwicklung von IT-Systemen, Anforderungen an Netzdienste sowie Rueckgabe und sichere Loeschung von Informationen.", + related=["R02","R10","R12"], + roles=[("{{ROLE_IT_LEAD}}","Beschaffung/Entwicklung"), + ("{{ROLE_ISB}}","Definition Sicherheitsanforderungen")], + controls=[ + {"num":"5.3.1","title":"Sicherheit bei Beschaffung/Entwicklung","reqs":[ + {"t":"M","req":"Bei Beschaffung oder Weiterentwicklung von IT-Systemen werden Informationssicherheitsanforderungen ermittelt und beruecksichtigt.", + "impl":"Sicherheitsanforderungen sind fester Bestandteil von Beschaffungs- und Aenderungsprozessen (Security by Design)."}, + {"t":"M","req":"{{IF_DEV}}Fuer die Eigenentwicklung gelten Vorgaben fuer sichere Entwicklung (Secure Coding, Tests, Freigaben).", + "impl":"{{IF_DEV}}Fuer die Eigenentwicklung gelten Secure-Coding-Vorgaben mit Tests und Freigaben.","cond":"FLAG_DEV_INHOUSE"}, + {"t":"S","req":"Sicherheitsanforderungen sind Bestandteil des Beschaffungs-/Entwicklungsprozesses (Security by Design).", + "impl":"Sicherheitsanforderungen werden dokumentiert und ihre Umsetzung vor Freigabe geprueft."}]}, + {"num":"5.3.2","title":"Anforderungen an Netzdienste","reqs":[ + {"t":"M","req":"Sicherheitsanforderungen an Netzdienste (intern und extern) sind definiert.", + "impl":"Fuer genutzte Netzdienste sind Sicherheitsanforderungen definiert und vereinbart."}]}, + {"num":"5.3.3","title":"Rueckgabe und sichere Loeschung","reqs":[ + {"t":"M","req":"Rueckgabe und sichere Entfernung/Loeschung von Informationen und Assets sind geregelt.", + "impl":"Rueckgabe und sichere Loeschung (bei Vertragsende, Geraeteausmusterung) sind geregelt und werden nachgewiesen."}, + {"t":"S","req":"Loeschverfahren entsprechen dem Schutzbedarf; Loeschungen werden nachgewiesen.", + "impl":"Loeschverfahren richten sich nach dem Schutzbedarf; Loeschungen werden dokumentiert."}]}, + ]) + +pol(id="R12", fn="R12_Cloud-KI-und-externe-IT-Dienste", + title="Cloud-, KI- und externe IT-Dienste", owner="ROLE_ISB", + purpose="Diese Richtlinie regelt den Schutz von Informationen bei der Nutzung ausgelagerter oder geteilter externer IT-Dienste (Cloud) sowie beim Einsatz von KI-/GenAI-Diensten, einschliesslich Auswahl, Freigabe, zulaessiger Nutzung und Datenpreisgabe.", + related=["R09","R11","R13"], + roles=[("{{ROLE_ISB}}","Freigabe Cloud-/KI-Dienste, Pflege der Freigabeliste"), + ("{{ROLE_IT_LEAD}}","Technische Absicherung"), + ("Fachbereiche","Nutzung nur freigegebener Dienste")], + controls=[ + {"num":"5.3.4","title":"Externe/geteilte IT-Dienste und Cloud","reqs":[ + {"t":"M","req":"Bei geteilten externen IT-Diensten ist durch wirksame Mandantentrennung sichergestellt, dass Unbefugte anderer Organisationen nicht auf eigene Informationen zugreifen koennen.", + "impl":"Bei geteilten Diensten wird auf eine wirksame Mandantentrennung geachtet und diese vertraglich zugesichert."}, + {"t":"M","req":"{{IF_CLOUD}}Cloud-Dienste werden vor Nutzung bewertet und freigegeben; nur freigegebene Dienste werden fuer Unternehmensinformationen genutzt.", + "impl":"{{IF_CLOUD}}Cloud-Dienste werden vor Nutzung bewertet (Schutzbedarf, Datenlokation, Exit) und freigegeben; die Freigabeliste wird im ISMS-Tool ({{TOOL_NAME}}) gepflegt.","cond":"FLAG_CLOUD_USED"}, + {"t":"S","req":"Das Segregationskonzept des Anbieters ist dokumentiert und wird bei Aenderungen angepasst.", + "impl":"Das Segregationskonzept des Anbieters wird dokumentiert und bei Aenderungen aktualisiert."}]}, + {"num":"5.3.4-KI","title":"Nutzung von KI-/GenAI-Diensten","flag":"FLAG_AI_USED","reqs":[ + {"t":"M","req":"Der Einsatz von KI-/GenAI-Diensten ist geregelt; es werden nur freigegebene Dienste genutzt.", + "impl":"Der Einsatz von KI-/GenAI-Diensten ist geregelt; nur freigegebene Dienste (Freigabeliste im ISMS-Tool) duerfen genutzt werden."}, + {"t":"M","req":"Die Eingabe vertraulicher oder personenbezogener Informationen in nicht freigegebene KI-Dienste ist untersagt; zulaessige Datenklassen je Dienst sind definiert.", + "impl":"Zulaessige Datenklassen je KI-Dienst sind definiert; die Eingabe vertraulicher/personenbezogener Daten in nicht freigegebene Dienste ist untersagt."}, + {"t":"M","req":"Bei freigegebenen KI-Diensten ist geklaert, ob Eingaben zum Training genutzt werden; eine Trainings-/Weitergabe von Unternehmensdaten wird ausgeschlossen oder vertraglich untersagt.", + "impl":"Bei Freigabe wird geprueft und vertraglich sichergestellt, dass Eingaben nicht zum Training genutzt oder weitergegeben werden."}, + {"t":"S","req":"Ergebnisse werden vor geschaeftskritischer Verwendung geprueft (Human-in-the-Loop); der KI-Einsatz wird dokumentiert; regulatorische Anforderungen (z. B. EU AI Act) werden beruecksichtigt.", + "impl":"KI-Ergebnisse werden vor kritischer Verwendung durch Menschen geprueft; der KI-Einsatz wird dokumentiert und regulatorische Anforderungen (EU AI Act) beruecksichtigt."}]}, + ]) + +pol(id="R13", fn="R13_Lieferanten-und-Dienstleistersteuerung", + title="Lieferanten- und Dienstleistersteuerung", owner="ROLE_ISB", + purpose="Diese Richtlinie regelt die Sicherstellung der Informationssicherheit bei Auftragnehmern und Lieferanten, Vertraulichkeitsvereinbarungen sowie die Abgrenzung von Verantwortlichkeiten mit externen IT-Dienstleistern.", + related=["R01","R12"], + roles=[("{{ROLE_ISB}}","Steuerung der Lieferantensicherheit, Pflege Lieferantenverzeichnis"), + ("Einkauf","Vertragliche Einbindung der Anforderungen")], + controls=[ + {"num":"6.1.1","title":"Informationssicherheit bei Lieferanten","reqs":[ + {"t":"M","req":"Informationssicherheitsanforderungen an Auftragnehmer/Lieferanten sind ermittelt und werden vertraglich vereinbart und ueberwacht.", + "impl":"Sicherheitsanforderungen an Lieferanten werden ermittelt, vertraglich vereinbart und ueberwacht; das Lieferantenverzeichnis wird im ISMS-Tool ({{TOOL_NAME}}) gepflegt."}, + {"t":"M","req":"Lieferanten werden risikoorientiert bewertet.", + "impl":"Lieferanten werden risikoorientiert (nach Schutzbedarf und Zugriff) bewertet."}, + {"t":"S","req":"Die Einhaltung der Anforderungen wird regelmaessig ueberprueft (z. B. Nachweise, Audits, TISAX-Label).", + "impl":"Die Einhaltung wird regelmaessig ueberprueft (Nachweise, Audits, TISAX-Label)."}]}, + {"num":"6.1.2","title":"Vertraulichkeit","reqs":[ + {"t":"M","req":"Der Austausch von Informationen mit Externen ist durch Vertraulichkeitsvereinbarungen (NDA) abgesichert.", + "impl":"Vor dem Austausch schutzbeduerftiger Informationen werden NDAs abgeschlossen."}, + {"t":"S","req":"NDA-Vorlagen sind standardisiert; Geltungsdauer und Rueckgabe-/Loeschpflichten sind geregelt.", + "impl":"Standardisierte NDA-Vorlagen mit Geltungsdauer und Rueckgabe-/Loeschpflichten werden verwendet."}]}, + {"num":"6.1.3","title":"Abgrenzung der Verantwortlichkeiten","reqs":[ + {"t":"M","req":"{{IF_EXTIT}}Verantwortlichkeiten zwischen der Organisation und externen IT-Dienstleistern sind klar abgegrenzt und dokumentiert.", + "impl":"{{IF_EXTIT}}Die Verantwortlichkeiten mit externen IT-Dienstleistern (Betriebs-, Sicherheits-, Meldepflichten) sind abgegrenzt und dokumentiert.","cond":"FLAG_EXTERNAL_IT"}, + {"t":"S","req":"Schnittstellen, Eskalations- und Meldewege mit Dienstleistern sind vereinbart.", + "impl":"Schnittstellen sowie Eskalations- und Meldewege sind vertraglich vereinbart."}]}, + ]) + +pol(id="R14", fn="R14_Compliance-und-Datenschutz", + title="Compliance und Datenschutz", owner="ROLE_ISB", + purpose="Diese Richtlinie regelt die Einhaltung regulatorischer und vertraglicher Vorgaben sowie den Schutz personenbezogener Daten.", + related=["L00","R03"], + roles=[("{{ROLE_ISB}}","Compliance-Register"), + ("{{ROLE_DPO}}","Datenschutz")], + controls=[ + {"num":"7.1.1","title":"Regulatorische und vertragliche Compliance","reqs":[ + {"t":"M","req":"Relevante gesetzliche, regulatorische und vertragliche Anforderungen an die Informationssicherheit sind identifiziert, dokumentiert und werden eingehalten.", + "impl":"Relevante Anforderungen werden in einem Compliance-/Rechtsregister im ISMS-Tool ({{TOOL_NAME}}) erfasst und ihre Einhaltung nachverfolgt."}, + {"t":"S","req":"Ein Compliance-/Rechtsregister wird gepflegt und regelmaessig aktualisiert; Verantwortliche sind benannt.", + "impl":"Das Register wird mindestens {{REVIEW_CYCLE}} aktualisiert; Verantwortliche sind benannt."}]}, + {"num":"7.1.2","title":"Schutz personenbezogener Daten","flag":"FLAG_PERSONAL_DATA","reqs":[ + {"t":"M","req":"Beim Umgang mit personenbezogenen Daten werden die datenschutzrechtlichen Anforderungen (z. B. DSGVO) beruecksichtigt.", + "impl":"Datenschutzrechtliche Anforderungen (DSGVO) werden beruecksichtigt; {{ROLE_DPO}} ist eingebunden."}, + {"t":"M","req":"Ein Verzeichnis der Verarbeitungstaetigkeiten wird gefuehrt.", + "impl":"Das Verzeichnis der Verarbeitungstaetigkeiten wird im ISMS-Tool ({{TOOL_NAME}}) gefuehrt."}, + {"t":"S","req":"Technische und organisatorische Massnahmen (TOM), Loeschkonzepte und Betroffenenrechte sind geregelt.", + "impl":"TOM, Loeschkonzepte und Prozesse fuer Betroffenenrechte sind geregelt."}]}, + ]) + +# --------------------------------------------------------------------------- +# Inline-Bedingungsersetzungen (Feature-Flags in Req/Impl-Text) +# --------------------------------------------------------------------------- +INLINE = { + "{{IF_CUSTOMER}}":"{{#if FLAG_CUSTOMER_SYSTEMS}}, auch fuer Zugriffe in Kundensystemen{{/if}}", + "{{IF_CUSTOMER_IMPL}}":"{{#if FLAG_CUSTOMER_SYSTEMS}}, auch fuer Zugriffe in Kundensystemen{{/if}}", + "{{IF_PKI}}":"{{#if FLAG_CRYPTO_PKI}} und eine PKI/Zertifikatsverwaltung ist etabliert{{/if}}", + "{{IF_PKI_IMPL}}":"{{#if FLAG_CRYPTO_PKI}}; eine PKI/Zertifikatsverwaltung ist etabliert{{/if}}", + "{{IF_OT}}":"", "{{IF_DEV}}":"", "{{IF_CLOUD}}":"", "{{IF_EXTIT}}":"", +} +def inline(s): + for k,v in INLINE.items(): s=s.replace(k,v) + return s + +# --------------------------------------------------------------------------- +# Rendering +# --------------------------------------------------------------------------- +META = """# Richtlinie {title} + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{{{ISMS_SCOPE}}}} | +| Organisation | {{{{ORG_NAME}}}} | +| Verantwortlich | {{{{{owner}}}}} | +| Freigabe durch | {{{{ROLE_MANAGEMENT}}}} | +| Version | {{{{DOC_VERSION}}}} | +| Datum | {{{{DOC_DATE}}}} | +| Status | {{{{DOC_STATUS}}}} | +""" + +mapping = {"meta":{"paket":"ISMS-Vorlagenpaket v2","standard":"VDA ISA 2027 (Information Security)"},"anforderungen":[]} + +def suffix(reqs): + m=s=0; ids=[] + for r in reqs: + if r["t"]=="M": m+=1; ids.append("M%d"%m) + else: s+=1; ids.append("S%d"%s) + return ids + +for p in POLICIES: + ids_by_control={} + body=[META.format(title=p["title"], owner=p["owner"])] + body.append("\n## 1. Zweck\n\n"+inline(p["purpose"])+" Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfuellung der Anforderungen des VDA ISA 2027.\n") + body.append("## 2. Geltungsbereich\n\nDiese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}).\n") + body.append("## 3. Anforderungen und Umsetzung\n\n> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsaechliche Ausgestaltung, anzupassen wo erforderlich).\n") + sec=0 + for c in p["controls"]: + sec+=1 + ids=suffix(c["reqs"]) + head=f"### 3.{sec} {c['title']} (ISA {c['num']})\n" + wrap_flag=c.get("flag") + block=[head, "\n**Anforderung**\n"] + for r,rid in zip(c["reqs"], ids): + full_id=f"{c['num']}-{rid}" + tag="[MUSS]" if r["t"]=="M" else "[SOLL]" + line=f"\n- **{tag}** {inline(r['req'])}" + cond = r.get("cond") + if r["t"]=="S" and not cond: cond="FLAG_INCLUDE_SHOULD" + if cond: line=f"{{{{#if {cond}}}}}\n{line}\n{{{{/if}}}}" + block.append(line) + block.append("\n**Umsetzung bei {{ORG_NAME}}**\n") + for r,rid in zip(c["reqs"], ids): + full_id=f"{c['num']}-{rid}" + line=f"\n{inline(r['impl'])}" + cond = r.get("cond") + if r["t"]=="S" and not cond: cond="FLAG_INCLUDE_SHOULD" + if cond: line=f"{{{{#if {cond}}}}}\n{line}\n{{{{/if}}}}" + block.append(line) + # mapping-Eintrag + mapping["anforderungen"].append({ + "id":full_id,"policy":p["id"],"policy_file":p["fn"]+".md", + "control":c["num"],"type":"MUSS" if r["t"]=="M" else "SOLL", + "req_anchor":f"REQ {full_id}","impl_anchor":f"IMPL {full_id}", + "condition": r.get("cond") or (None if r["t"]=="M" else "FLAG_INCLUDE_SHOULD"), + "requirement": inline(r["req"]).replace("{{IF_OT}}","").replace("{{IF_DEV}}","").replace("{{IF_CLOUD}}","").replace("{{IF_EXTIT}}",""), + "implementation": inline(r["impl"]).replace("{{IF_OT}}","").replace("{{IF_DEV}}","").replace("{{IF_CLOUD}}","").replace("{{IF_EXTIT}}",""), + "link":f"{{{{LINK:{p['id']}#{c['num']}}}}}", + "nachweis_link":"{{LINK:NACHWEISREGISTER}}" + }) + section_text="\n".join(block) + if wrap_flag: + section_text=f"{{{{#if {wrap_flag}}}}}\n{section_text}\n{{{{/if}}}}" + body.append(section_text+"\n") + # Verbindlichkeit / Rollen / Pruefung / Nachweise / Verwandte + body.append("## 4. Verbindlichkeit\n\nDiese Richtlinie ist fuer alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{"+p["owner"]+"}} ueberwacht.\n") + roles="\n".join("| %s | %s |"%(r,v) for r,v in p["roles"]) + body.append("## 5. Rollen und Verantwortlichkeiten\n\n| Rolle | Verantwortung in dieser Richtlinie |\n|-------|-------------------------------------|\n"+roles+"\n") + body.append("## 6. Ueberpruefung und Aktualisierung\n\nDiese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{"+p["owner"]+"}} ueberprueft und durch {{ROLE_MANAGEMENT}} freigegeben.\n") + body.append("## 7. Nachweise\n\nDie Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument gefuehrt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehoerigen Eintraegen des ISMS-Tools ({{TOOL_NAME}}).\n") + rel=", ".join("{{LINK:%s}}"%x for x in p["related"]) + body.append("## 8. Verwandte Dokumente\n\n- Informationssicherheitsleitlinie: {{LINK:L00}}\n- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}}\n- Nachweisregister: {{LINK:NACHWEISREGISTER}}\n- Weitere: "+rel+"\n\n\n") + txt="\n".join(body) + with open(os.path.join(RDIR,p["fn"]+".md"),"w",encoding="utf-8") as f: + f.write(txt) + +json.dump(mapping, open(os.path.join(BASE,"mapping.json"),"w",encoding="utf-8"), ensure_ascii=False, indent=1) +print("Richtlinien:", len(POLICIES), "| Mapping-Eintraege:", len(mapping["anforderungen"])) diff --git a/seed/isms-vorlagenpaket-v2/_generate_verfahren.py b/seed/isms-vorlagenpaket-v2/_generate_verfahren.py new file mode 100644 index 0000000..bab9ef6 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/_generate_verfahren.py @@ -0,0 +1,295 @@ +# -*- coding: utf-8 -*- +"""Generiert 13 Verfahrensanweisungen (VA-01..VA-13) auditfest: +Zweck, Ausloeser, Eingaben, Ablauf, RACI, Ergebnis/Nachweis, KPI, Verwandte Dokumente. +Erweitert mapping.json um 'verfahren' und annotiert Anforderungen mit erfuellenden Verfahren. +Ergaenzt {{LINK:VA-xx}} in den zugehoerigen Richtlinien.""" +import os, json, re +BASE=os.path.dirname(__file__) +VDIR=os.path.join(BASE,"verfahren"); os.makedirs(VDIR, exist_ok=True) + +# step = (Text, R, A, C, I) +P=[] +def va(**k): P.append(k) + +va(id="VA-01", fn="VA-01_Incident-Response-und-Meldeverfahren", title="Incident-Response- und Meldeverfahren", + owner="{{ROLE_ISB}}", policy="R04", fulfills=["1.6.1-M1","1.6.1-M2","1.6.2-M1","1.6.2-M2","1.6.2-S1","1.6.2-S2"], + purpose="Dieses Verfahren regelt Meldung, Bewertung, Behandlung und Nachbereitung von Informationssicherheitsvorfällen.", + trigger="Meldung eines Sicherheitsereignisses (Mitarbeitende, Technik/Monitoring, Externe) über den definierten Meldeweg.", + inputs=["Meldung/Alarm mit Kurzbeschreibung","Betroffene Systeme/Informationen (Asset-Inventar)","Klassifizierung/Schutzbedarf"], + steps=[ + ("Ereignis melden: Meldung über {{TOOL_TICKET}} bzw. E-Mail an {{ROLE_ISB}} erfassen.","Meldende Person","{{ROLE_ISB}}","-","-"), + ("Triage & Klassifizierung: Relevanz, Schweregrad und Kategorie festlegen.","{{ROLE_ISB}}","{{ROLE_ISB}}","{{ROLE_IT_LEAD}}","-"), + ("Eindämmung: Sofortmaßnahmen zur Begrenzung des Schadens einleiten.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","{{ROLE_ISB}}","{{ROLE_MANAGEMENT}}"), + ("Behebung & Wiederherstellung: Ursache beseitigen, Normalbetrieb herstellen.","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-"), + ("Meldepflichten prüfen: Kunden/OEM, Behörden, bei personenbezogenen Daten {{ROLE_DPO}} (72-Stunden-Frist).","{{ROLE_ISB}}","{{ROLE_MANAGEMENT}}","{{ROLE_DPO}}","-"), + ("Dokumentation & Lessons Learned: Vorfall abschließen, Verbesserungsmaßnahmen ableiten.","{{ROLE_ISB}}","{{ROLE_ISB}}","{{ROLE_IT_LEAD}}","{{ROLE_MANAGEMENT}}"), + ], + output="Dokumentierter, abgeschlossener Vorfall im {{TOOL_TICKET}}; abgeleitete Maßnahmen im ISMS-Tool ({{TOOL_NAME}}).", + kpis=["Zeit bis Ersterfassung (Time-to-Detect/Acknowledge)","Zeit bis Behebung (Time-to-Resolve)","Anteil fristgerechter Meldungen"], + related=["R04","VA-02"]) + +va(id="VA-02", fn="VA-02_IT-Notfall-und-Wiederanlaufverfahren", title="IT-Notfall- und Wiederanlaufverfahren (BCM)", + owner="{{ROLE_IT_LEAD}}", policy="R04", fulfills=["1.6.3-M1","1.6.3-S1","5.2.8-M1","5.2.8-S1"], + purpose="Dieses Verfahren regelt die Aufrechterhaltung und Wiederherstellung kritischer IT-Dienste bei Ausfall oder Krise.", + trigger="Ausfall kritischer IT-Dienste, Notfall oder Krisenfall (Eskalation aus VA-01).", + inputs=["Liste kritischer IT-Dienste mit RTO/RPO","Wiederanlaufpläne","Backup-Status (VA-05)"], + steps=[ + ("Notfall feststellen & einstufen: Ausmaß bewerten, ggf. Krisenstab einberufen.","{{ROLE_IT_LEAD}}","{{ROLE_MANAGEMENT}}","{{ROLE_ISB}}","-"), + ("Kommunikation aktivieren: Interne/externe Stakeholder informieren.","{{ROLE_ISB}}","{{ROLE_MANAGEMENT}}","-","Mitarbeitende"), + ("Wiederanlauf priorisieren: Dienste nach RTO/RPO in Reihenfolge bringen.","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-"), + ("Wiederherstellung durchführen: Systeme/Daten aus Backup (VA-05) wiederherstellen.","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","-","-"), + ("Rückkehr zum Normalbetrieb bestätigen & dokumentieren.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","{{ROLE_MANAGEMENT}}"), + ("Nachbereitung & Test-Update: Plan aktualisieren, {{BACKUP_TEST_FREQ}} üben.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ], + output="Wiederhergestellte Dienste; dokumentierter Notfall/Test im ISMS-Tool ({{TOOL_NAME}}); aktualisierte Wiederanlaufpläne.", + kpis=["Einhaltung RTO/RPO","Erfolgsquote Wiederherstellungstests","Aktualität der Notfallpläne"], + related=["R04","VA-01","VA-05"]) + +va(id="VA-03", fn="VA-03_Berechtigungsverfahren", title="Berechtigungsverfahren (Joiner/Mover/Leaver und Rezertifizierung)", + owner="{{ROLE_IT_LEAD}}", policy="R08", fulfills=["4.1.1-S1","4.1.3-M1","4.2.1-M1","4.2.1-M2","4.2.1-S1"], + purpose="Dieses Verfahren regelt Beantragung, Genehmigung, Änderung, Entzug und regelmäßige Überprüfung von Zugriffsrechten.", + trigger="Eintritt, Rollenwechsel oder Austritt einer Person; Berechtigungsantrag; fällige Rezertifizierung.", + inputs=["Personalmeldung (HR)","Rollen-/Rechtekatalog (RBAC)","Bestehende Berechtigungen aus {{TOOL_IAM}}"], + steps=[ + ("Antrag erfassen: Zugang/Recht im {{TOOL_TICKET}} beantragen (Joiner/Mover).","Vorgesetzte/Fachbereich","{{ROLE_IT_LEAD}}","-","-"), + ("Fachliche Genehmigung: Erforderlichkeit nach Minimalprinzip prüfen und freigeben.","Fachbereich/Dateneigentümer","Fachbereich/Dateneigentümer","{{ROLE_ISB}}","-"), + ("Umsetzung: Rechte rollenbasiert in {{TOOL_IAM}} setzen.","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","-","Antragsteller"), + ("Leaver/Änderung: Bei Austritt/Wechsel Rechte unverzüglich entziehen/anpassen.","{{ROLE_IT_LEAD}}","{{ROLE_HR_LEAD}}","-","-"), + ("Rezertifizierung ({{RECERT_FREQ}}, BL-IAM-05): Owner bestätigen/entziehen Rechte.","Fachbereich/Dateneigentümer","{{ROLE_ISB}}","{{ROLE_IT_LEAD}}","-"), + ("Privilegierte Konten: gesondert prüfen und protokollieren (BL-IAM-06).","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ], + output="Dokumentierte Anträge/Genehmigungen im {{TOOL_TICKET}}; aktueller Berechtigungsstand in {{TOOL_IAM}}; Rezertifizierungsnachweis.", + kpis=["Anteil fristgerecht entzogener Leaver-Rechte","Rezertifizierungsquote","Zahl verwaister/privilegierter Konten"], + related=["R08","VA-01"]) + +va(id="VA-04", fn="VA-04_Change-und-Patch-Management-Verfahren", title="Change- und Patch-Management-Verfahren", + owner="{{ROLE_IT_LEAD}}", policy="R10", fulfills=["5.2.1-M1","5.2.5-M1"], + purpose="Dieses Verfahren regelt geplante Änderungen an IT-Systemen sowie das risikoorientierte Einspielen von Patches.", + trigger="Änderungsbedarf, verfügbarer Patch oder identifizierte Schwachstelle (VA-06).", + inputs=["Change-/Patch-Antrag","Risikoeinschätzung","Patch-SLA (BL-OPS-01)"], + steps=[ + ("Change beantragen & klassifizieren (Standard/Normal/Notfall) im {{TOOL_TICKET}}.","Antragsteller","{{ROLE_IT_LEAD}}","-","-"), + ("Risiko-/Auswirkungsbewertung inkl. Rollback-Plan.","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-"), + ("Genehmigung durch CAB/verantwortliche Rolle.","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-"), + ("Test in getrennter Umgebung (BL-OPS, R10).","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","-","-"), + ("Umsetzung in Produktion gemäß Patch-SLA (kritisch {{PATCH_SLA_CRIT}}).","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","-","Betroffene"), + ("Verifikation & Dokumentation des Ergebnisses im {{TOOL_TICKET}}.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ], + output="Dokumentierte, genehmigte und verifizierte Änderung/Patch im {{TOOL_TICKET}}.", + kpis=["Patch-Compliance je Kritikalität","Anteil erfolgreicher Changes (ohne Rollback)","Durchlaufzeit kritischer Patches"], + related=["R10","VA-06"]) + +va(id="VA-05", fn="VA-05_Backup-und-Restore-Verfahren", title="Backup- und Restore-Verfahren", + owner="{{ROLE_IT_LEAD}}", policy="R10", fulfills=["5.2.9-M1","5.2.9-M2","5.2.9-S1"], + purpose="Dieses Verfahren regelt Datensicherung, Aufbewahrung und Wiederherstellung nach dem {{BACKUP_SCHEME}}-Schema.", + trigger="Regulärer Sicherungslauf; Wiederherstellungsbedarf; geplanter Restore-Test.", + inputs=["Sicherungsplan je System","Klassifizierung/RPO","Backup-Ziele ({{TECH_BACKUP}})"], + steps=[ + ("Sicherung durchführen: automatisierte Backups gemäß {{BACKUP_SCHEME}} (BL-OPS-05).","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","-","-"), + ("Überwachung: Erfolg/Fehler prüfen, Fehlläufe nachverfolgen ({{TOOL_TICKET}}).","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","-","-"), + ("Schutz & Auslagerung: 1 Kopie offline/immutable, Aufbewahrung {{BACKUP_RETENTION}}.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ("Restore-Anforderung bearbeiten (bei Bedarf/Notfall, VA-02).","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","Anforderer","-"), + ("Wiederherstellungstest ({{BACKUP_TEST_FREQ}}, BL-OPS-06) durchführen & dokumentieren.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ], + output="Protokollierte Sicherungen; dokumentierte Restore-Tests; Nachweis im ISMS-Tool ({{TOOL_NAME}}).", + kpis=["Backup-Erfolgsquote","Erfolgsquote Restore-Tests","Einhaltung RPO"], + related=["R10","VA-02"]) + +va(id="VA-06", fn="VA-06_Schwachstellenmanagement-Verfahren", title="Schwachstellenmanagement-Verfahren", + owner="{{ROLE_IT_LEAD}}", policy="R10", fulfills=["5.2.5-M1","5.2.5-S1","5.2.6-M1"], + purpose="Dieses Verfahren regelt Erkennung, Bewertung, Behandlung und technische Prüfung von Schwachstellen.", + trigger="Regelmäßiger Scan ({{VULN_SCAN_FREQ}}), Sicherheitsmeldung/CVE, Penetrationstest ({{PENTEST_FREQ}}).", + inputs=["Scan-/Testberichte","Asset-Inventar & Kritikalität","Patch-SLA (BL-OPS-01)"], + steps=[ + ("Identifikation: Schwachstellen-Scan {{VULN_SCAN_FREQ}} (BL-OPS-02) und Meldungen auswerten.","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","-","-"), + ("Bewertung & Priorisierung nach Kritikalität und Exponierung.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ("Behandlung anstoßen: Patch/Change (VA-04) oder kompensierende Maßnahme.","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-"), + ("Technische Prüfung: Härtung (BL-OPS-07) und Penetrationstests ({{PENTEST_FREQ}}, BL-OPS-08).","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","Externer Dienstleister","-"), + ("Nachverfolgung & Verifikation der Behebung im {{TOOL_TICKET}}.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ], + output="Nachverfolgte Schwachstellen mit Behandlungsstatus im {{TOOL_TICKET}}; Testberichte.", + kpis=["Mittlere Behebungszeit je Kritikalität","Offene kritische Schwachstellen","Scan-Abdeckung"], + related=["R10","VA-04"]) + +va(id="VA-07", fn="VA-07_Kryptokonzept-und-Schluesselverwaltung", title="Kryptokonzept und Schlüsselverwaltung", + owner="{{ROLE_IT_LEAD}}", policy="R09", fulfills=["5.1.1-M1","5.1.1-M2","5.1.1-S1","5.1.2-M1","5.1.2-S1"], + purpose="Dieses Verfahren regelt den Einsatz kryptografischer Verfahren und die Verwaltung von Schlüsseln über den Lebenszyklus.", + trigger="Neuer Bedarf an Verschlüsselung/Zertifikaten; Schlüsselerneuerung/-sperrung; Änderung des Stands der Technik.", + inputs=["Zulässige Algorithmen (BL-CRY-02)","Schutzbedarf der Daten","Zertifikats-/Schlüsselbestand"], + steps=[ + ("Bedarf & Verfahren festlegen: zulässige Algorithmen {{CRYPTO_ALGO}} (BL-CRY-02) wählen.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ("Schlüssel/Zertifikate erzeugen und sicher verteilen (BL-CRY-05).","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","-","-"), + ("Speicherung & Zugriffsschutz (getrennte Aufbewahrung, {{#if FLAG_CRYPTO_PKI}}PKI, {{/if}}Berechtigungen).","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ("Übertragungsschutz sicherstellen: mindestens {{TLS_MIN}} (BL-CRY-01).","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","-","-"), + ("Erneuerung/Sperrung/Vernichtung dokumentieren.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ], + output="Dokumentiertes Kryptokonzept; nachvollziehbarer Schlüssel-/Zertifikatslebenszyklus.", + kpis=["Anteil konformer Verfahren/Algorithmen","Ablaufende Zertifikate ohne Erneuerung","Abdeckung Transportverschlüsselung"], + related=["R09","VA-04"]) + +va(id="VA-08", fn="VA-08_Asset-und-Klassifizierungsverfahren", title="Asset- und Klassifizierungsverfahren", + owner="{{ROLE_IT_LEAD}}", policy="R02", fulfills=["1.3.1-M1","1.3.1-M2","1.3.1-S1","1.3.2-M1","1.3.2-M2","1.3.2-S1"], + purpose="Dieses Verfahren regelt Erfassung, Owner-Zuordnung, Klassifizierung und Pflege von Informationswerten und Assets.", + trigger="Neues/geändertes Asset; Beschaffung; regelmäßige Inventurprüfung.", + inputs=["Beschaffungs-/Änderungsmeldung","Klassifizierungsschema","Asset-Inventar ({{TOOL_NAME}})"], + steps=[ + ("Asset erfassen im Inventar ({{TOOL_NAME}}) mit Attributen.","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","-","-"), + ("Owner zuordnen.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","Asset Owner"), + ("Klassifizieren (Vertraulichkeit/Integrität/Verfügbarkeit) durch Owner.","Asset Owner","Asset Owner","{{ROLE_ISB}}","-"), + ("Handhabungsvorgaben je Schutzklasse anwenden (Kennzeichnung/Speicherung/Löschung BL-DEL-01).","Asset Owner","{{ROLE_ISB}}","-","Mitarbeitende"), + ("Pflege & Review ({{REVIEW_CYCLE}}) auf Aktualität.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ], + output="Aktuelles, klassifiziertes Asset-Inventar im ISMS-Tool ({{TOOL_NAME}}).", + kpis=["Inventar-Abdeckung","Anteil klassifizierter Assets","Assets ohne Owner"], + related=["R02","VA-03"]) + +va(id="VA-09", fn="VA-09_Risikomanagement-Verfahren", title="Risikomanagement-Verfahren", + owner="{{ROLE_ISB}}", policy="R03", fulfills=["1.4.1-M1","1.4.1-M2","1.4.1-M3","1.4.1-S1"], + purpose="Dieses Verfahren regelt Identifikation, Analyse, Bewertung, Behandlung und Überwachung von Informationssicherheitsrisiken.", + trigger="Neues System/Projekt, Vorfall, Änderung, regelmäßiger Review-Zyklus.", + inputs=["Asset-/Prozessliste","Bewertungsskalen & Akzeptanzschwellen","Bestehendes Risikoregister"], + steps=[ + ("Risiken identifizieren (Assets, Bedrohungen, Schwachstellen).","{{ROLE_ISB}}","{{ROLE_ISB}}","Asset/Prozessverantwortliche","-"), + ("Analysieren & bewerten (Eintritt × Schadenshöhe) im ISMS-Tool ({{TOOL_NAME}}).","{{ROLE_ISB}}","{{ROLE_ISB}}","{{ROLE_IT_LEAD}}","-"), + ("Behandlung festlegen (reduzieren/vermeiden/übertragen/akzeptieren) und Maßnahmen planen.","{{ROLE_ISB}}","{{ROLE_MANAGEMENT}}","Fachbereich","-"), + ("Restrisiko-Akzeptanz dokumentieren.","{{ROLE_MANAGEMENT}}","{{ROLE_MANAGEMENT}}","{{ROLE_ISB}}","-"), + ("Überwachen & aktualisieren ({{REVIEW_CYCLE}} und anlassbezogen).","{{ROLE_ISB}}","{{ROLE_ISB}}","-","-"), + ], + output="Gepflegtes Risikoregister mit Behandlungsplan und Akzeptanzentscheidungen im ISMS-Tool ({{TOOL_NAME}}).", + kpis=["Anteil behandelter Risiken","Überfällige Maßnahmen","Aktualität des Risikoregisters"], + related=["R03","VA-01"]) + +va(id="VA-10", fn="VA-10_Lieferanten-Onboarding-und-Bewertung", title="Lieferanten-Onboarding- und Bewertungsverfahren", + owner="{{ROLE_ISB}}", policy="R13", fulfills=["6.1.1-M1","6.1.1-M2","6.1.1-S1","6.1.2-M1","6.1.2-S1","6.1.3-M1"], + purpose="Dieses Verfahren regelt Auswahl, sicherheitsbezogene Bewertung, vertragliche Bindung und Überwachung von Lieferanten/Dienstleistern.", + trigger="Neuer Lieferant/Dienstleister mit Zugriff auf Informationen; Vertragsverlängerung; periodische Überprüfung.", + inputs=["Leistungs-/Schutzbedarfsbeschreibung","Risikoklassen (BL-SUP-01)","NDA-/Vertragsvorlagen"], + steps=[ + ("Bedarf & Risikoklasse bestimmen (Schutzbedarf, Zugriff).","Einkauf/Fachbereich","{{ROLE_ISB}}","-","-"), + ("Sicherheitsbewertung (Selbstauskunft/Nachweise/TISAX) durchführen.","{{ROLE_ISB}}","{{ROLE_ISB}}","Fachbereich","-"), + ("NDA & vertragliche Sicherheitsanforderungen vereinbaren.","Einkauf","{{ROLE_MANAGEMENT}}","{{ROLE_ISB}}","-"), + ("Verantwortlichkeiten abgrenzen (Betrieb/Sicherheit/Meldung).","{{ROLE_ISB}}","{{ROLE_ISB}}","{{ROLE_IT_LEAD}}","-"), + ("Ins Lieferantenverzeichnis ({{TOOL_NAME}}) aufnehmen und {{REVIEW_CYCLE}} überprüfen.","{{ROLE_ISB}}","{{ROLE_ISB}}","-","-"), + ], + output="Bewerteter, vertraglich gebundener Lieferant im Lieferantenverzeichnis ({{TOOL_NAME}}); NDA hinterlegt.", + kpis=["Anteil bewerteter Lieferanten","NDA-Abdeckung","Überfällige Lieferantenprüfungen"], + related=["R13","VA-11"]) + +va(id="VA-11", fn="VA-11_Cloud-und-KI-Freigabeverfahren", title="Cloud- und KI-Freigabeverfahren", + owner="{{ROLE_ISB}}", policy="R12", fulfills=["5.3.4-M1","5.3.4-M2","5.3.4-S1","5.3.4-KI-M1","5.3.4-KI-M2","5.3.4-KI-M3","5.3.4-KI-S1"], + purpose="Dieses Verfahren regelt Bewertung und Freigabe von Cloud- und KI-/GenAI-Diensten sowie die zulässige Nutzung.", + trigger="Antrag zur Nutzung eines Cloud- oder KI-Dienstes.", + inputs=["Dienstbeschreibung & Anbieterinfos","Schutzbedarf/Datenklassen","Vertrags-/DPA-Unterlagen"], + steps=[ + ("Antrag erfassen im {{TOOL_TICKET}} (Dienst, Zweck, Datenklassen).","Antragsteller/Fachbereich","{{ROLE_ISB}}","-","-"), + ("Bewertung: Schutzbedarf, Datenlokation/EU, Mandantentrennung, Exit; bei KI Trainings-/Weitergabe-Ausschluss.","{{ROLE_ISB}}","{{ROLE_ISB}}","{{ROLE_IT_LEAD}}","{{ROLE_DPO}}"), + ("Vertrag/DPA prüfen (bei KI: Opt-out/Enterprise-Vertrag, EU AI Act).","{{ROLE_ISB}}","{{ROLE_MANAGEMENT}}","{{ROLE_DPO}}","-"), + ("Freigabe & Aufnahme in die Freigabeliste ({{TOOL_NAME}}); zulässige Datenklassen festlegen.","{{ROLE_ISB}}","{{ROLE_ISB}}","-","Fachbereich"), + ("Nutzung & Kontrolle: Human-in-the-Loop bei KI, periodische Überprüfung ({{REVIEW_CYCLE}}).","Fachbereich","{{ROLE_ISB}}","-","-"), + ], + output="Freigabeentscheidung und Freigabeliste im ISMS-Tool ({{TOOL_NAME}}); dokumentierte zulässige Datenklassen.", + kpis=["Anteil freigegebener vs. genutzter Dienste","Schatten-IT-Funde","Überfällige Dienst-Reviews"], + related=["R12","VA-10"]) + +va(id="VA-12", fn="VA-12_Awareness-und-Schulungsverfahren", title="Awareness- und Schulungsverfahren", + owner="{{ROLE_ISB}}", policy="R05", fulfills=["2.1.3-M1","2.1.3-S1"], + purpose="Dieses Verfahren regelt Planung, Durchführung und Nachweis von Sensibilisierung und Schulung zur Informationssicherheit.", + trigger="Eintritt neuer Mitarbeitender; jährlicher Schulungszyklus; anlassbezogen nach Vorfällen.", + inputs=["Schulungsplan/Curriculum (BL-HR-01)","Zielgruppen/Rollen","Teilnahmestatus ({{TOOL_NAME}})"], + steps=[ + ("Schulungsbedarf & Zielgruppen planen (rollenspezifisch).","{{ROLE_ISB}}","{{ROLE_ISB}}","{{ROLE_HR_LEAD}}","-"), + ("Onboarding-Schulung bei Eintritt durchführen.","{{ROLE_HR_LEAD}}","{{ROLE_ISB}}","-","Mitarbeitende"), + ("Regelmäßige Schulung ({{REVIEW_CYCLE}}, BL-HR-01) durchführen.","{{ROLE_ISB}}","{{ROLE_ISB}}","-","Mitarbeitende"), + ("Wirksamkeit prüfen (Phishing-Simulation) und nachschulen.","{{ROLE_ISB}}","{{ROLE_ISB}}","{{ROLE_IT_LEAD}}","-"), + ("Teilnahme nachweisen im ISMS-Tool ({{TOOL_NAME}}).","{{ROLE_HR_LEAD}}","{{ROLE_ISB}}","-","-"), + ], + output="Dokumentierte Schulungsteilnahme und Wirksamkeitsmessung im ISMS-Tool ({{TOOL_NAME}}).", + kpis=["Schulungsquote","Phishing-Klickrate","Anteil rollenspezifischer Schulungen"], + related=["R05","VA-01"]) + +va(id="VA-13", fn="VA-13_Logging-und-Monitoring-Verfahren", title="Logging- und Monitoring-Verfahren", + owner="{{ROLE_IT_LEAD}}", policy="R10", fulfills=["5.2.4-M1","5.2.4-S1"], + purpose="Dieses Verfahren regelt Erhebung, Schutz, Auswertung und Aufbewahrung sicherheitsrelevanter Protokolldaten.", + trigger="Kontinuierlicher Betrieb; sicherheitsrelevantes Ereignis; Alarm aus {{TECH_SIEM}}.", + inputs=["Log-Quellen/Systeme","Aufbewahrungsvorgaben (BL-OPS-04)","Alarmierungsregeln"], + steps=[ + ("Log-Quellen anbinden und zentral in {{TECH_SIEM}} erfassen (BL-OPS-04).","{{ROLE_IT_LEAD}}","{{ROLE_IT_LEAD}}","-","-"), + ("Manipulationsschutz & Aufbewahrung {{LOG_RETENTION}} sicherstellen.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ("Auswertung & Alarmierung: Regeln pflegen, Auffälligkeiten prüfen.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ("Verdachtsfall an Incident-Response (VA-01) übergeben.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ("Regelmäßige Überprüfung der Abdeckung und Regeln.","{{ROLE_IT_LEAD}}","{{ROLE_ISB}}","-","-"), + ], + output="Zentrale, geschützte Protokollierung mit Auswertung; Nachweis im ISMS-Tool ({{TOOL_NAME}}).", + kpis=["Log-Quellen-Abdeckung","Mittlere Zeit bis Alarmreaktion","Anteil auswertbarer Ereignisse"], + related=["R10","VA-01"]) + +# ---------- Rendering ---------- +def render(p): + L=[] + L.append(f"# {p['title']}\n") + L.append("| Dokumenteninformation | Wert |") + L.append("|-----------------------|------|") + L.append(f"| Dokumententyp | Verfahrensanweisung ({p['id']}) |") + L.append("| Geltungsbereich | {{ISMS_SCOPE}} |") + L.append("| Organisation | {{ORG_NAME}} |") + L.append(f"| Prozessverantwortlich | {p['owner']} |") + L.append("| Freigabe durch | {{ROLE_ISB}} |") + L.append("| Version | {{DOC_VERSION}} |") + L.append("| Datum | {{DOC_DATE}} |") + L.append("| Status | {{DOC_STATUS}} |") + L.append(f"\n\n") + L.append("## 1. Zweck\n\n"+p["purpose"]+f" Es operationalisiert die zugehörige Richtlinie ({{{{LINK:{p['policy']}}}}}).\n") + L.append("## 2. Geltungsbereich\n\nGilt innerhalb des ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}).\n") + L.append("## 3. Auslöser\n\n"+p["trigger"]+"\n") + L.append("## 4. Eingaben\n\n"+"\n".join("- "+i for i in p["inputs"])+"\n") + L.append("## 5. Ablauf\n") + for n,s in enumerate(p["steps"],1): + L.append(f"{n}. {s[0]}") + L.append("\n## 6. RACI\n") + L.append("| # | Schritt | R (Durchführung) | A (Rechenschaft) | C (Konsultiert) | I (Informiert) |") + L.append("|---|---------|------------------|------------------|-----------------|----------------|") + for n,s in enumerate(p["steps"],1): + short=s[0].split(":")[0] if ":" in s[0] else s[0][:40] + L.append(f"| {n} | {short} | {s[1]} | {s[2]} | {s[3]} | {s[4]} |") + L.append("\n## 7. Ergebnis & Nachweis\n\n"+p["output"]+" Nachweise werden im zentralen Nachweisregister ({{LINK:NACHWEISREGISTER}}) referenziert.\n") + L.append("## 8. Kennzahlen (KPI)\n\n"+"\n".join("- "+k for k in p["kpis"])+"\n") + L.append("## 9. Verwandte Dokumente\n") + rel="\n".join("- "+("Zugehörige Richtlinie: " if x==p['policy'] else "")+f"{{{{LINK:{x}}}}}" for x in p["related"]) + L.append(rel) + L.append("- Technische Sicherheits-Baseline: {{LINK:BASELINE}}") + L.append("- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}}") + L.append("\n\n") + return "\n".join(L) + +for p in P: + open(os.path.join(VDIR,p["fn"]+".md"),"w",encoding="utf-8").write(render(p)) + +# ---------- mapping.json erweitern ---------- +mp=os.path.join(BASE,"mapping.json") +d=json.load(open(mp,encoding="utf-8")) +d["verfahren"]=[{"id":p["id"],"title":p["title"],"file":"verfahren/"+p["fn"]+".md", + "policy":p["policy"],"fulfills":p["fulfills"],"link":"{{LINK:%s}}"%p["id"]} for p in P] +# Annotation je Anforderung +by_req={} +for p in P: + for rid in p["fulfills"]: by_req.setdefault(rid,[]).append(p["id"]) +for a in d["anforderungen"]: + a["verfahren"]=by_req.get(a["id"],[]) +json.dump(d,open(mp,"w",encoding="utf-8"),ensure_ascii=False,indent=1) + +# ---------- {{LINK:VA-xx}} in Richtlinien ergaenzen ---------- +pol2va={} +for p in P: pol2va.setdefault(p["policy"],[]).append(p["id"]) +for fp in [os.path.join(BASE,"richtlinien",f) for f in os.listdir(os.path.join(BASE,"richtlinien"))]: + pid=os.path.basename(fp).split("_")[0] + if pid in pol2va: + txt=open(fp,encoding="utf-8").read() + line="- Zugehörige Verfahren: "+", ".join("{{LINK:%s}}"%v for v in pol2va[pid]) + if "Zugehörige Verfahren" not in txt and "- Technische Sicherheits-Baseline: {{LINK:BASELINE}}" in txt: + txt=txt.replace("- Technische Sicherheits-Baseline: {{LINK:BASELINE}}", + line+"\n- Technische Sicherheits-Baseline: {{LINK:BASELINE}}") + open(fp,"w",encoding="utf-8").write(txt) + +print("Verfahren erstellt:",len(P)) +print("Anforderungen mit Verfahren:",sum(1 for a in d["anforderungen"] if a["verfahren"])) +print("Policies mit Verfahrenslink:",sorted(pol2va)) diff --git a/seed/isms-vorlagenpaket-v2/_matrix.py b/seed/isms-vorlagenpaket-v2/_matrix.py new file mode 100644 index 0000000..088af7a --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/_matrix.py @@ -0,0 +1,30 @@ +# -*- coding: utf-8 -*- +import json, collections, os +BASE=os.path.dirname(__file__) +d=json.load(open(os.path.join(BASE,"mapping.json"),encoding="utf-8")) +POLTITLE={"L00":"Informationssicherheitsleitlinie","R01":"ISMS-Organisation und Rollen","R02":"Asset- und Klassifizierung","R03":"Risikomanagement und Audit","R04":"Incident, Notfall und Kontinuitaet","R05":"Personalsicherheit und Awareness","R06":"Mobiles Arbeiten und mobile Geraete","R07":"Physische Sicherheit","R08":"Identitaets- und Zugriffsmanagement","R09":"Kryptografie und Uebertragung","R10":"Betriebssicherheit","R11":"Sichere Beschaffung und Entwicklung","R12":"Cloud-, KI- und externe IT-Dienste","R13":"Lieferanten- und Dienstleistersteuerung","R14":"Compliance und Datenschutz"} +by=collections.OrderedDict() +for a in d["anforderungen"]: + by.setdefault(a["control"],[]).append(a) +L=[] +L.append("# ISA-Mapping-Matrix - VDA ISA 2027 (Information Security)\n") +L.append("Zentrale Zuordnung: **ISA-Control -> Richtlinie -> einzelne Anforderungen (MUSS/SOLL)**. Ersetzt den frueheren Abschnitt 'Bezug zu VDA ISA' in den einzelnen Richtlinien. Das Tool verlinkt von jeder Anforderung (Hidden-Anker, siehe `mapping.json`) auf diese Matrix und auf das Nachweisregister ({{LINK:NACHWEISREGISTER}}).\n") +L.append("| ISA | Richtlinie | MUSS | SOLL | Anforderungs-IDs |") +L.append("|-----|-----------|------|------|------------------|") +for ctrl,items in by.items(): + pol=items[0]["policy"] + m=sum(1 for x in items if x["type"]=="MUSS"); s=len(items)-m + ids=", ".join(x["id"].split("-",1)[1] for x in items) + L.append(f"| {ctrl} | {{{{LINK:{pol}}}}} {POLTITLE.get(pol,pol)} | {m} | {s} | {ids} |") +cnt=collections.Counter(a["type"] for a in d["anforderungen"]) +L.append(f"\n**Summe:** {len(d['anforderungen'])} Anforderungen (MUSS {cnt['MUSS']}, SOLL {cnt['SOLL']}) ueber {len(by)} Controls und {len(set(a['policy'] for a in d['anforderungen']))} Dokumente.\n") +L.append("> Hinweis zu 3.1.2: In der ISA 2027 als 'Superseded by 1.6.3, 5.2.8 und 5.2.9' entfallen - abgedeckt ueber {{LINK:R04}} und {{LINK:R10}}.\n") +L.append("## Detailzuordnung je Anforderung\n") +L.append("| ID | Typ | Richtlinie | Anforderung (Kurz) | Bedingung |") +L.append("|----|-----|-----------|--------------------|-----------|") +for a in d["anforderungen"]: + req=a["requirement"].replace("|","/") + req=(req[:80]+"...") if len(req)>80 else req + L.append(f"| {a['id']} | {a['type']} | {a['policy']} | {req} | {a['condition'] or '-'} |") +open(os.path.join(BASE,"ISA-Mapping-Matrix.md"),"w",encoding="utf-8").write("\n".join(L)) +print("Matrix ok, Controls:",len(by),"Anforderungen:",len(d["anforderungen"])) diff --git a/seed/isms-vorlagenpaket-v2/_verify.py b/seed/isms-vorlagenpaket-v2/_verify.py new file mode 100644 index 0000000..b06edff --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/_verify.py @@ -0,0 +1,51 @@ +# -*- coding: utf-8 -*- +# Korrekter rekursiver {{#if}}-Renderer (wie echtes Handlebars) zur Verifikation. +import re, glob, json, os +BASE=os.path.dirname(__file__) +schema=json.load(open(os.path.join(BASE,"variables.schema.json"))) +allvars=set(schema["properties"].keys()) + +def make_ctx(inc, extra=None): + c={k:(True if k.startswith("FLAG_") else k) for k in allvars} + for k in ["FLAG_OT_USED","FLAG_DEV_INHOUSE","FLAG_CRYPTO_PKI","FLAG_CUSTOMER_SYSTEMS"]: c[k]=False + c["FLAG_INCLUDE_SHOULD"]=inc + c["ORG_NAME"]="Muster GmbH"; c["TOOL_NAME"]="ISMS-Portal"; c["REVIEW_CYCLE"]="jährlich" + if extra: c.update(extra) + return c + +def render_if(t,c): + # rekursiv innerste Bloecke zuerst + pat=re.compile(r"\{\{#if (\w+)\}\}((?:(?!\{\{#if )(?!\{\{/if\}\}).)*?)\{\{/if\}\}",re.S) + prev=None + while prev!=t: + prev=t + t=pat.sub(lambda m:(m.group(2) if c.get(m.group(1)) else ""),t) + return t + +def render(t,c): + t=render_if(t,c) + t=re.sub(r"\{\{LINK:[^}]+\}\}","[LINK]",t) + t=re.sub(r"\{\{(\w+)\}\}",lambda m:str(c[m.group(1)]) if m.group(1) in c else "«MISS:%s»"%m.group(1),t) + return t + +files=sorted(glob.glob(os.path.join(BASE,"richtlinien/*.md")))+[os.path.join(BASE,"Nachweisregister_zentral.md"),os.path.join(BASE,"ISA-Mapping-Matrix.md")] +problems=0 +for inc in [True,False]: + c=make_ctx(inc) + for fp in files: + r=render(open(fp,encoding="utf-8").read(),c) + bad=re.findall(r"\{\{.*?\}\}",r); miss=sorted(set(re.findall(r"«MISS:\w+»",r))) + if bad or miss: + problems+=1; print("!",os.path.basename(fp),"inc=%s"%inc,"open:",bad[:4],"miss:",miss[:4]) +d=json.load(open(os.path.join(BASE,"mapping.json"))) +fa=set() +for fp in glob.glob(os.path.join(BASE,"richtlinien/*.md")): + for m in re.findall(r"",open(fp,encoding="utf-8").read()): fa.add(m[0]+" "+m[1]) +ma=set() +for a in d["anforderungen"]: ma.add(a["req_anchor"]); ma.add(a["impl_anchor"]) +leftover_hb=any("{{" in a["requirement"] or "{{" in a["implementation"] for a in d["anforderungen"]) +print("Render-Probleme:",problems) +print("mapping-Anker ohne Datei:",sorted(ma-fa)) +print("Datei-Anker ohne mapping:",sorted(fa-ma)) +print("Handlebars-Reste in mapping-Text:",leftover_hb) +print("OK" if problems==0 and not (ma-fa) and not (fa-ma) and not leftover_hb else "PRUEFEN") diff --git a/seed/isms-vorlagenpaket-v2/mapping.json b/seed/isms-vorlagenpaket-v2/mapping.json new file mode 100644 index 0000000..93a14e4 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/mapping.json @@ -0,0 +1,2091 @@ +{ + "meta": { + "paket": "ISMS-Vorlagenpaket v2", + "standard": "VDA ISA 2027 (Information Security)" + }, + "anforderungen": [ + { + "id": "1.1.1-M1", + "policy": "L00", + "policy_file": "L00_Informationssicherheitsleitlinie.md", + "control": "1.1.1", + "type": "MUSS", + "req_anchor": "REQ 1.1.1-M1", + "impl_anchor": "REQ 1.1.1-M1", + "condition": null, + "requirement": "Die Anforderungen der Informationssicherheit sind bestimmt, dokumentiert und an den Zielen der Organisation ausgerichtet.", + "implementation": "Beschrieben in Zweck und Abschnitt 5 der Leitlinie; Pflege im ISMS-Tool.", + "link": "{{LINK:L00#1.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.1.1-M2", + "policy": "L00", + "policy_file": "L00_Informationssicherheitsleitlinie.md", + "control": "1.1.1", + "type": "MUSS", + "req_anchor": "REQ 1.1.1-M2", + "impl_anchor": "REQ 1.1.1-M2", + "condition": null, + "requirement": "Eine Leitlinie existiert und ist durch die Leitung genehmigt.", + "implementation": "Die Leitlinie ist durch die {{ROLE_MANAGEMENT}} genehmigt (Abschnitt 7).", + "link": "{{LINK:L00#1.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.1.1-M3", + "policy": "L00", + "policy_file": "L00_Informationssicherheitsleitlinie.md", + "control": "1.1.1", + "type": "MUSS", + "req_anchor": "REQ 1.1.1-M3", + "impl_anchor": "REQ 1.1.1-M3", + "condition": null, + "requirement": "Die Leitlinie benennt Ziele und die Bedeutung der Informationssicherheit.", + "implementation": "Ziele und Bedeutung sind in Abschnitt 3 benannt.", + "link": "{{LINK:L00#1.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.1.1-M4", + "policy": "L00", + "policy_file": "L00_Informationssicherheitsleitlinie.md", + "control": "1.1.1", + "type": "MUSS", + "req_anchor": "REQ 1.1.1-M4", + "impl_anchor": "REQ 1.1.1-M4", + "condition": null, + "requirement": "Die Leitlinie wird den Mitarbeitenden in geeigneter Form zur Verfügung gestellt.", + "implementation": "Veroeffentlichung im ISMS-Tool und weiteren Kanälen (Abschnitt 8).", + "link": "{{LINK:L00#1.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.1.1-M5", + "policy": "L00", + "policy_file": "L00_Informationssicherheitsleitlinie.md", + "control": "1.1.1", + "type": "MUSS", + "req_anchor": "REQ 1.1.1-M5", + "impl_anchor": "REQ 1.1.1-M5", + "condition": null, + "requirement": "Mitarbeitende und externe Partner werden über relevante Änderungen informiert.", + "implementation": "Kommunikation relevanter Änderungen gemäß Abschnitt 8.", + "link": "{{LINK:L00#1.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.1.1-S1", + "policy": "L00", + "policy_file": "L00_Informationssicherheitsleitlinie.md", + "control": "1.1.1", + "type": "SOLL", + "req_anchor": "REQ 1.1.1-S1", + "impl_anchor": "REQ 1.1.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Die Anforderungen basieren auf der Strategie der Organisation; Gesetze und Verträge sind berücksichtigt.", + "implementation": "Beschrieben in Abschnitt 5.", + "link": "{{LINK:L00#1.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.1.1-S4", + "policy": "L00", + "policy_file": "L00_Informationssicherheitsleitlinie.md", + "control": "1.1.1", + "type": "SOLL", + "req_anchor": "REQ 1.1.1-S4", + "impl_anchor": "REQ 1.1.1-S4", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Regelmaessige Überprüfung und ggf. Revision der Leitlinie.", + "implementation": "Überprüfung mindestens jährlich und anlassbezogen (Abschnitt 9).", + "link": "{{LINK:L00#1.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.2.1-M1", + "policy": "R01", + "policy_file": "R01_ISMS-Organisation-und-Rollen.md", + "control": "1.2.1", + "type": "MUSS", + "req_anchor": "REQ 1.2.1-M1", + "impl_anchor": "IMPL 1.2.1-M1", + "condition": null, + "requirement": "Der Geltungsbereich des ISMS (Organisation, Standorte, Prozesse) ist bestimmt und dokumentiert.", + "implementation": "Der ISMS-Geltungsbereich (Organisation, Standorte, Prozesse) ist im ISMS-Tool ({{TOOL_NAME}}) dokumentiert, versioniert und wird dort gepflegt; wesentliche Änderungen gibt {{ROLE_ISB}} frei.", + "link": "{{LINK:R01#1.2.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.2.1-M2", + "policy": "R01", + "policy_file": "R01_ISMS-Organisation-und-Rollen.md", + "control": "1.2.1", + "type": "MUSS", + "req_anchor": "REQ 1.2.1-M2", + "impl_anchor": "IMPL 1.2.1-M2", + "condition": null, + "requirement": "Das ISMS wird durch die Leitung initiiert, gesteuert und überwacht; erforderliche Ressourcen werden bereitgestellt.", + "implementation": "Die {{ROLE_MANAGEMENT}} hat das ISMS per Managementbeschluss beauftragt, stellt Personal- und Budgetressourcen bereit und trägt die Gesamtverantwortung; die operative Steuerung liegt bei {{ROLE_ISB}}.", + "link": "{{LINK:R01#1.2.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.2.1-M3", + "policy": "R01", + "policy_file": "R01_ISMS-Organisation-und-Rollen.md", + "control": "1.2.1", + "type": "MUSS", + "req_anchor": "REQ 1.2.1-M3", + "impl_anchor": "IMPL 1.2.1-M3", + "condition": null, + "requirement": "Die Wirksamkeit des ISMS wird regelmäßig durch die Leitung bewertet (Managementbewertung).", + "implementation": "Die Wirksamkeit wird mindestens {{REVIEW_CYCLE}} in einer dokumentierten Managementbewertung anhand von Zielen, Kennzahlen sowie Audit- und Vorfallsergebnissen geprüft; Protokoll und Maßnahmen werden im ISMS-Tool ({{TOOL_NAME}}) abgelegt.", + "link": "{{LINK:R01#1.2.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.2.1-S1", + "policy": "R01", + "policy_file": "R01_ISMS-Organisation-und-Rollen.md", + "control": "1.2.1", + "type": "SOLL", + "req_anchor": "REQ 1.2.1-S1", + "impl_anchor": "IMPL 1.2.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Informationssicherheitsziele sind messbar formuliert und werden nachverfolgt (KPI).", + "implementation": "Messbare Informationssicherheitsziele und KPI (z. B. Schulungsquote, offene Maßnahmen, Patch-Compliance) sind definiert und werden im ISMS-Tool ({{TOOL_NAME}}) nachverfolgt.", + "link": "{{LINK:R01#1.2.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.2.2-M1", + "policy": "R01", + "policy_file": "R01_ISMS-Organisation-und-Rollen.md", + "control": "1.2.2", + "type": "MUSS", + "req_anchor": "REQ 1.2.2-M1", + "impl_anchor": "IMPL 1.2.2-M1", + "condition": null, + "requirement": "Verantwortlichkeiten für Informationssicherheit sind definiert, zugewiesen und dokumentiert.", + "implementation": "Verantwortlichkeiten sind in der Rollen-/Verantwortungsmatrix (Abschnitt 5) und im ISMS-Tool ({{TOOL_NAME}}) dokumentiert und den Rolleninhabern kommuniziert.", + "link": "{{LINK:R01#1.2.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.2.2-M2", + "policy": "R01", + "policy_file": "R01_ISMS-Organisation-und-Rollen.md", + "control": "1.2.2", + "type": "MUSS", + "req_anchor": "REQ 1.2.2-M2", + "impl_anchor": "IMPL 1.2.2-M2", + "condition": null, + "requirement": "Eine für Informationssicherheit verantwortliche Rolle ist benannt, verfügt über ausreichende Kompetenzen und einen direkten Berichtsweg zur Leitung.", + "implementation": "Die Rolle {{ROLE_ISB}} ist schriftlich benannt, mit Zeit-/Budgetressourcen und Weisungsrechten ausgestattet und berichtet direkt an die {{ROLE_MANAGEMENT}}.", + "link": "{{LINK:R01#1.2.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.2.2-S1", + "policy": "R01", + "policy_file": "R01_ISMS-Organisation-und-Rollen.md", + "control": "1.2.2", + "type": "SOLL", + "req_anchor": "REQ 1.2.2-S1", + "impl_anchor": "IMPL 1.2.2-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "In Konflikt stehende Aufgaben und Verantwortungsbereiche sind getrennt (Funktionstrennung).", + "implementation": "In Konflikt stehende Tätigkeiten (Umsetzung vs. Kontrolle, Beantragung vs. Genehmigung) sind getrennt; unvermeidbare Doppelrollen werden dokumentiert und durch kompensierende Kontrollen (Vier-Augen-Prinzip) abgesichert.", + "link": "{{LINK:R01#1.2.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.2.2-S2", + "policy": "R01", + "policy_file": "R01_ISMS-Organisation-und-Rollen.md", + "control": "1.2.2", + "type": "SOLL", + "req_anchor": "REQ 1.2.2-S2", + "impl_anchor": "IMPL 1.2.2-S2", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Kontakte zu relevanten Behörden und Interessengruppen werden gepflegt.", + "implementation": "Kontakte zu Behörden, CERT/CSIRT und relevanten Branchengremien werden von {{ROLE_ISB}} gepflegt und im ISMS-Tool hinterlegt.", + "link": "{{LINK:R01#1.2.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.2.3-M1", + "policy": "R01", + "policy_file": "R01_ISMS-Organisation-und-Rollen.md", + "control": "1.2.3", + "type": "MUSS", + "req_anchor": "REQ 1.2.3-M1", + "impl_anchor": "IMPL 1.2.3-M1", + "condition": null, + "requirement": "Projekte werden unter Berücksichtigung ihres Informationssicherheitsbedarfs klassifiziert.", + "implementation": "Projekte werden zu Beginn anhand eines Kriterienkatalogs hinsichtlich Informationssicherheitsbedarf bewertet und klassifiziert; die Einstufung wird im {{TOOL_TICKET}} bzw. ISMS-Tool dokumentiert.", + "link": "{{LINK:R01#1.2.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.2.3-M2", + "policy": "R01", + "policy_file": "R01_ISMS-Organisation-und-Rollen.md", + "control": "1.2.3", + "type": "MUSS", + "req_anchor": "REQ 1.2.3-M2", + "impl_anchor": "IMPL 1.2.3-M2", + "condition": null, + "requirement": "In Projekten werden Informationssicherheitsanforderungen ermittelt und berücksichtigt.", + "implementation": "Bei erhöhtem Schutzbedarf wird {{ROLE_ISB}} verbindlich eingebunden; ermittelte Sicherheitsanforderungen werden als Aufgaben im {{TOOL_TICKET}} nachgehalten und vor Projektabschluss geprüft.", + "link": "{{LINK:R01#1.2.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.2.3-S1", + "policy": "R01", + "policy_file": "R01_ISMS-Organisation-und-Rollen.md", + "control": "1.2.3", + "type": "SOLL", + "req_anchor": "REQ 1.2.3-S1", + "impl_anchor": "IMPL 1.2.3-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Verfahren und Kriterien zur Klassifizierung von Projekten sind dokumentiert und werden angewandt.", + "implementation": "Der Kriterienkatalog zur Projekteinstufung ist dokumentiert und wird einheitlich angewandt.", + "link": "{{LINK:R01#1.2.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.3.1-M1", + "policy": "R02", + "policy_file": "R02_Asset-und-Klassifizierungsrichtlinie.md", + "control": "1.3.1", + "type": "MUSS", + "req_anchor": "REQ 1.3.1-M1", + "impl_anchor": "IMPL 1.3.1-M1", + "condition": null, + "requirement": "Informationswerte und weitere Assets, die Informationen verarbeiten, sind identifiziert und erfasst.", + "implementation": "Informationswerte und Assets werden im ISMS-Tool ({{TOOL_NAME}}) im Asset-Inventar mit Attributen (Owner, Standort, Schutzbedarf) erfasst; Zu-/Abgänge werden über {{TOOL_TICKET}} ausgelöst.", + "link": "{{LINK:R02#1.3.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-08" + ] + }, + { + "id": "1.3.1-M2", + "policy": "R02", + "policy_file": "R02_Asset-und-Klassifizierungsrichtlinie.md", + "control": "1.3.1", + "type": "MUSS", + "req_anchor": "REQ 1.3.1-M2", + "impl_anchor": "IMPL 1.3.1-M2", + "condition": null, + "requirement": "Für jedes Asset ist ein Verantwortlicher (Owner) benannt.", + "implementation": "Jedem Asset ist im Inventar ein verantwortlicher Owner zugeordnet, der Klassifizierung und Aktualität verantwortet.", + "link": "{{LINK:R02#1.3.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-08" + ] + }, + { + "id": "1.3.1-S1", + "policy": "R02", + "policy_file": "R02_Asset-und-Klassifizierungsrichtlinie.md", + "control": "1.3.1", + "type": "SOLL", + "req_anchor": "REQ 1.3.1-S1", + "impl_anchor": "IMPL 1.3.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Ein Katalog der relevanten Informationswerte wird gepflegt und regelmäßig aktualisiert.", + "implementation": "Das Asset-Inventar wird laufend gepflegt und mindestens {{REVIEW_CYCLE}} vollständig auf Aktualität geprüft (Review durch {{ROLE_IT_LEAD}}).", + "link": "{{LINK:R02#1.3.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-08" + ] + }, + { + "id": "1.3.2-M1", + "policy": "R02", + "policy_file": "R02_Asset-und-Klassifizierungsrichtlinie.md", + "control": "1.3.2", + "type": "MUSS", + "req_anchor": "REQ 1.3.2-M1", + "impl_anchor": "IMPL 1.3.2-M1", + "condition": null, + "requirement": "Informationswerte sind nach Schutzbedarf (Vertraulichkeit, Integrität, Verfügbarkeit) klassifiziert.", + "implementation": "Es gilt ein vierstufiges Klassifizierungsschema (Öffentlich / Intern / Vertraulich / Streng vertraulich); die Einstufung nach Vertraulichkeit, Integrität und Verfügbarkeit erfolgt durch den Asset Owner im ISMS-Tool.", + "link": "{{LINK:R02#1.3.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-08" + ] + }, + { + "id": "1.3.2-M2", + "policy": "R02", + "policy_file": "R02_Asset-und-Klassifizierungsrichtlinie.md", + "control": "1.3.2", + "type": "MUSS", + "req_anchor": "REQ 1.3.2-M2", + "impl_anchor": "IMPL 1.3.2-M2", + "condition": null, + "requirement": "Abhängig von der Klassifizierung sind Vorgaben zu Kennzeichnung, Handhabung, Speicherung, Uebertragung und Löschung definiert.", + "implementation": "Je Schutzklasse sind Handhabungsvorgaben zu Kennzeichnung, Speicherung, Übertragung (BL-CRY-01/04) und Löschung (BL-DEL-01) definiert und den Mitarbeitenden bekannt gemacht.", + "link": "{{LINK:R02#1.3.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-08" + ] + }, + { + "id": "1.3.2-S1", + "policy": "R02", + "policy_file": "R02_Asset-und-Klassifizierungsrichtlinie.md", + "control": "1.3.2", + "type": "SOLL", + "req_anchor": "REQ 1.3.2-S1", + "impl_anchor": "IMPL 1.3.2-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Die Klassifizierung wird bei wesentlichen Aenderungen überprüft und angepasst.", + "implementation": "Bei wesentlichen Änderungen wird die Klassifizierung durch den Asset Owner überprüft und im ISMS-Tool aktualisiert.", + "link": "{{LINK:R02#1.3.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-08" + ] + }, + { + "id": "1.3.3-M1", + "policy": "R02", + "policy_file": "R02_Asset-und-Klassifizierungsrichtlinie.md", + "control": "1.3.3", + "type": "MUSS", + "req_anchor": "REQ 1.3.3-M1", + "impl_anchor": "IMPL 1.3.3-M1", + "condition": null, + "requirement": "Es ist sichergestellt, dass nur bewertete und freigegebene externe Hardware/IT-Komponenten eingesetzt werden.", + "implementation": "Externe Hardware/IT-Komponenten werden vor Einsatz technisch und sicherheitsseitig bewertet und freigegeben; die Freigabeliste wird im ISMS-Tool ({{TOOL_NAME}}) geführt.", + "link": "{{LINK:R02#1.3.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.3.3-S1", + "policy": "R02", + "policy_file": "R02_Asset-und-Klassifizierungsrichtlinie.md", + "control": "1.3.3", + "type": "SOLL", + "req_anchor": "REQ 1.3.3-S1", + "impl_anchor": "IMPL 1.3.3-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Nicht freigegebene Geräte werden technisch unterbunden.", + "implementation": "Der Anschluss nicht freigegebener Geräte wird soweit möglich technisch unterbunden (z. B. Portkontrolle, {{TECH_MDM}}).", + "link": "{{LINK:R02#1.3.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.3.4-M1", + "policy": "R02", + "policy_file": "R02_Asset-und-Klassifizierungsrichtlinie.md", + "control": "1.3.4", + "type": "MUSS", + "req_anchor": "REQ 1.3.4-M1", + "impl_anchor": "IMPL 1.3.4-M1", + "condition": null, + "requirement": "Es ist sichergestellt, dass nur bewertete und freigegebene Software eingesetzt wird.", + "implementation": "Software wird vor Einsatz freigegeben; eine Liste zugelassener Software (Whitelist) wird im ISMS-Tool gepflegt, Beschaffung/Freigabe läuft über {{TOOL_TICKET}}.", + "link": "{{LINK:R02#1.3.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.3.4-S1", + "policy": "R02", + "policy_file": "R02_Asset-und-Klassifizierungsrichtlinie.md", + "control": "1.3.4", + "type": "SOLL", + "req_anchor": "REQ 1.3.4-S1", + "impl_anchor": "IMPL 1.3.4-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Die Installation nicht freigegebener Software wird technisch eingeschränkt.", + "implementation": "Die Installation von Software ist für Standardnutzer technisch eingeschränkt (keine lokalen Adminrechte); Ausnahmen werden im {{TOOL_TICKET}} genehmigt.", + "link": "{{LINK:R02#1.3.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.4.1-M1", + "policy": "R03", + "policy_file": "R03_Risikomanagement-und-Auditrichtlinie.md", + "control": "1.4.1", + "type": "MUSS", + "req_anchor": "REQ 1.4.1-M1", + "impl_anchor": "IMPL 1.4.1-M1", + "condition": null, + "requirement": "Es existiert ein dokumentiertes Verfahren zur Identifikation, Analyse, Bewertung und Behandlung von Informationssicherheitsrisiken.", + "implementation": "Das Risikomanagement-Verfahren (Identifikation, Analyse, Bewertung, Behandlung) ist dokumentiert; Risiken werden im ISMS-Tool ({{TOOL_NAME}}) im Risikoregister geführt.", + "link": "{{LINK:R03#1.4.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-09" + ] + }, + { + "id": "1.4.1-M2", + "policy": "R03", + "policy_file": "R03_Risikomanagement-und-Auditrichtlinie.md", + "control": "1.4.1", + "type": "MUSS", + "req_anchor": "REQ 1.4.1-M2", + "impl_anchor": "IMPL 1.4.1-M2", + "condition": null, + "requirement": "Risiken werden in einem Risikoregister erfasst; Behandlungsoptionen und Maßnahmen sind festgelegt.", + "implementation": "Je Risiko sind Eintrittswahrscheinlichkeit, Schadenshöhe, Behandlungsoption (reduzieren/vermeiden/übertragen/akzeptieren), Maßnahmen, Verantwortlicher und Termin hinterlegt.", + "link": "{{LINK:R03#1.4.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-09" + ] + }, + { + "id": "1.4.1-M3", + "policy": "R03", + "policy_file": "R03_Risikomanagement-und-Auditrichtlinie.md", + "control": "1.4.1", + "type": "MUSS", + "req_anchor": "REQ 1.4.1-M3", + "impl_anchor": "IMPL 1.4.1-M3", + "condition": null, + "requirement": "Die Risikobewertung wird regelmäßig und anlassbezogen aktualisiert; die Risikoakzeptanz erfolgt durch die Leitung.", + "implementation": "Die Bewertung wird mindestens {{REVIEW_CYCLE}} und anlassbezogen (neue Systeme, Vorfälle, Änderungen) aktualisiert; Restrisiken werden von der {{ROLE_MANAGEMENT}} dokumentiert akzeptiert.", + "link": "{{LINK:R03#1.4.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-09" + ] + }, + { + "id": "1.4.1-S1", + "policy": "R03", + "policy_file": "R03_Risikomanagement-und-Auditrichtlinie.md", + "control": "1.4.1", + "type": "SOLL", + "req_anchor": "REQ 1.4.1-S1", + "impl_anchor": "IMPL 1.4.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Kriterien für Eintrittswahrscheinlichkeit, Schadenshöhe und Akzeptanzschwellen sind definiert.", + "implementation": "Bewertungsskalen und Akzeptanzschwellen sind definiert und im ISMS-Tool hinterlegt.", + "link": "{{LINK:R03#1.4.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-09" + ] + }, + { + "id": "1.5.1-M1", + "policy": "R03", + "policy_file": "R03_Risikomanagement-und-Auditrichtlinie.md", + "control": "1.5.1", + "type": "MUSS", + "req_anchor": "REQ 1.5.1-M1", + "impl_anchor": "IMPL 1.5.1-M1", + "condition": null, + "requirement": "Die Einhaltung der Informationssicherheitsvorgaben wird regelmäßig geprüft.", + "implementation": "Die Einhaltung wird durch interne Audits und stichprobenartige Kontrollen (nach Auditplan) geprüft; Feststellungen werden im ISMS-Tool als Maßnahmen nachverfolgt.", + "link": "{{LINK:R03#1.5.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.5.1-S1", + "policy": "R03", + "policy_file": "R03_Risikomanagement-und-Auditrichtlinie.md", + "control": "1.5.1", + "type": "SOLL", + "req_anchor": "REQ 1.5.1-S1", + "impl_anchor": "IMPL 1.5.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Ein Auditprogramm mit Umfang, Turnus und Verantwortlichkeiten ist etabliert; Feststellungen werden nachverfolgt.", + "implementation": "Ein jährliches Auditprogramm mit Umfang, Turnus und Verantwortlichkeiten ist etabliert.", + "link": "{{LINK:R03#1.5.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.5.2-M1", + "policy": "R03", + "policy_file": "R03_Risikomanagement-und-Auditrichtlinie.md", + "control": "1.5.2", + "type": "MUSS", + "req_anchor": "REQ 1.5.2-M1", + "impl_anchor": "IMPL 1.5.2-M1", + "condition": null, + "requirement": "Das ISMS wird durch eine unabhängige Stelle überprüft.", + "implementation": "Das ISMS wird durch eine unabhängige Stelle (interne Revision oder externe Auditierung, z. B. TISAX) überprüft.", + "link": "{{LINK:R03#1.5.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.5.2-S1", + "policy": "R03", + "policy_file": "R03_Risikomanagement-und-Auditrichtlinie.md", + "control": "1.5.2", + "type": "SOLL", + "req_anchor": "REQ 1.5.2-S1", + "impl_anchor": "IMPL 1.5.2-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Ergebnisse fließen in die Managementbewertung und den Verbesserungsprozess ein.", + "implementation": "Die Ergebnisse werden in der Managementbewertung behandelt und fließen in den kontinuierlichen Verbesserungsprozess ein.", + "link": "{{LINK:R03#1.5.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.6.1-M1", + "policy": "R04", + "policy_file": "R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md", + "control": "1.6.1", + "type": "MUSS", + "req_anchor": "REQ 1.6.1-M1", + "impl_anchor": "IMPL 1.6.1-M1", + "condition": null, + "requirement": "Sicherheitsrelevante Ereignisse und Beobachtungen können über einen definierten Meldeweg gemeldet werden.", + "implementation": "Sicherheitsereignisse können über einen definierten Meldeweg (Meldebutton/Formular im {{TOOL_TICKET}} bzw. ISMS-Tool sowie per E-Mail an {{ROLE_ISB}}) gemeldet werden.", + "link": "{{LINK:R04#1.6.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-01" + ] + }, + { + "id": "1.6.1-M2", + "policy": "R04", + "policy_file": "R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md", + "control": "1.6.1", + "type": "MUSS", + "req_anchor": "REQ 1.6.1-M2", + "impl_anchor": "IMPL 1.6.1-M2", + "condition": null, + "requirement": "Der Meldeweg ist bekannt gemacht und niedrigschwellig erreichbar.", + "implementation": "Der Meldeweg ist allen Beschäftigten über Onboarding und Awareness (BL-HR-01) bekannt und niedrigschwellig, auch anonym, erreichbar.", + "link": "{{LINK:R04#1.6.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-01" + ] + }, + { + "id": "1.6.1-S1", + "policy": "R04", + "policy_file": "R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md", + "control": "1.6.1", + "type": "SOLL", + "req_anchor": "REQ 1.6.1-S1", + "impl_anchor": "IMPL 1.6.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Meldungen werden zentral erfasst und kategorisiert.", + "implementation": "Meldungen werden zentral im ISMS-Tool erfasst, kategorisiert und einem Schweregrad zugeordnet.", + "link": "{{LINK:R04#1.6.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "1.6.2-M1", + "policy": "R04", + "policy_file": "R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md", + "control": "1.6.2", + "type": "MUSS", + "req_anchor": "REQ 1.6.2-M1", + "impl_anchor": "IMPL 1.6.2-M1", + "condition": null, + "requirement": "Gemeldete Sicherheitsereignisse werden bewertet, priorisiert, behandelt und dokumentiert.", + "implementation": "Ereignisse werden nach einem definierten Incident-Verfahren bewertet, priorisiert, eingedämmt, behoben und dokumentiert; die Bearbeitung erfolgt im {{TOOL_TICKET}}.", + "link": "{{LINK:R04#1.6.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-01" + ] + }, + { + "id": "1.6.2-M2", + "policy": "R04", + "policy_file": "R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md", + "control": "1.6.2", + "type": "MUSS", + "req_anchor": "REQ 1.6.2-M2", + "impl_anchor": "IMPL 1.6.2-M2", + "condition": null, + "requirement": "Verantwortlichkeiten und Eskalationswege für die Vorfallsbehandlung sind definiert.", + "implementation": "Verantwortlichkeiten und Eskalationsstufen sind definiert; {{ROLE_ISB}} koordiniert, {{ROLE_IT_LEAD}} setzt technische Maßnahmen um.", + "link": "{{LINK:R04#1.6.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-01" + ] + }, + { + "id": "1.6.2-S1", + "policy": "R04", + "policy_file": "R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md", + "control": "1.6.2", + "type": "SOLL", + "req_anchor": "REQ 1.6.2-S1", + "impl_anchor": "IMPL 1.6.2-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Erkenntnisse aus Vorfällen werden ausgewertet (Lessons Learned) und führen zu Verbesserungen.", + "implementation": "Nach relevanten Vorfällen erfolgt eine Nachbereitung (Lessons Learned) mit Ableitung und Nachverfolgung von Verbesserungsmaßnahmen.", + "link": "{{LINK:R04#1.6.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-01" + ] + }, + { + "id": "1.6.2-S2", + "policy": "R04", + "policy_file": "R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md", + "control": "1.6.2", + "type": "SOLL", + "req_anchor": "REQ 1.6.2-S2", + "impl_anchor": "IMPL 1.6.2-S2", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Meldepflichten (z. B. an Kunden/OEM, Behörden) sind berücksichtigt.", + "implementation": "Vertragliche und gesetzliche Meldepflichten (Kunden/OEM, Aufsichtsbehörden, bei personenbezogenen Daten binnen 72 Stunden) sind im Verfahren berücksichtigt.", + "link": "{{LINK:R04#1.6.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-01" + ] + }, + { + "id": "1.6.3-M1", + "policy": "R04", + "policy_file": "R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md", + "control": "1.6.3", + "type": "MUSS", + "req_anchor": "REQ 1.6.3-M1", + "impl_anchor": "IMPL 1.6.3-M1", + "condition": null, + "requirement": "Die Organisation ist auf die Bewältigung von Krisensituationen vorbereitet (Rollen, Kommunikation, Entscheidungswege).", + "implementation": "Ein Krisenmanagement mit Krisenstab, Rollen, Kommunikations- und Entscheidungswegen ist definiert; der Krisenstab wird durch die {{ROLE_MANAGEMENT}} einberufen.", + "link": "{{LINK:R04#1.6.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-02" + ] + }, + { + "id": "1.6.3-S1", + "policy": "R04", + "policy_file": "R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md", + "control": "1.6.3", + "type": "SOLL", + "req_anchor": "REQ 1.6.3-S1", + "impl_anchor": "IMPL 1.6.3-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Krisen-/Notfallpläne werden regelmäßig geübt und aktualisiert.", + "implementation": "Krisen- und Notfallpläne werden mindestens {{REVIEW_CYCLE}} geübt (z. B. Tabletop-Übung) und aktualisiert.", + "link": "{{LINK:R04#1.6.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-02" + ] + }, + { + "id": "5.2.8-M1", + "policy": "R04", + "policy_file": "R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md", + "control": "5.2.8", + "type": "MUSS", + "req_anchor": "REQ 5.2.8-M1", + "impl_anchor": "IMPL 5.2.8-M1", + "condition": null, + "requirement": "Für kritische IT-Dienste besteht eine Kontinuitätsplanung (Wiederanlaufziele, Verantwortliche, Maßnahmen).", + "implementation": "Für kritische IT-Dienste bestehen Wiederanlaufziele (RTO/RPO), Verantwortliche und Maßnahmen; {{ROLE_IT_LEAD}} verantwortet die Kontinuitätsplanung.", + "link": "{{LINK:R04#5.2.8}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-02" + ] + }, + { + "id": "5.2.8-S1", + "policy": "R04", + "policy_file": "R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md", + "control": "5.2.8", + "type": "SOLL", + "req_anchor": "REQ 5.2.8-S1", + "impl_anchor": "IMPL 5.2.8-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Wiederanlaufmaßnahmen werden regelmäßig getestet; Ergebnisse werden dokumentiert.", + "implementation": "Wiederanlaufmaßnahmen werden mindestens {{BACKUP_TEST_FREQ}} getestet (BL-OPS-06); Ergebnisse werden dokumentiert.", + "link": "{{LINK:R04#5.2.8}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-02" + ] + }, + { + "id": "2.1.1-M1", + "policy": "R05", + "policy_file": "R05_Personalsicherheit-und-Awareness.md", + "control": "2.1.1", + "type": "MUSS", + "req_anchor": "REQ 2.1.1-M1", + "impl_anchor": "IMPL 2.1.1-M1", + "condition": null, + "requirement": "Für sicherheitsrelevante/sensible Tätigkeiten ist die erforderliche Qualifikation und Zuverlässigkeit der Beschäftigten sichergestellt.", + "implementation": "Für sensible Tätigkeiten werden Qualifikation und Zuverlässigkeit im rechtlich zulässigen Rahmen sichergestellt (z. B. Qualifikationsnachweise, bei besonders schutzbedürftigen Rollen ggf. Führungszeugnis).", + "link": "{{LINK:R05#2.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "2.1.1-S1", + "policy": "R05", + "policy_file": "R05_Personalsicherheit-und-Awareness.md", + "control": "2.1.1", + "type": "SOLL", + "req_anchor": "REQ 2.1.1-S1", + "impl_anchor": "IMPL 2.1.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Anforderungen an Positionen sind beschrieben; angemessene Überprüfungen erfolgen im rechtlich zulässigen Rahmen.", + "implementation": "Sicherheitsanforderungen an Positionen sind in Stellenbeschreibungen hinterlegt; Überprüfungen erfolgen anlass- und rollenbezogen.", + "link": "{{LINK:R05#2.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "2.1.2-M1", + "policy": "R05", + "policy_file": "R05_Personalsicherheit-und-Awareness.md", + "control": "2.1.2", + "type": "MUSS", + "req_anchor": "REQ 2.1.2-M1", + "impl_anchor": "IMPL 2.1.2-M1", + "condition": null, + "requirement": "Alle Beschäftigten sind vertraglich zur Einhaltung der Informationssicherheit und zur Vertraulichkeit verpflichtet.", + "implementation": "Alle Beschäftigten werden bei Eintritt vertraglich zur Vertraulichkeit und Einhaltung der Informationssicherheit verpflichtet ({{ROLE_HR_LEAD}}); der Nachweis wird in der Personalakte geführt.", + "link": "{{LINK:R05#2.1.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "2.1.2-S1", + "policy": "R05", + "policy_file": "R05_Personalsicherheit-und-Awareness.md", + "control": "2.1.2", + "type": "SOLL", + "req_anchor": "REQ 2.1.2-S1", + "impl_anchor": "IMPL 2.1.2-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Verpflichtungen gelten auch nach Beendigung des Arbeitsverhältnisses fort und umfassen Rückgabepflichten.", + "implementation": "Die Vertraulichkeitsverpflichtung gilt nachvertraglich fort; Rückgabe von Assets und Entzug von Berechtigungen beim Austritt sind über {{TOOL_TICKET}} geregelt (Leaver-Prozess).", + "link": "{{LINK:R05#2.1.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "2.1.3-M1", + "policy": "R05", + "policy_file": "R05_Personalsicherheit-und-Awareness.md", + "control": "2.1.3", + "type": "MUSS", + "req_anchor": "REQ 2.1.3-M1", + "impl_anchor": "IMPL 2.1.3-M1", + "condition": null, + "requirement": "Beschäftigte werden hinsichtlich Informationssicherheit sensibilisiert und geschult.", + "implementation": "Beschäftigte werden bei Eintritt und danach mindestens {{REVIEW_CYCLE}} geschult (BL-HR-01); Teilnahmenachweise werden im {{TOOL_NAME}} geführt.", + "link": "{{LINK:R05#2.1.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-12" + ] + }, + { + "id": "2.1.3-S1", + "policy": "R05", + "policy_file": "R05_Personalsicherheit-und-Awareness.md", + "control": "2.1.3", + "type": "SOLL", + "req_anchor": "REQ 2.1.3-S1", + "impl_anchor": "IMPL 2.1.3-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Schulungsinhalte sind rollenspezifisch; die Wirksamkeit wird überprüft (z. B. Phishing-Tests).", + "implementation": "Schulungen sind rollenspezifisch; die Wirksamkeit wird durch Phishing-Simulationen und gezielte Nachschulungen überprüft.", + "link": "{{LINK:R05#2.1.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-12" + ] + }, + { + "id": "2.1.4-M1", + "policy": "R06", + "policy_file": "R06_Mobiles-Arbeiten-und-mobile-Geraete.md", + "control": "2.1.4", + "type": "MUSS", + "req_anchor": "REQ 2.1.4-M1", + "impl_anchor": "IMPL 2.1.4-M1", + "condition": null, + "requirement": "Mobiles Arbeiten ist geregelt (zulässige Orte, Umgang mit Informationen, Absicherung der Verbindung).", + "implementation": "Mobiles Arbeiten ist in einer Regelung festgelegt; der Zugriff erfolgt ausschließlich über {{TECH_VPN}} mit MFA (BL-IAM-02) und freigegebene, verschlüsselte Geräte (BL-CRY-03).", + "link": "{{LINK:R06#2.1.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "2.1.4-M2", + "policy": "R06", + "policy_file": "R06_Mobiles-Arbeiten-und-mobile-Geraete.md", + "control": "2.1.4", + "type": "MUSS", + "req_anchor": "REQ 2.1.4-M2", + "impl_anchor": "IMPL 2.1.4-M2", + "condition": null, + "requirement": "Der Zugriff auf Unternehmensinformationen erfolgt ausschließlich über gesicherte Verbindungen und freigegebene Geräte.", + "implementation": "Der Zugriff auf Unternehmensinformationen ist auf verwaltete Geräte ({{TECH_MDM}}) beschränkt; die Nutzung ist an die Einhaltung der Regelung gebunden.", + "link": "{{LINK:R06#2.1.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "2.1.4-S1", + "policy": "R06", + "policy_file": "R06_Mobiles-Arbeiten-und-mobile-Geraete.md", + "control": "2.1.4", + "type": "SOLL", + "req_anchor": "REQ 2.1.4-S1", + "impl_anchor": "IMPL 2.1.4-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Sichtschutz, Clean-Desk/Clean-Screen und Regeln für öffentliche Umgebungen sind definiert.", + "implementation": "Regeln zu Sichtschutz, Clean-Desk/Clean-Screen und zum Arbeiten in öffentlichen Umgebungen sind definiert und Teil der Awareness (BL-HR-01).", + "link": "{{LINK:R06#2.1.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "3.1.4-M1", + "policy": "R06", + "policy_file": "R06_Mobiles-Arbeiten-und-mobile-Geraete.md", + "control": "3.1.4", + "type": "MUSS", + "req_anchor": "REQ 3.1.4-M1", + "impl_anchor": "IMPL 3.1.4-M1", + "condition": null, + "requirement": "Der Umgang mit mobilen IT-Geräten und mobilen Datenträgern ist geregelt (Verschlüsselung, Verlustmeldung, Freigabe).", + "implementation": "Mobile Geräte sind vollverschlüsselt (BL-CRY-03) und über {{TECH_MDM}} zentral verwaltet; Verlustmeldung erfolgt über den Meldeweg (R04) und {{TOOL_TICKET}}.", + "link": "{{LINK:R06#3.1.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "3.1.4-M2", + "policy": "R06", + "policy_file": "R06_Mobiles-Arbeiten-und-mobile-Geraete.md", + "control": "3.1.4", + "type": "MUSS", + "req_anchor": "REQ 3.1.4-M2", + "impl_anchor": "IMPL 3.1.4-M2", + "condition": null, + "requirement": "Mobile Geräte sind verschlüsselt und können bei Verlust gesperrt/gelöscht werden.", + "implementation": "Bei Verlust können Geräte über {{TECH_MDM}} gesperrt und aus der Ferne gelöscht werden (BL-EP-02).", + "link": "{{LINK:R06#3.1.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "3.1.4-S1", + "policy": "R06", + "policy_file": "R06_Mobiles-Arbeiten-und-mobile-Geraete.md", + "control": "3.1.4", + "type": "SOLL", + "req_anchor": "REQ 3.1.4-S1", + "impl_anchor": "IMPL 3.1.4-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Der Einsatz privater Geräte (BYOD) ist geregelt oder untersagt; Wechseldatenträger werden kontrolliert.", + "implementation": "Der Einsatz privater Geräte (BYOD) ist geregelt bzw. untersagt; Wechseldatenträger werden nur verschlüsselt und freigegeben zugelassen (BL-EP-03).", + "link": "{{LINK:R06#3.1.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "3.1.1-M1", + "policy": "R07", + "policy_file": "R07_Physische-Sicherheit.md", + "control": "3.1.1", + "type": "MUSS", + "req_anchor": "REQ 3.1.1-M1", + "impl_anchor": "IMPL 3.1.1-M1", + "condition": null, + "requirement": "Sicherheitszonen sind definiert und der Zutritt zu schützenswerten Bereichen ist reglementiert und nachvollziehbar.", + "implementation": "Sicherheitszonen sind definiert (BL-PHY-01); der Zutritt zu schutzbedürftigen Bereichen (z. B. Serverraum) ist reglementiert und wird protokolliert (BL-PHY-02).", + "link": "{{LINK:R07#3.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "3.1.1-M2", + "policy": "R07", + "policy_file": "R07_Physische-Sicherheit.md", + "control": "3.1.1", + "type": "MUSS", + "req_anchor": "REQ 3.1.1-M2", + "impl_anchor": "IMPL 3.1.1-M2", + "condition": null, + "requirement": "Zutrittsrechte werden nach Bedarf vergeben, dokumentiert und bei Wegfall entzogen.", + "implementation": "Zutrittsrechte werden bedarfsorientiert über {{TOOL_TICKET}} vergeben, dokumentiert und bei Wegfall (Austritt/Rollenwechsel) entzogen.", + "link": "{{LINK:R07#3.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "3.1.1-S1", + "policy": "R07", + "policy_file": "R07_Physische-Sicherheit.md", + "control": "3.1.1", + "type": "SOLL", + "req_anchor": "REQ 3.1.1-S1", + "impl_anchor": "IMPL 3.1.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Zutritte werden protokolliert; Besucher werden begleitet; technische Schutzmaßnahmen sind vorhanden.", + "implementation": "Besucher werden registriert und begleitet; technische Schutzmaßnahmen (Zutrittskontrolle, Alarm, Videoüberwachung im rechtlichen Rahmen) sind vorhanden.", + "link": "{{LINK:R07#3.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "3.1.3-M1", + "policy": "R07", + "policy_file": "R07_Physische-Sicherheit.md", + "control": "3.1.3", + "type": "MUSS", + "req_anchor": "REQ 3.1.3-M1", + "impl_anchor": "IMPL 3.1.3-M1", + "condition": null, + "requirement": "Der Umgang mit unterstützenden Assets (z. B. Verkabelung, Strom-/Klimaversorgung, Serverräume) ist geregelt und schützt vor Ausfall und unbefugtem Zugriff.", + "implementation": "Serverräume und Versorgungseinrichtungen (Strom, Klima, Verkabelung) sind zutrittsgeschützt und gegen Ausfall abgesichert.", + "link": "{{LINK:R07#3.1.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "3.1.3-S1", + "policy": "R07", + "policy_file": "R07_Physische-Sicherheit.md", + "control": "3.1.3", + "type": "SOLL", + "req_anchor": "REQ 3.1.3-S1", + "impl_anchor": "IMPL 3.1.3-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Versorgungseinrichtungen werden gewartet und überwacht; Redundanzen bestehen für kritische Bereiche.", + "implementation": "Versorgungseinrichtungen werden gewartet und überwacht; für kritische Bereiche bestehen Redundanzen (z. B. USV, Klimaredundanz).", + "link": "{{LINK:R07#3.1.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "4.1.1-M1", + "policy": "R08", + "policy_file": "R08_Identitaets-und-Zugriffsmanagement.md", + "control": "4.1.1", + "type": "MUSS", + "req_anchor": "REQ 4.1.1-M1", + "impl_anchor": "IMPL 4.1.1-M1", + "condition": null, + "requirement": "Der Einsatz von Identifikationsmitteln (Benutzerkennungen, Token, Zertifikate) ist geregelt und eindeutig personenbezogen.", + "implementation": "Identifikationsmittel (Benutzerkennungen, Token, Zertifikate) werden eindeutig personenbezogen über {{TOOL_IAM}} vergeben; Sammelkonten werden vermieden bzw. dokumentiert und begründet.", + "link": "{{LINK:R08#4.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "4.1.1-S1", + "policy": "R08", + "policy_file": "R08_Identitaets-und-Zugriffsmanagement.md", + "control": "4.1.1", + "type": "SOLL", + "req_anchor": "REQ 4.1.1-S1", + "impl_anchor": "IMPL 4.1.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Ausgabe, Rücknahme und Sperrung von Identifikationsmitteln sind dokumentiert.", + "implementation": "Ausgabe, Rücknahme und Sperrung von Identifikationsmitteln werden im {{TOOL_TICKET}} beantragt, genehmigt und dokumentiert (BL-IAM-07).", + "link": "{{LINK:R08#4.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-03" + ] + }, + { + "id": "4.1.2-M1", + "policy": "R08", + "policy_file": "R08_Identitaets-und-Zugriffsmanagement.md", + "control": "4.1.2", + "type": "MUSS", + "req_anchor": "REQ 4.1.2-M1", + "impl_anchor": "IMPL 4.1.2-M1", + "condition": null, + "requirement": "Der Zugang zu IT-Diensten und IT-Systemen ist durch sichere Authentifizierungsverfahren geschützt.", + "implementation": "Der Zugang ist durch sichere Authentifizierung geschützt; die Passwortvorgaben nach BL-IAM-01 (mind. {{PW_MIN_LENGTH}} Zeichen, {{PW_COMPLEXITY}}, {{PW_ROTATION}}) werden zentral über {{TOOL_IAM}} erzwungen.", + "link": "{{LINK:R08#4.1.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "4.1.2-M2", + "policy": "R08", + "policy_file": "R08_Identitaets-und-Zugriffsmanagement.md", + "control": "4.1.2", + "type": "MUSS", + "req_anchor": "REQ 4.1.2-M2", + "impl_anchor": "IMPL 4.1.2-M2", + "condition": null, + "requirement": "Für erhöhten Schutzbedarf und Fernzugriffe wird Mehr-Faktor-Authentifizierung (MFA) eingesetzt.", + "implementation": "Für Fernzugriffe, administrative Zugänge und Cloud-Dienste wird MFA gemäß BL-IAM-02 über {{TECH_MFA}} durchgesetzt.", + "link": "{{LINK:R08#4.1.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "4.1.2-S1", + "policy": "R08", + "policy_file": "R08_Identitaets-und-Zugriffsmanagement.md", + "control": "4.1.2", + "type": "SOLL", + "req_anchor": "REQ 4.1.2-S1", + "impl_anchor": "IMPL 4.1.2-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Passwortanforderungen, Sperrmechanismen und Sitzungsverwaltung sind definiert.", + "implementation": "Sperrmechanismen (BL-IAM-04) und Sitzungs-Timeouts (BL-IAM-03) sind zentral konfiguriert.", + "link": "{{LINK:R08#4.1.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "4.1.3-M1", + "policy": "R08", + "policy_file": "R08_Identitaets-und-Zugriffsmanagement.md", + "control": "4.1.3", + "type": "MUSS", + "req_anchor": "REQ 4.1.3-M1", + "impl_anchor": "IMPL 4.1.3-M1", + "condition": null, + "requirement": "Benutzerkonten und Anmeldeinformationen werden sicher verwaltet (Erstellung, Aenderung, Sperrung, Löschung).", + "implementation": "Konten werden über einen definierten Lebenszyklus (Joiner/Mover/Leaver) verwaltet; Auslöser sind {{TOOL_TICKET}}-Aufträge aus HR-/Vorgesetztenmeldungen.", + "link": "{{LINK:R08#4.1.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-03" + ] + }, + { + "id": "4.1.3-S1", + "policy": "R08", + "policy_file": "R08_Identitaets-und-Zugriffsmanagement.md", + "control": "4.1.3", + "type": "SOLL", + "req_anchor": "REQ 4.1.3-S1", + "impl_anchor": "IMPL 4.1.3-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Privilegierte und technische Konten werden gesondert verwaltet und überwacht.", + "implementation": "Privilegierte und technische Konten werden gesondert verwaltet, einzeln zugeordnet und verstärkt protokolliert (BL-IAM-06).", + "link": "{{LINK:R08#4.1.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "4.2.1-M1", + "policy": "R08", + "policy_file": "R08_Identitaets-und-Zugriffsmanagement.md", + "control": "4.2.1", + "type": "MUSS", + "req_anchor": "REQ 4.2.1-M1", + "impl_anchor": "IMPL 4.2.1-M1", + "condition": null, + "requirement": "Zugriffsrechte werden nach dem Minimalprinzip (need-to-know / least privilege) vergeben; Verfahren für Antrag, Prüfung und Genehmigung bestehen.", + "implementation": "Zugriffsrechte werden nach dem Minimalprinzip (need-to-know/least privilege) vergeben; Antrag, fachliche Prüfung und Genehmigung erfolgen im {{TOOL_TICKET}}.", + "link": "{{LINK:R08#4.2.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-03" + ] + }, + { + "id": "4.2.1-M2", + "policy": "R08", + "policy_file": "R08_Identitaets-und-Zugriffsmanagement.md", + "control": "4.2.1", + "type": "MUSS", + "req_anchor": "REQ 4.2.1-M2", + "impl_anchor": "IMPL 4.2.1-M2", + "condition": null, + "requirement": "Zugriffsrechte werden bei Wegfall des Bedarfs entzogen und regelmäßig überprüft (Rezertifizierung), auch für Zugriffe in Kundensystemen.", + "implementation": "Berechtigungen werden beim Wegfall entzogen und mindestens {{RECERT_FREQ}} rezertifiziert (BL-IAM-05), auch für Zugriffe in Kundensystemen.", + "link": "{{LINK:R08#4.2.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-03" + ] + }, + { + "id": "4.2.1-S1", + "policy": "R08", + "policy_file": "R08_Identitaets-und-Zugriffsmanagement.md", + "control": "4.2.1", + "type": "SOLL", + "req_anchor": "REQ 4.2.1-S1", + "impl_anchor": "IMPL 4.2.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Berechtigungen werden über Rollen vergeben; normale Konten erhalten keine privilegierten Rechte.", + "implementation": "Berechtigungen werden rollenbasiert (RBAC) über {{TOOL_IAM}} vergeben; Standardkonten erhalten keine privilegierten Rechte.", + "link": "{{LINK:R08#4.2.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-03" + ] + }, + { + "id": "5.1.1-M1", + "policy": "R09", + "policy_file": "R09_Kryptografie-und-Uebertragungsrichtlinie.md", + "control": "5.1.1", + "type": "MUSS", + "req_anchor": "REQ 5.1.1-M1", + "impl_anchor": "IMPL 5.1.1-M1", + "condition": null, + "requirement": "Der Einsatz von Kryptografie ist geregelt; zulässige Verfahren und Schlüssellängen entsprechen dem Stand der Technik.", + "implementation": "Zulässige Verfahren und Schlüssellängen nach BL-CRY-02 ({{CRYPTO_ALGO}}) sind vorgegeben; veraltete Verfahren sind untersagt.", + "link": "{{LINK:R09#5.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-07" + ] + }, + { + "id": "5.1.1-M2", + "policy": "R09", + "policy_file": "R09_Kryptografie-und-Uebertragungsrichtlinie.md", + "control": "5.1.1", + "type": "MUSS", + "req_anchor": "REQ 5.1.1-M2", + "impl_anchor": "IMPL 5.1.1-M2", + "condition": null, + "requirement": "Schlüssel werden über ihren gesamten Lebenszyklus sicher verwaltet.", + "implementation": "Schlüssel werden über ihren Lebenszyklus (Erzeugung, Verteilung, Speicherung, Sperrung, Vernichtung) sicher verwaltet (BL-CRY-05).", + "link": "{{LINK:R09#5.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-07" + ] + }, + { + "id": "5.1.1-S1", + "policy": "R09", + "policy_file": "R09_Kryptografie-und-Uebertragungsrichtlinie.md", + "control": "5.1.1", + "type": "SOLL", + "req_anchor": "REQ 5.1.1-S1", + "impl_anchor": "IMPL 5.1.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Ein Kryptokonzept ist dokumentiert und eine PKI/Zertifikatsverwaltung ist etabliert.", + "implementation": "Ein Kryptokonzept ist dokumentiert; eine PKI/Zertifikatsverwaltung ist etabliert.", + "link": "{{LINK:R09#5.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-07" + ] + }, + { + "id": "5.1.2-M1", + "policy": "R09", + "policy_file": "R09_Kryptografie-und-Uebertragungsrichtlinie.md", + "control": "5.1.2", + "type": "MUSS", + "req_anchor": "REQ 5.1.2-M1", + "impl_anchor": "IMPL 5.1.2-M1", + "condition": null, + "requirement": "Informationen werden abhängig vom Schutzbedarf bei der Uebertragung geschützt (z. B. Transportverschlüsselung, gesicherte Kanäle).", + "implementation": "Informationen werden schutzbedarfsgerecht bei der Übertragung geschützt: mindestens {{TLS_MIN}} (BL-CRY-01) und gesicherte Kanäle.", + "link": "{{LINK:R09#5.1.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-07" + ] + }, + { + "id": "5.1.2-S1", + "policy": "R09", + "policy_file": "R09_Kryptografie-und-Uebertragungsrichtlinie.md", + "control": "5.1.2", + "type": "SOLL", + "req_anchor": "REQ 5.1.2-S1", + "impl_anchor": "IMPL 5.1.2-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Regeln für sichere Uebertragungswege (E-Mail-Verschlüsselung, sichere Dateiübertragung) sind definiert.", + "implementation": "Regeln für E-Mail-Verschlüsselung und sichere Dateiübertragung sind definiert (BL-CRY-04).", + "link": "{{LINK:R09#5.1.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-07" + ] + }, + { + "id": "5.2.1-M1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.1", + "type": "MUSS", + "req_anchor": "REQ 5.2.1-M1", + "impl_anchor": "IMPL 5.2.1-M1", + "condition": null, + "requirement": "Aenderungen an IT-Systemen werden geregelt beantragt, bewertet, getestet, genehmigt und dokumentiert.", + "implementation": "Änderungen durchlaufen ein Change-Verfahren mit Antrag, Risikobewertung, Test, Genehmigung und Dokumentation im {{TOOL_TICKET}} (BL-OPS-09).", + "link": "{{LINK:R10#5.2.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-04" + ] + }, + { + "id": "5.2.2-M1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.2", + "type": "MUSS", + "req_anchor": "REQ 5.2.2-M1", + "impl_anchor": "IMPL 5.2.2-M1", + "condition": null, + "requirement": "Entwicklungs-, Test- und Produktionsumgebungen sind getrennt.", + "implementation": "Entwicklung, Test und Produktion sind getrennt betrieben.", + "link": "{{LINK:R10#5.2.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.2.2-S1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.2", + "type": "SOLL", + "req_anchor": "REQ 5.2.2-S1", + "impl_anchor": "IMPL 5.2.2-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Produktivdaten werden nicht ungeschützt in Test-/Entwicklungsumgebungen verwendet.", + "implementation": "Produktivdaten werden in Test-/Entwicklungsumgebungen nur anonymisiert/pseudonymisiert genutzt.", + "link": "{{LINK:R10#5.2.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.2.3-M1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.3", + "type": "MUSS", + "req_anchor": "REQ 5.2.3-M1", + "impl_anchor": "IMPL 5.2.3-M1", + "condition": null, + "requirement": "Anforderungen zum Schutz vor Schadsoftware sind bestimmt; technische und organisatorische Maßnahmen sind umgesetzt.", + "implementation": "Malware-Schutz ist über {{TECH_MALWARE}} auf allen Endpunkten und Servern umgesetzt (BL-OPS-03).", + "link": "{{LINK:R10#5.2.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.2.3-S1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.3", + "type": "SOLL", + "req_anchor": "REQ 5.2.3-S1", + "impl_anchor": "IMPL 5.2.3-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Schutzsoftware wird automatisch aktualisiert; unnötige Netzwerkdienste sind deaktiviert.", + "implementation": "Signaturen/Engines werden {{MALWARE_UPDATE}} aktualisiert; unnötige Netzwerkdienste sind deaktiviert.", + "link": "{{LINK:R10#5.2.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.2.4-M1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.4", + "type": "MUSS", + "req_anchor": "REQ 5.2.4-M1", + "impl_anchor": "IMPL 5.2.4-M1", + "condition": null, + "requirement": "Sicherheitsrelevante Ereignisse werden protokolliert und ausgewertet.", + "implementation": "Sicherheitsrelevante Ereignisse werden zentral über {{TECH_SIEM}} protokolliert und ausgewertet (BL-OPS-04).", + "link": "{{LINK:R10#5.2.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-13" + ] + }, + { + "id": "5.2.4-S1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.4", + "type": "SOLL", + "req_anchor": "REQ 5.2.4-S1", + "impl_anchor": "IMPL 5.2.4-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Protokolle sind vor Manipulation geschützt; Aufbewahrungsfristen sind definiert.", + "implementation": "Protokolle sind manipulationsgeschützt; die Aufbewahrung beträgt {{LOG_RETENTION}}.", + "link": "{{LINK:R10#5.2.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-13" + ] + }, + { + "id": "5.2.5-M1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.5", + "type": "MUSS", + "req_anchor": "REQ 5.2.5-M1", + "impl_anchor": "IMPL 5.2.5-M1", + "condition": null, + "requirement": "Schwachstellen werden identifiziert und risikoorientiert behoben (Patch-Management).", + "implementation": "Schwachstellen werden erfasst und nach BL-OPS-01 risikoorientiert gepatcht (kritisch {{PATCH_SLA_CRIT}}); die Nachverfolgung erfolgt im {{TOOL_TICKET}}.", + "link": "{{LINK:R10#5.2.5}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-04", + "VA-06" + ] + }, + { + "id": "5.2.5-S1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.5", + "type": "SOLL", + "req_anchor": "REQ 5.2.5-S1", + "impl_anchor": "IMPL 5.2.5-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Es besteht ein regelmäßiges Schwachstellen-Scanning; kritische Patches werden priorisiert.", + "implementation": "Ein Schwachstellen-Scanning ({{VULN_SCAN_FREQ}}, BL-OPS-02) ist etabliert.", + "link": "{{LINK:R10#5.2.5}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-06" + ] + }, + { + "id": "5.2.6-M1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.6", + "type": "MUSS", + "req_anchor": "REQ 5.2.6-M1", + "impl_anchor": "IMPL 5.2.6-M1", + "condition": null, + "requirement": "IT-Systeme und Dienste werden technisch überprüft (z. B. Systemhärtung, Penetrationstests).", + "implementation": "Systeme werden nach Härtungsvorgaben (BL-OPS-07, z. B. CIS-Benchmarks) konfiguriert und risikoorientiert technisch geprüft (Penetrationstest {{PENTEST_FREQ}}, BL-OPS-08).", + "link": "{{LINK:R10#5.2.6}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-06" + ] + }, + { + "id": "5.2.7-M1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.7", + "type": "MUSS", + "req_anchor": "REQ 5.2.7-M1", + "impl_anchor": "IMPL 5.2.7-M1", + "condition": null, + "requirement": "Das Netzwerk wird gesteuert und abgesichert (Segmentierung, Zugangskontrolle, Absicherung nach außen).", + "implementation": "Das Netzwerk ist nach Schutzbedarf segmentiert (BL-NET-01), zugangskontrolliert und nach außen über Firewall (Default-Deny, BL-NET-02) abgesichert.", + "link": "{{LINK:R10#5.2.7}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.2.7-M2", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.7", + "type": "MUSS", + "req_anchor": "REQ 5.2.7-M2", + "impl_anchor": "IMPL 5.2.7-M2", + "condition": "FLAG_OT_USED", + "requirement": "Produktions-/OT-Netze sind von Office-Netzen getrennt und besonders abgesichert.", + "implementation": "Produktions-/OT-Netze sind von Office-Netzen getrennt und besonders abgesichert (BL-NET-01).", + "link": "{{LINK:R10#5.2.7}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.2.7-S1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.7", + "type": "SOLL", + "req_anchor": "REQ 5.2.7-S1", + "impl_anchor": "IMPL 5.2.7-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Ein aktueller Netzplan und ein Segmentierungskonzept liegen vor.", + "implementation": "Ein aktueller Netzplan und ein Segmentierungskonzept werden gepflegt.", + "link": "{{LINK:R10#5.2.7}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.2.9-M1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.9", + "type": "MUSS", + "req_anchor": "REQ 5.2.9-M1", + "impl_anchor": "IMPL 5.2.9-M1", + "condition": null, + "requirement": "Daten und IT-Dienste werden gesichert; Wiederherstellung ist geregelt.", + "implementation": "Daten und Dienste werden nach Schema {{BACKUP_SCHEME}} über {{TECH_BACKUP}} gesichert (BL-OPS-05); die Wiederherstellung ist geregelt.", + "link": "{{LINK:R10#5.2.9}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-05" + ] + }, + { + "id": "5.2.9-M2", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.9", + "type": "MUSS", + "req_anchor": "REQ 5.2.9-M2", + "impl_anchor": "IMPL 5.2.9-M2", + "condition": null, + "requirement": "Wiederherstellungstests werden regelmäßig durchgeführt.", + "implementation": "Wiederherstellungstests werden mindestens {{BACKUP_TEST_FREQ}} durchgeführt und dokumentiert (BL-OPS-06).", + "link": "{{LINK:R10#5.2.9}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-05" + ] + }, + { + "id": "5.2.9-S1", + "policy": "R10", + "policy_file": "R10_Betriebssicherheit.md", + "control": "5.2.9", + "type": "SOLL", + "req_anchor": "REQ 5.2.9-S1", + "impl_anchor": "IMPL 5.2.9-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Backups werden geschützt/ausgelagert aufbewahrt (z. B. offline/immutable).", + "implementation": "Backups werden geschützt und ausgelagert aufbewahrt (offline/immutable), Aufbewahrung {{BACKUP_RETENTION}}.", + "link": "{{LINK:R10#5.2.9}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-05" + ] + }, + { + "id": "5.3.1-M1", + "policy": "R11", + "policy_file": "R11_Sichere-Systembeschaffung-und-Entwicklung.md", + "control": "5.3.1", + "type": "MUSS", + "req_anchor": "REQ 5.3.1-M1", + "impl_anchor": "IMPL 5.3.1-M1", + "condition": null, + "requirement": "Bei Beschaffung oder Weiterentwicklung von IT-Systemen werden Informationssicherheitsanforderungen ermittelt und berücksichtigt.", + "implementation": "Sicherheitsanforderungen sind fester Bestandteil von Beschaffungs- und Änderungsprozessen (Security by Design); die Prüfung erfolgt vor Freigabe im {{TOOL_TICKET}}.", + "link": "{{LINK:R11#5.3.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.3.1-M2", + "policy": "R11", + "policy_file": "R11_Sichere-Systembeschaffung-und-Entwicklung.md", + "control": "5.3.1", + "type": "MUSS", + "req_anchor": "REQ 5.3.1-M2", + "impl_anchor": "IMPL 5.3.1-M2", + "condition": "FLAG_DEV_INHOUSE", + "requirement": "Für die Eigenentwicklung gelten Vorgaben für sichere Entwicklung (Secure Coding, Tests, Freigaben).", + "implementation": "Für die Eigenentwicklung gelten Secure-Coding-Vorgaben mit Code-Reviews, automatisierten Sicherheitstests (SAST/Dependency-Scan) und dokumentierten Freigaben.", + "link": "{{LINK:R11#5.3.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.3.1-S1", + "policy": "R11", + "policy_file": "R11_Sichere-Systembeschaffung-und-Entwicklung.md", + "control": "5.3.1", + "type": "SOLL", + "req_anchor": "REQ 5.3.1-S1", + "impl_anchor": "IMPL 5.3.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Sicherheitsanforderungen sind Bestandteil des Beschaffungs-/Entwicklungsprozesses (Security by Design).", + "implementation": "Sicherheitsanforderungen werden dokumentiert und ihre Umsetzung vor Produktivsetzung geprüft.", + "link": "{{LINK:R11#5.3.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.3.2-M1", + "policy": "R11", + "policy_file": "R11_Sichere-Systembeschaffung-und-Entwicklung.md", + "control": "5.3.2", + "type": "MUSS", + "req_anchor": "REQ 5.3.2-M1", + "impl_anchor": "IMPL 5.3.2-M1", + "condition": null, + "requirement": "Sicherheitsanforderungen an Netzdienste (intern und extern) sind definiert.", + "implementation": "Für genutzte Netzdienste (intern/extern) sind Sicherheitsanforderungen definiert und vertraglich bzw. technisch vereinbart.", + "link": "{{LINK:R11#5.3.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.3.3-M1", + "policy": "R11", + "policy_file": "R11_Sichere-Systembeschaffung-und-Entwicklung.md", + "control": "5.3.3", + "type": "MUSS", + "req_anchor": "REQ 5.3.3-M1", + "impl_anchor": "IMPL 5.3.3-M1", + "condition": null, + "requirement": "Rückgabe und sichere Entfernung/Löschung von Informationen und Assets sind geregelt.", + "implementation": "Rückgabe und sichere Löschung/Vernichtung (bei Vertragsende, Geräteausmusterung) sind nach BL-DEL-01 geregelt und werden nachgewiesen.", + "link": "{{LINK:R11#5.3.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.3.3-S1", + "policy": "R11", + "policy_file": "R11_Sichere-Systembeschaffung-und-Entwicklung.md", + "control": "5.3.3", + "type": "SOLL", + "req_anchor": "REQ 5.3.3-S1", + "impl_anchor": "IMPL 5.3.3-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Löschverfahren entsprechen dem Schutzbedarf; Löschungen werden nachgewiesen.", + "implementation": "Löschverfahren richten sich nach dem Schutzbedarf; Löschungen werden dokumentiert (Löschprotokoll).", + "link": "{{LINK:R11#5.3.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "5.3.4-M1", + "policy": "R12", + "policy_file": "R12_Cloud-KI-und-externe-IT-Dienste.md", + "control": "5.3.4", + "type": "MUSS", + "req_anchor": "REQ 5.3.4-M1", + "impl_anchor": "IMPL 5.3.4-M1", + "condition": null, + "requirement": "Bei geteilten externen IT-Diensten ist durch wirksame Mandantentrennung sichergestellt, dass Unbefugte anderer Organisationen nicht auf eigene Informationen zugreifen können.", + "implementation": "Bei geteilten externen Diensten wird eine wirksame Mandantentrennung gefordert und vertraglich zugesichert; die Prüfung erfolgt vor Freigabe.", + "link": "{{LINK:R12#5.3.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-11" + ] + }, + { + "id": "5.3.4-M2", + "policy": "R12", + "policy_file": "R12_Cloud-KI-und-externe-IT-Dienste.md", + "control": "5.3.4", + "type": "MUSS", + "req_anchor": "REQ 5.3.4-M2", + "impl_anchor": "IMPL 5.3.4-M2", + "condition": "FLAG_CLOUD_USED", + "requirement": "Cloud-Dienste werden vor Nutzung bewertet und freigegeben; nur freigegebene Dienste werden für Unternehmensinformationen genutzt.", + "implementation": "Cloud-Dienste werden vor Nutzung bewertet (Schutzbedarf, Datenlokation/EU, Verschlüsselung, Exit) und von {{ROLE_ISB}} freigegeben; die Freigabeliste wird im ISMS-Tool ({{TOOL_NAME}}) geführt.", + "link": "{{LINK:R12#5.3.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-11" + ] + }, + { + "id": "5.3.4-S1", + "policy": "R12", + "policy_file": "R12_Cloud-KI-und-externe-IT-Dienste.md", + "control": "5.3.4", + "type": "SOLL", + "req_anchor": "REQ 5.3.4-S1", + "impl_anchor": "IMPL 5.3.4-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Das Segregationskonzept des Anbieters ist dokumentiert und wird bei Aenderungen angepasst.", + "implementation": "Das Segregationskonzept des Anbieters wird dokumentiert und bei Änderungen aktualisiert.", + "link": "{{LINK:R12#5.3.4}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-11" + ] + }, + { + "id": "5.3.4-KI-M1", + "policy": "R12", + "policy_file": "R12_Cloud-KI-und-externe-IT-Dienste.md", + "control": "5.3.4-KI", + "type": "MUSS", + "req_anchor": "REQ 5.3.4-KI-M1", + "impl_anchor": "IMPL 5.3.4-KI-M1", + "condition": null, + "requirement": "Der Einsatz von KI-/GenAI-Diensten ist geregelt; es werden nur freigegebene Dienste genutzt.", + "implementation": "Der Einsatz von KI-/GenAI-Diensten ist geregelt; nur von {{ROLE_ISB}} freigegebene Dienste (Freigabeliste im ISMS-Tool) dürfen genutzt werden.", + "link": "{{LINK:R12#5.3.4-KI}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-11" + ] + }, + { + "id": "5.3.4-KI-M2", + "policy": "R12", + "policy_file": "R12_Cloud-KI-und-externe-IT-Dienste.md", + "control": "5.3.4-KI", + "type": "MUSS", + "req_anchor": "REQ 5.3.4-KI-M2", + "impl_anchor": "IMPL 5.3.4-KI-M2", + "condition": null, + "requirement": "Die Eingabe vertraulicher oder personenbezogener Informationen in nicht freigegebene KI-Dienste ist untersagt; zulässige Datenklassen je Dienst sind definiert.", + "implementation": "Zulässige Datenklassen je KI-Dienst sind definiert; die Eingabe vertraulicher oder personenbezogener Daten in nicht freigegebene Dienste ist untersagt (Awareness BL-HR-01).", + "link": "{{LINK:R12#5.3.4-KI}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-11" + ] + }, + { + "id": "5.3.4-KI-M3", + "policy": "R12", + "policy_file": "R12_Cloud-KI-und-externe-IT-Dienste.md", + "control": "5.3.4-KI", + "type": "MUSS", + "req_anchor": "REQ 5.3.4-KI-M3", + "impl_anchor": "IMPL 5.3.4-KI-M3", + "condition": null, + "requirement": "Bei freigegebenen KI-Diensten ist geklärt, ob Eingaben zum Training genutzt werden; eine Trainings-/Weitergabe von Unternehmensdaten wird ausgeschlossen oder vertraglich untersagt.", + "implementation": "Bei Freigabe wird geprüft und vertraglich sichergestellt, dass Eingaben nicht zum Training genutzt oder an Dritte weitergegeben werden (Opt-out bzw. Enterprise-Vertrag).", + "link": "{{LINK:R12#5.3.4-KI}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-11" + ] + }, + { + "id": "5.3.4-KI-S1", + "policy": "R12", + "policy_file": "R12_Cloud-KI-und-externe-IT-Dienste.md", + "control": "5.3.4-KI", + "type": "SOLL", + "req_anchor": "REQ 5.3.4-KI-S1", + "impl_anchor": "IMPL 5.3.4-KI-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Ergebnisse werden vor geschäftskritischer Verwendung geprüft (Human-in-the-Loop); der KI-Einsatz wird dokumentiert; regulatorische Anforderungen (z. B. EU AI Act) werden berücksichtigt.", + "implementation": "KI-Ergebnisse werden vor geschäftskritischer Verwendung durch Menschen geprüft (Human-in-the-Loop); der KI-Einsatz wird dokumentiert und regulatorische Anforderungen (EU AI Act) berücksichtigt.", + "link": "{{LINK:R12#5.3.4-KI}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-11" + ] + }, + { + "id": "6.1.1-M1", + "policy": "R13", + "policy_file": "R13_Lieferanten-und-Dienstleistersteuerung.md", + "control": "6.1.1", + "type": "MUSS", + "req_anchor": "REQ 6.1.1-M1", + "impl_anchor": "IMPL 6.1.1-M1", + "condition": null, + "requirement": "Informationssicherheitsanforderungen an Auftragnehmer/Lieferanten sind ermittelt und werden vertraglich vereinbart und überwacht.", + "implementation": "Sicherheitsanforderungen an Lieferanten werden ermittelt, vertraglich vereinbart und überwacht; das Lieferantenverzeichnis wird im ISMS-Tool ({{TOOL_NAME}}) geführt.", + "link": "{{LINK:R13#6.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-10" + ] + }, + { + "id": "6.1.1-M2", + "policy": "R13", + "policy_file": "R13_Lieferanten-und-Dienstleistersteuerung.md", + "control": "6.1.1", + "type": "MUSS", + "req_anchor": "REQ 6.1.1-M2", + "impl_anchor": "IMPL 6.1.1-M2", + "condition": null, + "requirement": "Lieferanten werden risikoorientiert bewertet.", + "implementation": "Lieferanten werden risikoorientiert nach BL-SUP-01 (Schutzbedarf, Zugriff) klassifiziert.", + "link": "{{LINK:R13#6.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-10" + ] + }, + { + "id": "6.1.1-S1", + "policy": "R13", + "policy_file": "R13_Lieferanten-und-Dienstleistersteuerung.md", + "control": "6.1.1", + "type": "SOLL", + "req_anchor": "REQ 6.1.1-S1", + "impl_anchor": "IMPL 6.1.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Die Einhaltung der Anforderungen wird regelmäßig überprüft (z. B. Nachweise, Audits, TISAX-Label).", + "implementation": "Die Einhaltung wird risikobasiert überprüft (Selbstauskunft, Nachweise, Audits, TISAX-Label).", + "link": "{{LINK:R13#6.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-10" + ] + }, + { + "id": "6.1.2-M1", + "policy": "R13", + "policy_file": "R13_Lieferanten-und-Dienstleistersteuerung.md", + "control": "6.1.2", + "type": "MUSS", + "req_anchor": "REQ 6.1.2-M1", + "impl_anchor": "IMPL 6.1.2-M1", + "condition": null, + "requirement": "Der Austausch von Informationen mit Externen ist durch Vertraulichkeitsvereinbarungen (NDA) abgesichert.", + "implementation": "Vor dem Austausch schutzbedürftiger Informationen werden Vertraulichkeitsvereinbarungen (NDA) abgeschlossen und im ISMS-Tool hinterlegt.", + "link": "{{LINK:R13#6.1.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-10" + ] + }, + { + "id": "6.1.2-S1", + "policy": "R13", + "policy_file": "R13_Lieferanten-und-Dienstleistersteuerung.md", + "control": "6.1.2", + "type": "SOLL", + "req_anchor": "REQ 6.1.2-S1", + "impl_anchor": "IMPL 6.1.2-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "NDA-Vorlagen sind standardisiert; Geltungsdauer und Rückgabe-/Löschpflichten sind geregelt.", + "implementation": "Standardisierte NDA-Vorlagen mit Geltungsdauer sowie Rückgabe-/Löschpflichten werden verwendet.", + "link": "{{LINK:R13#6.1.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-10" + ] + }, + { + "id": "6.1.3-M1", + "policy": "R13", + "policy_file": "R13_Lieferanten-und-Dienstleistersteuerung.md", + "control": "6.1.3", + "type": "MUSS", + "req_anchor": "REQ 6.1.3-M1", + "impl_anchor": "IMPL 6.1.3-M1", + "condition": "FLAG_EXTERNAL_IT", + "requirement": "Verantwortlichkeiten zwischen der Organisation und externen IT-Dienstleistern sind klar abgegrenzt und dokumentiert.", + "implementation": "Die Verantwortlichkeiten mit externen IT-Dienstleistern (Betriebs-, Sicherheits-, Melde- und Mitwirkungspflichten) sind abgegrenzt und vertraglich dokumentiert.", + "link": "{{LINK:R13#6.1.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [ + "VA-10" + ] + }, + { + "id": "6.1.3-S1", + "policy": "R13", + "policy_file": "R13_Lieferanten-und-Dienstleistersteuerung.md", + "control": "6.1.3", + "type": "SOLL", + "req_anchor": "REQ 6.1.3-S1", + "impl_anchor": "IMPL 6.1.3-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Schnittstellen, Eskalations- und Meldewege mit Dienstleistern sind vereinbart.", + "implementation": "Schnittstellen sowie Eskalations- und Meldewege sind vertraglich vereinbart (Anbindung an R04).", + "link": "{{LINK:R13#6.1.3}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "7.1.1-M1", + "policy": "R14", + "policy_file": "R14_Compliance-und-Datenschutz.md", + "control": "7.1.1", + "type": "MUSS", + "req_anchor": "REQ 7.1.1-M1", + "impl_anchor": "IMPL 7.1.1-M1", + "condition": null, + "requirement": "Relevante gesetzliche, regulatorische und vertragliche Anforderungen an die Informationssicherheit sind identifiziert, dokumentiert und werden eingehalten.", + "implementation": "Relevante gesetzliche, regulatorische und vertragliche Anforderungen werden in einem Compliance-/Rechtsregister im ISMS-Tool ({{TOOL_NAME}}) erfasst und ihre Einhaltung nachverfolgt.", + "link": "{{LINK:R14#7.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "7.1.1-S1", + "policy": "R14", + "policy_file": "R14_Compliance-und-Datenschutz.md", + "control": "7.1.1", + "type": "SOLL", + "req_anchor": "REQ 7.1.1-S1", + "impl_anchor": "IMPL 7.1.1-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Ein Compliance-/Rechtsregister wird gepflegt und regelmäßig aktualisiert; Verantwortliche sind benannt.", + "implementation": "Das Register wird mindestens {{REVIEW_CYCLE}} aktualisiert; je Anforderung ist ein Verantwortlicher benannt.", + "link": "{{LINK:R14#7.1.1}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "7.1.2-M1", + "policy": "R14", + "policy_file": "R14_Compliance-und-Datenschutz.md", + "control": "7.1.2", + "type": "MUSS", + "req_anchor": "REQ 7.1.2-M1", + "impl_anchor": "IMPL 7.1.2-M1", + "condition": null, + "requirement": "Beim Umgang mit personenbezogenen Daten werden die datenschutzrechtlichen Anforderungen (z. B. DSGVO) berücksichtigt.", + "implementation": "Datenschutzrechtliche Anforderungen (DSGVO) werden berücksichtigt; {{ROLE_DPO}} ist eingebunden und bei relevanten Vorhaben (Datenschutz-Folgenabschätzung) beteiligt.", + "link": "{{LINK:R14#7.1.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "7.1.2-M2", + "policy": "R14", + "policy_file": "R14_Compliance-und-Datenschutz.md", + "control": "7.1.2", + "type": "MUSS", + "req_anchor": "REQ 7.1.2-M2", + "impl_anchor": "IMPL 7.1.2-M2", + "condition": null, + "requirement": "Ein Verzeichnis der Verarbeitungstätigkeiten wird geführt.", + "implementation": "Das Verzeichnis der Verarbeitungstätigkeiten wird im ISMS-Tool ({{TOOL_NAME}}) geführt und gepflegt.", + "link": "{{LINK:R14#7.1.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + }, + { + "id": "7.1.2-S1", + "policy": "R14", + "policy_file": "R14_Compliance-und-Datenschutz.md", + "control": "7.1.2", + "type": "SOLL", + "req_anchor": "REQ 7.1.2-S1", + "impl_anchor": "IMPL 7.1.2-S1", + "condition": "FLAG_INCLUDE_SHOULD", + "requirement": "Technische und organisatorische Maßnahmen (TOM), Löschkonzepte und Betroffenenrechte sind geregelt.", + "implementation": "Technische und organisatorische Maßnahmen (TOM), Löschkonzepte (BL-DEL-01) und Prozesse für Betroffenenrechte sind geregelt.", + "link": "{{LINK:R14#7.1.2}}", + "nachweis_link": "{{LINK:NACHWEISREGISTER}}", + "verfahren": [] + } + ], + "verfahren": [ + { + "id": "VA-01", + "title": "Incident-Response- und Meldeverfahren", + "file": "verfahren/VA-01_Incident-Response-und-Meldeverfahren.md", + "policy": "R04", + "fulfills": [ + "1.6.1-M1", + "1.6.1-M2", + "1.6.2-M1", + "1.6.2-M2", + "1.6.2-S1", + "1.6.2-S2" + ], + "link": "{{LINK:VA-01}}" + }, + { + "id": "VA-02", + "title": "IT-Notfall- und Wiederanlaufverfahren (BCM)", + "file": "verfahren/VA-02_IT-Notfall-und-Wiederanlaufverfahren.md", + "policy": "R04", + "fulfills": [ + "1.6.3-M1", + "1.6.3-S1", + "5.2.8-M1", + "5.2.8-S1" + ], + "link": "{{LINK:VA-02}}" + }, + { + "id": "VA-03", + "title": "Berechtigungsverfahren (Joiner/Mover/Leaver und Rezertifizierung)", + "file": "verfahren/VA-03_Berechtigungsverfahren.md", + "policy": "R08", + "fulfills": [ + "4.1.1-S1", + "4.1.3-M1", + "4.2.1-M1", + "4.2.1-M2", + "4.2.1-S1" + ], + "link": "{{LINK:VA-03}}" + }, + { + "id": "VA-04", + "title": "Change- und Patch-Management-Verfahren", + "file": "verfahren/VA-04_Change-und-Patch-Management-Verfahren.md", + "policy": "R10", + "fulfills": [ + "5.2.1-M1", + "5.2.5-M1" + ], + "link": "{{LINK:VA-04}}" + }, + { + "id": "VA-05", + "title": "Backup- und Restore-Verfahren", + "file": "verfahren/VA-05_Backup-und-Restore-Verfahren.md", + "policy": "R10", + "fulfills": [ + "5.2.9-M1", + "5.2.9-M2", + "5.2.9-S1" + ], + "link": "{{LINK:VA-05}}" + }, + { + "id": "VA-06", + "title": "Schwachstellenmanagement-Verfahren", + "file": "verfahren/VA-06_Schwachstellenmanagement-Verfahren.md", + "policy": "R10", + "fulfills": [ + "5.2.5-M1", + "5.2.5-S1", + "5.2.6-M1" + ], + "link": "{{LINK:VA-06}}" + }, + { + "id": "VA-07", + "title": "Kryptokonzept und Schlüsselverwaltung", + "file": "verfahren/VA-07_Kryptokonzept-und-Schluesselverwaltung.md", + "policy": "R09", + "fulfills": [ + "5.1.1-M1", + "5.1.1-M2", + "5.1.1-S1", + "5.1.2-M1", + "5.1.2-S1" + ], + "link": "{{LINK:VA-07}}" + }, + { + "id": "VA-08", + "title": "Asset- und Klassifizierungsverfahren", + "file": "verfahren/VA-08_Asset-und-Klassifizierungsverfahren.md", + "policy": "R02", + "fulfills": [ + "1.3.1-M1", + "1.3.1-M2", + "1.3.1-S1", + "1.3.2-M1", + "1.3.2-M2", + "1.3.2-S1" + ], + "link": "{{LINK:VA-08}}" + }, + { + "id": "VA-09", + "title": "Risikomanagement-Verfahren", + "file": "verfahren/VA-09_Risikomanagement-Verfahren.md", + "policy": "R03", + "fulfills": [ + "1.4.1-M1", + "1.4.1-M2", + "1.4.1-M3", + "1.4.1-S1" + ], + "link": "{{LINK:VA-09}}" + }, + { + "id": "VA-10", + "title": "Lieferanten-Onboarding- und Bewertungsverfahren", + "file": "verfahren/VA-10_Lieferanten-Onboarding-und-Bewertung.md", + "policy": "R13", + "fulfills": [ + "6.1.1-M1", + "6.1.1-M2", + "6.1.1-S1", + "6.1.2-M1", + "6.1.2-S1", + "6.1.3-M1" + ], + "link": "{{LINK:VA-10}}" + }, + { + "id": "VA-11", + "title": "Cloud- und KI-Freigabeverfahren", + "file": "verfahren/VA-11_Cloud-und-KI-Freigabeverfahren.md", + "policy": "R12", + "fulfills": [ + "5.3.4-M1", + "5.3.4-M2", + "5.3.4-S1", + "5.3.4-KI-M1", + "5.3.4-KI-M2", + "5.3.4-KI-M3", + "5.3.4-KI-S1" + ], + "link": "{{LINK:VA-11}}" + }, + { + "id": "VA-12", + "title": "Awareness- und Schulungsverfahren", + "file": "verfahren/VA-12_Awareness-und-Schulungsverfahren.md", + "policy": "R05", + "fulfills": [ + "2.1.3-M1", + "2.1.3-S1" + ], + "link": "{{LINK:VA-12}}" + }, + { + "id": "VA-13", + "title": "Logging- und Monitoring-Verfahren", + "file": "verfahren/VA-13_Logging-und-Monitoring-Verfahren.md", + "policy": "R10", + "fulfills": [ + "5.2.4-M1", + "5.2.4-S1" + ], + "link": "{{LINK:VA-13}}" + } + ] +} \ No newline at end of file diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/L00_Informationssicherheitsleitlinie.md b/seed/isms-vorlagenpaket-v2/richtlinien/L00_Informationssicherheitsleitlinie.md new file mode 100644 index 0000000..6198c43 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/L00_Informationssicherheitsleitlinie.md @@ -0,0 +1,145 @@ +# Informationssicherheitsleitlinie + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Leitlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_ISB}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + +## 1. Zweck + + +Diese Informationssicherheitsleitlinie beschreibt die grundsätzlichen Anforderungen, Ziele und Verantwortlichkeiten der {{ORG_NAME}} zum Schutz von Informationen, IT-Systemen, Geschäftsprozessen und unterstützenden Werten. Die Anforderungen der Informationssicherheit sind bestimmt, dokumentiert und an den Zielen der {{ORG_NAME}} ausgerichtet. + +Ziel ist es, ein angemessenes Informationssicherheitsniveau sicherzustellen und die Anforderungen des VDA ISA 2027 im Bereich Informationssicherheit zu erfüllen. + +## 2. Geltungsbereich + +Diese Leitlinie gilt für den definierten ISMS-Geltungsbereich: + +{{ISMS_SCOPE_DESCRIPTION}} + +Sie gilt für: + +- alle Mitarbeitenden innerhalb des Geltungsbereichs, +- Führungskräfte, +- externe Dienstleister, soweit diese Zugriff auf Informationen, Systeme oder Prozesse der Organisation haben, +- relevante IT-Systeme, Informationen, Anwendungen, Standorte und Geschäftsprozesse innerhalb des ISMS-Scopes. + +## 3. Ziele der Informationssicherheit + + +Die Leitlinie benennt die Ziele und die Bedeutung der Informationssicherheit. Die Organisation verfolgt mit dem ISMS insbesondere folgende Ziele: + +- Schutz vertraulicher Informationen vor unbefugtem Zugriff, +- Sicherstellung der Integrität von Informationen und Systemen, +- Sicherstellung der Verfügbarkeit geschäftskritischer Informationen, Systeme und Services, +- Einhaltung gesetzlicher, regulatorischer und vertraglicher Anforderungen, +- angemessener Schutz von Kundeninformationen, personenbezogenen Daten, Geschäftsgeheimnissen und weiteren schutzbedürftigen Informationen, +- strukturierte Erkennung, Bewertung und Behandlung von Informationssicherheitsrisiken, +- kontinuierliche Verbesserung der Informationssicherheit. + +## 4. Grundsätze der Informationssicherheit + +Die Informationssicherheit basiert auf folgenden Grundsätzen: + +### 4.1 Risikoorientierung +Informationssicherheitsmaßnahmen werden risikoorientiert geplant, umgesetzt, überprüft und verbessert. Risiken werden im eingesetzten ISMS-Tool ({{TOOL_NAME}}) bewertet und nachverfolgt (siehe {{LINK:R03}}). + +### 4.2 Angemessenheit +Schutzmaßnahmen müssen dem Schutzbedarf der Informationen, Systeme und Prozesse angemessen sein. Dabei werden Vertraulichkeit, Integrität und Verfügbarkeit berücksichtigt. + +### 4.3 Verantwortung +Informationssicherheit ist eine gemeinsame Verantwortung aller Mitarbeitenden. Die {{ROLE_MANAGEMENT}} trägt die Gesamtverantwortung für das ISMS. + +### 4.4 Nachvollziehbarkeit +Entscheidungen, Bewertungen, Freigaben und wesentliche Maßnahmen im Zusammenhang mit Informationssicherheit sind nachvollziehbar zu dokumentieren. + +### 4.5 Kontinuierliche Verbesserung +Das ISMS wird regelmäßig überprüft und bei Bedarf angepasst. Erkenntnisse aus Audits, Vorfällen, Risiken, Änderungen und Managementbewertungen fließen in die Verbesserung ein. + +## 5. Informationssicherheitsanforderungen + + +{{#if FLAG_INCLUDE_SHOULD}}Die Informationssicherheitsanforderungen basieren auf der Strategie der {{ORG_NAME}}; gesetzliche und vertragliche Vorgaben werden berücksichtigt. {{/if}}Die Organisation bestimmt und dokumentiert Informationssicherheitsanforderungen auf Basis von: + +- gesetzlichen und regulatorischen Anforderungen, +- vertraglichen Anforderungen, insbesondere von Kunden und Partnern, +- Anforderungen aus dem VDA ISA, +- internen Geschäftsanforderungen, +- Ergebnissen aus Risikoanalysen, +- Schutzbedarf von Informationen, Prozessen und IT-Systemen, +- Anforderungen aus Projekten, Änderungen und externen IT-Services. + +Die jeweils relevanten Anforderungen werden im ISMS berücksichtigt und über geeignete Richtlinien, Prozesse, technische Maßnahmen und Nachweise umgesetzt. + +## 6. Rollen und Verantwortlichkeiten + +Die Organisation definiert Rollen und Verantwortlichkeiten für Informationssicherheit. Dazu gehören mindestens: + +| Rolle | Grundsätzliche Verantwortung | +|-------|------------------------------| +| {{ROLE_MANAGEMENT}} | Gesamtverantwortung, Freigabe der Informationssicherheitsleitlinie, Bereitstellung angemessener Ressourcen | +| {{ROLE_ISB}} | Steuerung, Pflege und Weiterentwicklung des ISMS | +| Führungskräfte | Umsetzung der Anforderungen im jeweiligen Verantwortungsbereich | +| {{ROLE_IT_LEAD}} | Umsetzung technischer und organisatorischer Sicherheitsmaßnahmen im IT-Bereich | +| Asset Owner / Prozessverantwortliche | Bewertung und Pflege relevanter Informationen, Prozesse und Assets im ISMS-Tool | +| Mitarbeitende | Einhaltung der Richtlinien und Meldung von Sicherheitsereignissen | +| Externe Dienstleister | Einhaltung vertraglich vereinbarter Sicherheitsanforderungen | + +Die konkrete Rollen- und Verantwortlichkeitszuordnung wird im ISMS-Tool ({{TOOL_NAME}}) oder in einer ergänzenden Rollenmatrix gepflegt (siehe auch {{LINK:R01}}). + +## 7. Verbindlichkeit + + +Diese Leitlinie ist durch die {{ROLE_MANAGEMENT}} genehmigt und für alle betroffenen Personen im Geltungsbereich verbindlich. {{#if FLAG_INCLUDE_SHOULD}}Verstöße gegen Informationssicherheitsanforderungen können zu organisatorischen, arbeitsrechtlichen oder vertraglichen Maßnahmen führen. {{/if}}Alle Mitarbeitenden sind verpflichtet: + +- die geltenden Informationssicherheitsrichtlinien einzuhalten, +- schutzbedürftige Informationen angemessen zu behandeln, +- Sicherheitsereignisse oder Verdachtsfälle unverzüglich zu melden, +- nur freigegebene Systeme, Anwendungen und Dienste zu nutzen, +- erkannte Schwachstellen oder Risiken an die zuständige Stelle zu melden. + +## 8. Veröffentlichung und Kommunikation + + + +Die Informationssicherheitsleitlinie wird den relevanten Personen in geeigneter Form bekannt gemacht; über relevante Änderungen werden Mitarbeitende und betroffene externe Partner informiert. Dies kann erfolgen über: + +- Veröffentlichung im ISMS-Tool ({{TOOL_NAME}}), +- internes Wiki oder Dokumentenmanagementsystem, +- Onboarding-Prozess, +- Awareness-Schulungen (siehe {{LINK:R05}}), +- direkte Kommunikation an betroffene Zielgruppen. + +## 9. Überprüfung und Aktualisierung + + +Diese Leitlinie wird regelmäßig überprüft, mindestens jedoch: + +- {{REVIEW_CYCLE}}, +- bei wesentlichen Änderungen des ISMS-Geltungsbereichs, +- bei wesentlichen organisatorischen oder technischen Änderungen, +- bei relevanten Sicherheitsvorfällen, +- bei neuen oder geänderten regulatorischen, gesetzlichen oder vertraglichen Anforderungen. + +Änderungen werden dokumentiert und durch die {{ROLE_MANAGEMENT}} genehmigt. + +## 10. Nachweise + +Die Nachweise zur Umsetzung dieser Leitlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 11. Verwandte Dokumente + +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- ISMS-Organisation und Rollen: {{LINK:R01}} +- Alle thematischen Richtlinien: {{LINK:R01}} … {{LINK:R14}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R01_ISMS-Organisation-und-Rollen.md b/seed/isms-vorlagenpaket-v2/richtlinien/R01_ISMS-Organisation-und-Rollen.md new file mode 100644 index 0000000..b002c90 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R01_ISMS-Organisation-und-Rollen.md @@ -0,0 +1,143 @@ +# Richtlinie ISMS-Organisation und Rollen + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_ISB}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt Aufbau, Steuerung und Verantwortlichkeiten des Informationssicherheits-Managementsystems (ISMS) der {{ORG_NAME}} sowie die Berücksichtigung der Informationssicherheit in Projekten. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Steuerung der Informationssicherheit (ISA 1.2.1) + + +**Anforderung** + + +- **[MUSS]** Der Geltungsbereich des ISMS (Organisation, Standorte, Prozesse) ist bestimmt und dokumentiert. + +- **[MUSS]** Das ISMS wird durch die Leitung initiiert, gesteuert und überwacht; erforderliche Ressourcen werden bereitgestellt. + +- **[MUSS]** Die Wirksamkeit des ISMS wird regelmäßig durch die Leitung bewertet (Managementbewertung). +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Informationssicherheitsziele sind messbar formuliert und werden nachverfolgt (KPI). +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Der ISMS-Geltungsbereich (Organisation, Standorte, Prozesse) ist im ISMS-Tool ({{TOOL_NAME}}) dokumentiert, versioniert und wird dort gepflegt; wesentliche Änderungen gibt {{ROLE_ISB}} frei. + +Die {{ROLE_MANAGEMENT}} hat das ISMS per Managementbeschluss beauftragt, stellt Personal- und Budgetressourcen bereit und trägt die Gesamtverantwortung; die operative Steuerung liegt bei {{ROLE_ISB}}. + +Die Wirksamkeit wird mindestens {{REVIEW_CYCLE}} in einer dokumentierten Managementbewertung anhand von Zielen, Kennzahlen sowie Audit- und Vorfallsergebnissen geprüft; Protokoll und Maßnahmen werden im ISMS-Tool ({{TOOL_NAME}}) abgelegt. +{{#if FLAG_INCLUDE_SHOULD}} + +Messbare Informationssicherheitsziele und KPI (z. B. Schulungsquote, offene Maßnahmen, Patch-Compliance) sind definiert und werden im ISMS-Tool ({{TOOL_NAME}}) nachverfolgt. +{{/if}} + +### 3.2 Organisation der Verantwortlichkeiten (ISA 1.2.2) + + +**Anforderung** + + +- **[MUSS]** Verantwortlichkeiten für Informationssicherheit sind definiert, zugewiesen und dokumentiert. + +- **[MUSS]** Eine für Informationssicherheit verantwortliche Rolle ist benannt, verfügt über ausreichende Kompetenzen und einen direkten Berichtsweg zur Leitung. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** In Konflikt stehende Aufgaben und Verantwortungsbereiche sind getrennt (Funktionstrennung). +{{/if}} +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Kontakte zu relevanten Behörden und Interessengruppen werden gepflegt. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Verantwortlichkeiten sind in der Rollen-/Verantwortungsmatrix (Abschnitt 5) und im ISMS-Tool ({{TOOL_NAME}}) dokumentiert und den Rolleninhabern kommuniziert. + +Die Rolle {{ROLE_ISB}} ist schriftlich benannt, mit Zeit-/Budgetressourcen und Weisungsrechten ausgestattet und berichtet direkt an die {{ROLE_MANAGEMENT}}. +{{#if FLAG_INCLUDE_SHOULD}} + +In Konflikt stehende Tätigkeiten (Umsetzung vs. Kontrolle, Beantragung vs. Genehmigung) sind getrennt; unvermeidbare Doppelrollen werden dokumentiert und durch kompensierende Kontrollen (Vier-Augen-Prinzip) abgesichert. +{{/if}} +{{#if FLAG_INCLUDE_SHOULD}} + +Kontakte zu Behörden, CERT/CSIRT und relevanten Branchengremien werden von {{ROLE_ISB}} gepflegt und im ISMS-Tool hinterlegt. +{{/if}} + +### 3.3 Informationssicherheit in Projekten (ISA 1.2.3) + + +**Anforderung** + + +- **[MUSS]** Projekte werden unter Berücksichtigung ihres Informationssicherheitsbedarfs klassifiziert. + +- **[MUSS]** In Projekten werden Informationssicherheitsanforderungen ermittelt und berücksichtigt. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Verfahren und Kriterien zur Klassifizierung von Projekten sind dokumentiert und werden angewandt. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Projekte werden zu Beginn anhand eines Kriterienkatalogs hinsichtlich Informationssicherheitsbedarf bewertet und klassifiziert; die Einstufung wird im {{TOOL_TICKET}} bzw. ISMS-Tool dokumentiert. + +Bei erhöhtem Schutzbedarf wird {{ROLE_ISB}} verbindlich eingebunden; ermittelte Sicherheitsanforderungen werden als Aufgaben im {{TOOL_TICKET}} nachgehalten und vor Projektabschluss geprüft. +{{#if FLAG_INCLUDE_SHOULD}} + +Der Kriterienkatalog zur Projekteinstufung ist dokumentiert und wird einheitlich angewandt. +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_ISB}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_MANAGEMENT}} | Beauftragung und Gesamtverantwortung ISMS, Ressourcen, Managementbewertung | +| {{ROLE_ISB}} | Operative Steuerung des ISMS, Pflege der Verantwortlichkeiten | +| {{ROLE_IT_LEAD}} | Technische Umsetzung ISMS-relevanter Maßnahmen | +| Asset Owner / Prozessverantwortliche | Pflege zugeordneter Assets/Prozesse im ISMS-Tool | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_ISB}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:L00}}, {{LINK:R03}}, {{LINK:R13}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R02_Asset-und-Klassifizierungsrichtlinie.md b/seed/isms-vorlagenpaket-v2/richtlinien/R02_Asset-und-Klassifizierungsrichtlinie.md new file mode 100644 index 0000000..862924c --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R02_Asset-und-Klassifizierungsrichtlinie.md @@ -0,0 +1,148 @@ +# Richtlinie Asset- und Klassifizierungsrichtlinie + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt Identifikation, Inventarisierung, Klassifizierung und den geschützten Umgang mit Informationswerten und Assets der {{ORG_NAME}} sowie die Zulassung von Hard- und Software. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Identifikation von Assets (ISA 1.3.1) + + +**Anforderung** + + +- **[MUSS]** Informationswerte und weitere Assets, die Informationen verarbeiten, sind identifiziert und erfasst. + +- **[MUSS]** Für jedes Asset ist ein Verantwortlicher (Owner) benannt. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Ein Katalog der relevanten Informationswerte wird gepflegt und regelmäßig aktualisiert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Informationswerte und Assets werden im ISMS-Tool ({{TOOL_NAME}}) im Asset-Inventar mit Attributen (Owner, Standort, Schutzbedarf) erfasst; Zu-/Abgänge werden über {{TOOL_TICKET}} ausgelöst. + +Jedem Asset ist im Inventar ein verantwortlicher Owner zugeordnet, der Klassifizierung und Aktualität verantwortet. +{{#if FLAG_INCLUDE_SHOULD}} + +Das Asset-Inventar wird laufend gepflegt und mindestens {{REVIEW_CYCLE}} vollständig auf Aktualität geprüft (Review durch {{ROLE_IT_LEAD}}). +{{/if}} + +### 3.2 Klassifizierung (ISA 1.3.2) + + +**Anforderung** + + +- **[MUSS]** Informationswerte sind nach Schutzbedarf (Vertraulichkeit, Integrität, Verfügbarkeit) klassifiziert. + +- **[MUSS]** Abhängig von der Klassifizierung sind Vorgaben zu Kennzeichnung, Handhabung, Speicherung, Uebertragung und Löschung definiert. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Die Klassifizierung wird bei wesentlichen Aenderungen überprüft und angepasst. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Es gilt ein vierstufiges Klassifizierungsschema (Öffentlich / Intern / Vertraulich / Streng vertraulich); die Einstufung nach Vertraulichkeit, Integrität und Verfügbarkeit erfolgt durch den Asset Owner im ISMS-Tool. + +Je Schutzklasse sind Handhabungsvorgaben zu Kennzeichnung, Speicherung, Übertragung (BL-CRY-01/04) und Löschung (BL-DEL-01) definiert und den Mitarbeitenden bekannt gemacht. +{{#if FLAG_INCLUDE_SHOULD}} + +Bei wesentlichen Änderungen wird die Klassifizierung durch den Asset Owner überprüft und im ISMS-Tool aktualisiert. +{{/if}} + +### 3.3 Zugelassene Hardware (ISA 1.3.3) + + +**Anforderung** + + +- **[MUSS]** Es ist sichergestellt, dass nur bewertete und freigegebene externe Hardware/IT-Komponenten eingesetzt werden. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Nicht freigegebene Geräte werden technisch unterbunden. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Externe Hardware/IT-Komponenten werden vor Einsatz technisch und sicherheitsseitig bewertet und freigegeben; die Freigabeliste wird im ISMS-Tool ({{TOOL_NAME}}) geführt. +{{#if FLAG_INCLUDE_SHOULD}} + +Der Anschluss nicht freigegebener Geräte wird soweit möglich technisch unterbunden (z. B. Portkontrolle, {{TECH_MDM}}). +{{/if}} + +### 3.4 Zugelassene Software (ISA 1.3.4) + + +**Anforderung** + + +- **[MUSS]** Es ist sichergestellt, dass nur bewertete und freigegebene Software eingesetzt wird. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Die Installation nicht freigegebener Software wird technisch eingeschränkt. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Software wird vor Einsatz freigegeben; eine Liste zugelassener Software (Whitelist) wird im ISMS-Tool gepflegt, Beschaffung/Freigabe läuft über {{TOOL_TICKET}}. +{{#if FLAG_INCLUDE_SHOULD}} + +Die Installation von Software ist für Standardnutzer technisch eingeschränkt (keine lokalen Adminrechte); Ausnahmen werden im {{TOOL_TICKET}} genehmigt. +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_IT_LEAD}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_IT_LEAD}} | Pflege des Asset-Inventars, Zulassung Hard-/Software | +| {{ROLE_ISB}} | Vorgabe des Klassifizierungsschemas | +| Asset Owner | Bewertung und Pflege einzelner Assets im ISMS-Tool | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_IT_LEAD}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Zugehörige Verfahren: {{LINK:VA-08}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:R01}}, {{LINK:R08}}, {{LINK:R11}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R03_Risikomanagement-und-Auditrichtlinie.md b/seed/isms-vorlagenpaket-v2/richtlinien/R03_Risikomanagement-und-Auditrichtlinie.md new file mode 100644 index 0000000..526a927 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R03_Risikomanagement-und-Auditrichtlinie.md @@ -0,0 +1,127 @@ +# Richtlinie Risikomanagement- und Auditrichtlinie + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_ISB}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt Identifikation, Bewertung und Behandlung von Informationssicherheitsrisiken sowie die interne und unabhängige Überprüfung des ISMS. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Risikomanagement (ISA 1.4.1) + + +**Anforderung** + + +- **[MUSS]** Es existiert ein dokumentiertes Verfahren zur Identifikation, Analyse, Bewertung und Behandlung von Informationssicherheitsrisiken. + +- **[MUSS]** Risiken werden in einem Risikoregister erfasst; Behandlungsoptionen und Maßnahmen sind festgelegt. + +- **[MUSS]** Die Risikobewertung wird regelmäßig und anlassbezogen aktualisiert; die Risikoakzeptanz erfolgt durch die Leitung. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Kriterien für Eintrittswahrscheinlichkeit, Schadenshöhe und Akzeptanzschwellen sind definiert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Das Risikomanagement-Verfahren (Identifikation, Analyse, Bewertung, Behandlung) ist dokumentiert; Risiken werden im ISMS-Tool ({{TOOL_NAME}}) im Risikoregister geführt. + +Je Risiko sind Eintrittswahrscheinlichkeit, Schadenshöhe, Behandlungsoption (reduzieren/vermeiden/übertragen/akzeptieren), Maßnahmen, Verantwortlicher und Termin hinterlegt. + +Die Bewertung wird mindestens {{REVIEW_CYCLE}} und anlassbezogen (neue Systeme, Vorfälle, Änderungen) aktualisiert; Restrisiken werden von der {{ROLE_MANAGEMENT}} dokumentiert akzeptiert. +{{#if FLAG_INCLUDE_SHOULD}} + +Bewertungsskalen und Akzeptanzschwellen sind definiert und im ISMS-Tool hinterlegt. +{{/if}} + +### 3.2 Compliance-Prüfung im IS-Betrieb (ISA 1.5.1) + + +**Anforderung** + + +- **[MUSS]** Die Einhaltung der Informationssicherheitsvorgaben wird regelmäßig geprüft. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Ein Auditprogramm mit Umfang, Turnus und Verantwortlichkeiten ist etabliert; Feststellungen werden nachverfolgt. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Die Einhaltung wird durch interne Audits und stichprobenartige Kontrollen (nach Auditplan) geprüft; Feststellungen werden im ISMS-Tool als Maßnahmen nachverfolgt. +{{#if FLAG_INCLUDE_SHOULD}} + +Ein jährliches Auditprogramm mit Umfang, Turnus und Verantwortlichkeiten ist etabliert. +{{/if}} + +### 3.3 Unabhängige Überprüfung (ISA 1.5.2) + + +**Anforderung** + + +- **[MUSS]** Das ISMS wird durch eine unabhängige Stelle überprüft. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Ergebnisse fließen in die Managementbewertung und den Verbesserungsprozess ein. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Das ISMS wird durch eine unabhängige Stelle (interne Revision oder externe Auditierung, z. B. TISAX) überprüft. +{{#if FLAG_INCLUDE_SHOULD}} + +Die Ergebnisse werden in der Managementbewertung behandelt und fließen in den kontinuierlichen Verbesserungsprozess ein. +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_ISB}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_ISB}} | Steuerung des Risikomanagements, Pflege des Risikoregisters | +| {{ROLE_MANAGEMENT}} | Entscheidung über Risikoakzeptanz | +| Asset/Prozessverantwortliche | Mitwirkung bei Risikobewertung | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_ISB}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Zugehörige Verfahren: {{LINK:VA-09}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:R01}}, {{LINK:R04}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md b/seed/isms-vorlagenpaket-v2/richtlinien/R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md new file mode 100644 index 0000000..7527058 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R04_Incident-Notfall-und-Kontinuitaetsrichtlinie.md @@ -0,0 +1,156 @@ +# Richtlinie Incident-, Notfall- und Kontinuitätsrichtlinie + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_ISB}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt Meldung und Behandlung von Sicherheitsereignissen, das Krisenmanagement sowie die Notfall- und Kontinuitätsplanung für IT-Dienste. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Meldung von Ereignissen (ISA 1.6.1) + + +**Anforderung** + + +- **[MUSS]** Sicherheitsrelevante Ereignisse und Beobachtungen können über einen definierten Meldeweg gemeldet werden. + +- **[MUSS]** Der Meldeweg ist bekannt gemacht und niedrigschwellig erreichbar. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Meldungen werden zentral erfasst und kategorisiert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Sicherheitsereignisse können über einen definierten Meldeweg (Meldebutton/Formular im {{TOOL_TICKET}} bzw. ISMS-Tool sowie per E-Mail an {{ROLE_ISB}}) gemeldet werden. + +Der Meldeweg ist allen Beschäftigten über Onboarding und Awareness (BL-HR-01) bekannt und niedrigschwellig, auch anonym, erreichbar. +{{#if FLAG_INCLUDE_SHOULD}} + +Meldungen werden zentral im ISMS-Tool erfasst, kategorisiert und einem Schweregrad zugeordnet. +{{/if}} + +### 3.2 Behandlung von Sicherheitsereignissen (ISA 1.6.2) + + +**Anforderung** + + +- **[MUSS]** Gemeldete Sicherheitsereignisse werden bewertet, priorisiert, behandelt und dokumentiert. + +- **[MUSS]** Verantwortlichkeiten und Eskalationswege für die Vorfallsbehandlung sind definiert. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Erkenntnisse aus Vorfällen werden ausgewertet (Lessons Learned) und führen zu Verbesserungen. +{{/if}} +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Meldepflichten (z. B. an Kunden/OEM, Behörden) sind berücksichtigt. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Ereignisse werden nach einem definierten Incident-Verfahren bewertet, priorisiert, eingedämmt, behoben und dokumentiert; die Bearbeitung erfolgt im {{TOOL_TICKET}}. + +Verantwortlichkeiten und Eskalationsstufen sind definiert; {{ROLE_ISB}} koordiniert, {{ROLE_IT_LEAD}} setzt technische Maßnahmen um. +{{#if FLAG_INCLUDE_SHOULD}} + +Nach relevanten Vorfällen erfolgt eine Nachbereitung (Lessons Learned) mit Ableitung und Nachverfolgung von Verbesserungsmaßnahmen. +{{/if}} +{{#if FLAG_INCLUDE_SHOULD}} + +Vertragliche und gesetzliche Meldepflichten (Kunden/OEM, Aufsichtsbehörden, bei personenbezogenen Daten binnen 72 Stunden) sind im Verfahren berücksichtigt. +{{/if}} + +### 3.3 Krisenmanagement (ISA 1.6.3) + + +**Anforderung** + + +- **[MUSS]** Die Organisation ist auf die Bewältigung von Krisensituationen vorbereitet (Rollen, Kommunikation, Entscheidungswege). +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Krisen-/Notfallpläne werden regelmäßig geübt und aktualisiert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Ein Krisenmanagement mit Krisenstab, Rollen, Kommunikations- und Entscheidungswegen ist definiert; der Krisenstab wird durch die {{ROLE_MANAGEMENT}} einberufen. +{{#if FLAG_INCLUDE_SHOULD}} + +Krisen- und Notfallpläne werden mindestens {{REVIEW_CYCLE}} geübt (z. B. Tabletop-Übung) und aktualisiert. +{{/if}} + +### 3.4 Kontinuitätsplanung IT (ISA 5.2.8) + + +**Anforderung** + + +- **[MUSS]** Für kritische IT-Dienste besteht eine Kontinuitätsplanung (Wiederanlaufziele, Verantwortliche, Maßnahmen). +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Wiederanlaufmaßnahmen werden regelmäßig getestet; Ergebnisse werden dokumentiert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Für kritische IT-Dienste bestehen Wiederanlaufziele (RTO/RPO), Verantwortliche und Maßnahmen; {{ROLE_IT_LEAD}} verantwortet die Kontinuitätsplanung. +{{#if FLAG_INCLUDE_SHOULD}} + +Wiederanlaufmaßnahmen werden mindestens {{BACKUP_TEST_FREQ}} getestet (BL-OPS-06); Ergebnisse werden dokumentiert. +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_ISB}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_ISB}} | Koordination der Vorfallsbehandlung | +| {{ROLE_IT_LEAD}} | IT-Notfall- und Wiederanlaufplanung | +| {{ROLE_MANAGEMENT}} | Einberufung Krisenstab | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_ISB}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Zugehörige Verfahren: {{LINK:VA-01}}, {{LINK:VA-02}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:R03}}, {{LINK:R10}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R05_Personalsicherheit-und-Awareness.md b/seed/isms-vorlagenpaket-v2/richtlinien/R05_Personalsicherheit-und-Awareness.md new file mode 100644 index 0000000..e5075f3 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R05_Personalsicherheit-und-Awareness.md @@ -0,0 +1,119 @@ +# Richtlinie Personalsicherheit und Awareness + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_HR_LEAD}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt Eignung und Qualifikation für sicherheitsrelevante Tätigkeiten, die vertragliche Verpflichtung des Personals sowie Schulung und Sensibilisierung. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Qualifikation für sensible Tätigkeiten (ISA 2.1.1) + + +**Anforderung** + + +- **[MUSS]** Für sicherheitsrelevante/sensible Tätigkeiten ist die erforderliche Qualifikation und Zuverlässigkeit der Beschäftigten sichergestellt. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Anforderungen an Positionen sind beschrieben; angemessene Überprüfungen erfolgen im rechtlich zulässigen Rahmen. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Für sensible Tätigkeiten werden Qualifikation und Zuverlässigkeit im rechtlich zulässigen Rahmen sichergestellt (z. B. Qualifikationsnachweise, bei besonders schutzbedürftigen Rollen ggf. Führungszeugnis). +{{#if FLAG_INCLUDE_SHOULD}} + +Sicherheitsanforderungen an Positionen sind in Stellenbeschreibungen hinterlegt; Überprüfungen erfolgen anlass- und rollenbezogen. +{{/if}} + +### 3.2 Vertragliche Verpflichtung (ISA 2.1.2) + + +**Anforderung** + + +- **[MUSS]** Alle Beschäftigten sind vertraglich zur Einhaltung der Informationssicherheit und zur Vertraulichkeit verpflichtet. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Verpflichtungen gelten auch nach Beendigung des Arbeitsverhältnisses fort und umfassen Rückgabepflichten. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Alle Beschäftigten werden bei Eintritt vertraglich zur Vertraulichkeit und Einhaltung der Informationssicherheit verpflichtet ({{ROLE_HR_LEAD}}); der Nachweis wird in der Personalakte geführt. +{{#if FLAG_INCLUDE_SHOULD}} + +Die Vertraulichkeitsverpflichtung gilt nachvertraglich fort; Rückgabe von Assets und Entzug von Berechtigungen beim Austritt sind über {{TOOL_TICKET}} geregelt (Leaver-Prozess). +{{/if}} + +### 3.3 Sensibilisierung und Schulung (ISA 2.1.3) + + +**Anforderung** + + +- **[MUSS]** Beschäftigte werden hinsichtlich Informationssicherheit sensibilisiert und geschult. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Schulungsinhalte sind rollenspezifisch; die Wirksamkeit wird überprüft (z. B. Phishing-Tests). +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Beschäftigte werden bei Eintritt und danach mindestens {{REVIEW_CYCLE}} geschult (BL-HR-01); Teilnahmenachweise werden im {{TOOL_NAME}} geführt. +{{#if FLAG_INCLUDE_SHOULD}} + +Schulungen sind rollenspezifisch; die Wirksamkeit wird durch Phishing-Simulationen und gezielte Nachschulungen überprüft. +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_HR_LEAD}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_HR_LEAD}} | Vertragliche Verpflichtung, Eignungsprüfungen | +| {{ROLE_ISB}} | Inhalte und Nachweis von Schulung und Awareness | +| Führungskräfte | Umsetzung im Verantwortungsbereich | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_HR_LEAD}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Zugehörige Verfahren: {{LINK:VA-12}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:R01}}, {{LINK:R06}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R06_Mobiles-Arbeiten-und-mobile-Geraete.md b/seed/isms-vorlagenpaket-v2/richtlinien/R06_Mobiles-Arbeiten-und-mobile-Geraete.md new file mode 100644 index 0000000..12260b8 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R06_Mobiles-Arbeiten-und-mobile-Geraete.md @@ -0,0 +1,109 @@ +# Richtlinie Mobiles Arbeiten und mobile Geräte + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_ISB}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt mobiles Arbeiten (Homeoffice/Telearbeit) sowie den sicheren Umgang mit mobilen IT-Geräten und Datenträgern. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +{{#if FLAG_MOBILE_WORK}} +### 3.1 Mobiles Arbeiten (ISA 2.1.4) + + +**Anforderung** + + +- **[MUSS]** Mobiles Arbeiten ist geregelt (zulässige Orte, Umgang mit Informationen, Absicherung der Verbindung). + +- **[MUSS]** Der Zugriff auf Unternehmensinformationen erfolgt ausschließlich über gesicherte Verbindungen und freigegebene Geräte. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Sichtschutz, Clean-Desk/Clean-Screen und Regeln für öffentliche Umgebungen sind definiert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Mobiles Arbeiten ist in einer Regelung festgelegt; der Zugriff erfolgt ausschließlich über {{TECH_VPN}} mit MFA (BL-IAM-02) und freigegebene, verschlüsselte Geräte (BL-CRY-03). + +Der Zugriff auf Unternehmensinformationen ist auf verwaltete Geräte ({{TECH_MDM}}) beschränkt; die Nutzung ist an die Einhaltung der Regelung gebunden. +{{#if FLAG_INCLUDE_SHOULD}} + +Regeln zu Sichtschutz, Clean-Desk/Clean-Screen und zum Arbeiten in öffentlichen Umgebungen sind definiert und Teil der Awareness (BL-HR-01). +{{/if}} +{{/if}} + +{{#if FLAG_MOBILE_DEVICES}} +### 3.2 Mobile Geräte und Datenträger (ISA 3.1.4) + + +**Anforderung** + + +- **[MUSS]** Der Umgang mit mobilen IT-Geräten und mobilen Datenträgern ist geregelt (Verschlüsselung, Verlustmeldung, Freigabe). + +- **[MUSS]** Mobile Geräte sind verschlüsselt und können bei Verlust gesperrt/gelöscht werden. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Der Einsatz privater Geräte (BYOD) ist geregelt oder untersagt; Wechseldatenträger werden kontrolliert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Mobile Geräte sind vollverschlüsselt (BL-CRY-03) und über {{TECH_MDM}} zentral verwaltet; Verlustmeldung erfolgt über den Meldeweg (R04) und {{TOOL_TICKET}}. + +Bei Verlust können Geräte über {{TECH_MDM}} gesperrt und aus der Ferne gelöscht werden (BL-EP-02). +{{#if FLAG_INCLUDE_SHOULD}} + +Der Einsatz privater Geräte (BYOD) ist geregelt bzw. untersagt; Wechseldatenträger werden nur verschlüsselt und freigegeben zugelassen (BL-EP-03). +{{/if}} +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_ISB}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_ISB}} | Festlegung der Sicherheitsanforderungen | +| {{ROLE_IT_LEAD}} | Technische Umsetzung (VPN, MDM) | +| Mitarbeitende | Einhaltung der Vorgaben | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_ISB}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:R05}}, {{LINK:R07}}, {{LINK:R08}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R07_Physische-Sicherheit.md b/seed/isms-vorlagenpaket-v2/richtlinien/R07_Physische-Sicherheit.md new file mode 100644 index 0000000..1d35c1e --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R07_Physische-Sicherheit.md @@ -0,0 +1,100 @@ +# Richtlinie Physische Sicherheit + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt den physischen Schutz von Informationen und informationsverarbeitenden Einrichtungen durch Sicherheitszonen, Zutrittsschutz und den Umgang mit unterstützenden Betriebsmitteln. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Sicherheitszonen und Zutritt (ISA 3.1.1) + + +**Anforderung** + + +- **[MUSS]** Sicherheitszonen sind definiert und der Zutritt zu schützenswerten Bereichen ist reglementiert und nachvollziehbar. + +- **[MUSS]** Zutrittsrechte werden nach Bedarf vergeben, dokumentiert und bei Wegfall entzogen. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Zutritte werden protokolliert; Besucher werden begleitet; technische Schutzmaßnahmen sind vorhanden. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Sicherheitszonen sind definiert (BL-PHY-01); der Zutritt zu schutzbedürftigen Bereichen (z. B. Serverraum) ist reglementiert und wird protokolliert (BL-PHY-02). + +Zutrittsrechte werden bedarfsorientiert über {{TOOL_TICKET}} vergeben, dokumentiert und bei Wegfall (Austritt/Rollenwechsel) entzogen. +{{#if FLAG_INCLUDE_SHOULD}} + +Besucher werden registriert und begleitet; technische Schutzmaßnahmen (Zutrittskontrolle, Alarm, Videoüberwachung im rechtlichen Rahmen) sind vorhanden. +{{/if}} + +### 3.2 Umgang mit unterstützenden Betriebsmitteln (ISA 3.1.3) + + +**Anforderung** + + +- **[MUSS]** Der Umgang mit unterstützenden Assets (z. B. Verkabelung, Strom-/Klimaversorgung, Serverräume) ist geregelt und schützt vor Ausfall und unbefugtem Zugriff. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Versorgungseinrichtungen werden gewartet und überwacht; Redundanzen bestehen für kritische Bereiche. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Serverräume und Versorgungseinrichtungen (Strom, Klima, Verkabelung) sind zutrittsgeschützt und gegen Ausfall abgesichert. +{{#if FLAG_INCLUDE_SHOULD}} + +Versorgungseinrichtungen werden gewartet und überwacht; für kritische Bereiche bestehen Redundanzen (z. B. USV, Klimaredundanz). +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_IT_LEAD}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_IT_LEAD}} | Zonenkonzept, Zutrittsschutz, Betriebsmittel | +| {{ROLE_ISB}} | Vorgabe der Anforderungen | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_IT_LEAD}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:R02}}, {{LINK:R06}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R08_Identitaets-und-Zugriffsmanagement.md b/seed/isms-vorlagenpaket-v2/richtlinien/R08_Identitaets-und-Zugriffsmanagement.md new file mode 100644 index 0000000..72062c1 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R08_Identitaets-und-Zugriffsmanagement.md @@ -0,0 +1,148 @@ +# Richtlinie Identitäts- und Zugriffsmanagement + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt Identifikationsmittel, die sichere Anmeldung, die Verwaltung von Benutzerkonten und Anmeldeinformationen sowie die Vergabe und Kontrolle von Zugriffsrechten. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Identifikationsmittel (ISA 4.1.1) + + +**Anforderung** + + +- **[MUSS]** Der Einsatz von Identifikationsmitteln (Benutzerkennungen, Token, Zertifikate) ist geregelt und eindeutig personenbezogen. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Ausgabe, Rücknahme und Sperrung von Identifikationsmitteln sind dokumentiert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Identifikationsmittel (Benutzerkennungen, Token, Zertifikate) werden eindeutig personenbezogen über {{TOOL_IAM}} vergeben; Sammelkonten werden vermieden bzw. dokumentiert und begründet. +{{#if FLAG_INCLUDE_SHOULD}} + +Ausgabe, Rücknahme und Sperrung von Identifikationsmitteln werden im {{TOOL_TICKET}} beantragt, genehmigt und dokumentiert (BL-IAM-07). +{{/if}} + +### 3.2 Sichere Anmeldung (ISA 4.1.2) + + +**Anforderung** + + +- **[MUSS]** Der Zugang zu IT-Diensten und IT-Systemen ist durch sichere Authentifizierungsverfahren geschützt. + +- **[MUSS]** Für erhöhten Schutzbedarf und Fernzugriffe wird Mehr-Faktor-Authentifizierung (MFA) eingesetzt. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Passwortanforderungen, Sperrmechanismen und Sitzungsverwaltung sind definiert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Der Zugang ist durch sichere Authentifizierung geschützt; die Passwortvorgaben nach BL-IAM-01 (mind. {{PW_MIN_LENGTH}} Zeichen, {{PW_COMPLEXITY}}, {{PW_ROTATION}}) werden zentral über {{TOOL_IAM}} erzwungen. + +Für Fernzugriffe, administrative Zugänge und Cloud-Dienste wird MFA gemäß BL-IAM-02 über {{TECH_MFA}} durchgesetzt. +{{#if FLAG_INCLUDE_SHOULD}} + +Sperrmechanismen (BL-IAM-04) und Sitzungs-Timeouts (BL-IAM-03) sind zentral konfiguriert. +{{/if}} + +### 3.3 Konten und Anmeldeinformationen (ISA 4.1.3) + + +**Anforderung** + + +- **[MUSS]** Benutzerkonten und Anmeldeinformationen werden sicher verwaltet (Erstellung, Aenderung, Sperrung, Löschung). +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Privilegierte und technische Konten werden gesondert verwaltet und überwacht. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Konten werden über einen definierten Lebenszyklus (Joiner/Mover/Leaver) verwaltet; Auslöser sind {{TOOL_TICKET}}-Aufträge aus HR-/Vorgesetztenmeldungen. +{{#if FLAG_INCLUDE_SHOULD}} + +Privilegierte und technische Konten werden gesondert verwaltet, einzeln zugeordnet und verstärkt protokolliert (BL-IAM-06). +{{/if}} + +### 3.4 Zugriffsrechte (ISA 4.2.1) + + +**Anforderung** + + +- **[MUSS]** Zugriffsrechte werden nach dem Minimalprinzip (need-to-know / least privilege) vergeben; Verfahren für Antrag, Prüfung und Genehmigung bestehen. + +- **[MUSS]** Zugriffsrechte werden bei Wegfall des Bedarfs entzogen und regelmäßig überprüft (Rezertifizierung){{#if FLAG_CUSTOMER_SYSTEMS}}, auch für Zugriffe in Kundensystemen{{/if}}. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Berechtigungen werden über Rollen vergeben; normale Konten erhalten keine privilegierten Rechte. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Zugriffsrechte werden nach dem Minimalprinzip (need-to-know/least privilege) vergeben; Antrag, fachliche Prüfung und Genehmigung erfolgen im {{TOOL_TICKET}}. + +Berechtigungen werden beim Wegfall entzogen und mindestens {{RECERT_FREQ}} rezertifiziert (BL-IAM-05){{#if FLAG_CUSTOMER_SYSTEMS}}, auch für Zugriffe in Kundensystemen{{/if}}. +{{#if FLAG_INCLUDE_SHOULD}} + +Berechtigungen werden rollenbasiert (RBAC) über {{TOOL_IAM}} vergeben; Standardkonten erhalten keine privilegierten Rechte. +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_IT_LEAD}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_IT_LEAD}} | Technische Umsetzung IAM | +| Fachbereiche | Fachliche Freigabe von Berechtigungen | +| {{ROLE_ISB}} | Ueberwachung der Einhaltung | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_IT_LEAD}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Zugehörige Verfahren: {{LINK:VA-03}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:R02}}, {{LINK:R05}}, {{LINK:R10}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R09_Kryptografie-und-Uebertragungsrichtlinie.md b/seed/isms-vorlagenpaket-v2/richtlinien/R09_Kryptografie-und-Uebertragungsrichtlinie.md new file mode 100644 index 0000000..07972de --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R09_Kryptografie-und-Uebertragungsrichtlinie.md @@ -0,0 +1,101 @@ +# Richtlinie Kryptografie- und Uebertragungsrichtlinie + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt den Einsatz kryptografischer Verfahren, die Schlüsselverwaltung sowie den Schutz von Informationen bei der Uebertragung. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Einsatz kryptografischer Verfahren (ISA 5.1.1) + + +**Anforderung** + + +- **[MUSS]** Der Einsatz von Kryptografie ist geregelt; zulässige Verfahren und Schlüssellängen entsprechen dem Stand der Technik. + +- **[MUSS]** Schlüssel werden über ihren gesamten Lebenszyklus sicher verwaltet. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Ein Kryptokonzept ist dokumentiert{{#if FLAG_CRYPTO_PKI}} und eine PKI/Zertifikatsverwaltung ist etabliert{{/if}}. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Zulässige Verfahren und Schlüssellängen nach BL-CRY-02 ({{CRYPTO_ALGO}}) sind vorgegeben; veraltete Verfahren sind untersagt. + +Schlüssel werden über ihren Lebenszyklus (Erzeugung, Verteilung, Speicherung, Sperrung, Vernichtung) sicher verwaltet (BL-CRY-05). +{{#if FLAG_INCLUDE_SHOULD}} + +Ein Kryptokonzept ist dokumentiert{{#if FLAG_CRYPTO_PKI}}; eine PKI/Zertifikatsverwaltung ist etabliert{{/if}}. +{{/if}} + +### 3.2 Schutz bei Uebertragung (ISA 5.1.2) + + +**Anforderung** + + +- **[MUSS]** Informationen werden abhängig vom Schutzbedarf bei der Uebertragung geschützt (z. B. Transportverschlüsselung, gesicherte Kanäle). +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Regeln für sichere Uebertragungswege (E-Mail-Verschlüsselung, sichere Dateiübertragung) sind definiert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Informationen werden schutzbedarfsgerecht bei der Übertragung geschützt: mindestens {{TLS_MIN}} (BL-CRY-01) und gesicherte Kanäle. +{{#if FLAG_INCLUDE_SHOULD}} + +Regeln für E-Mail-Verschlüsselung und sichere Dateiübertragung sind definiert (BL-CRY-04). +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_IT_LEAD}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_IT_LEAD}} | Verfahren und Schlüsselverwaltung | +| {{ROLE_ISB}} | Vorgabe zulässiger Algorithmen/Stärken | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_IT_LEAD}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Zugehörige Verfahren: {{LINK:VA-07}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:R08}}, {{LINK:R10}}, {{LINK:R12}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R10_Betriebssicherheit.md b/seed/isms-vorlagenpaket-v2/richtlinien/R10_Betriebssicherheit.md new file mode 100644 index 0000000..19ed078 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R10_Betriebssicherheit.md @@ -0,0 +1,219 @@ +# Richtlinie Betriebssicherheit + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt den sicheren IT-Betrieb: Change-Management, Trennung von Umgebungen, Malware-Schutz, Protokollierung, Schwachstellen- und Patch-Management, technische Prüfungen, Netzwerksicherheit sowie Datensicherung und Wiederherstellung. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Change-Management (ISA 5.2.1) + + +**Anforderung** + + +- **[MUSS]** Aenderungen an IT-Systemen werden geregelt beantragt, bewertet, getestet, genehmigt und dokumentiert. + +**Umsetzung bei {{ORG_NAME}}** + + +Änderungen durchlaufen ein Change-Verfahren mit Antrag, Risikobewertung, Test, Genehmigung und Dokumentation im {{TOOL_TICKET}} (BL-OPS-09). + +### 3.2 Trennung der Umgebungen (ISA 5.2.2) + + +**Anforderung** + + +- **[MUSS]** Entwicklungs-, Test- und Produktionsumgebungen sind getrennt. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Produktivdaten werden nicht ungeschützt in Test-/Entwicklungsumgebungen verwendet. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Entwicklung, Test und Produktion sind getrennt betrieben. +{{#if FLAG_INCLUDE_SHOULD}} + +Produktivdaten werden in Test-/Entwicklungsumgebungen nur anonymisiert/pseudonymisiert genutzt. +{{/if}} + +### 3.3 Schutz vor Malware (ISA 5.2.3) + + +**Anforderung** + + +- **[MUSS]** Anforderungen zum Schutz vor Schadsoftware sind bestimmt; technische und organisatorische Maßnahmen sind umgesetzt. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Schutzsoftware wird automatisch aktualisiert; unnötige Netzwerkdienste sind deaktiviert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Malware-Schutz ist über {{TECH_MALWARE}} auf allen Endpunkten und Servern umgesetzt (BL-OPS-03). +{{#if FLAG_INCLUDE_SHOULD}} + +Signaturen/Engines werden {{MALWARE_UPDATE}} aktualisiert; unnötige Netzwerkdienste sind deaktiviert. +{{/if}} + +### 3.4 Protokollierung und Auswertung (ISA 5.2.4) + + +**Anforderung** + + +- **[MUSS]** Sicherheitsrelevante Ereignisse werden protokolliert und ausgewertet. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Protokolle sind vor Manipulation geschützt; Aufbewahrungsfristen sind definiert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Sicherheitsrelevante Ereignisse werden zentral über {{TECH_SIEM}} protokolliert und ausgewertet (BL-OPS-04). +{{#if FLAG_INCLUDE_SHOULD}} + +Protokolle sind manipulationsgeschützt; die Aufbewahrung beträgt {{LOG_RETENTION}}. +{{/if}} + +### 3.5 Schwachstellen- und Patch-Management (ISA 5.2.5) + + +**Anforderung** + + +- **[MUSS]** Schwachstellen werden identifiziert und risikoorientiert behoben (Patch-Management). +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Es besteht ein regelmäßiges Schwachstellen-Scanning; kritische Patches werden priorisiert. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Schwachstellen werden erfasst und nach BL-OPS-01 risikoorientiert gepatcht (kritisch {{PATCH_SLA_CRIT}}); die Nachverfolgung erfolgt im {{TOOL_TICKET}}. +{{#if FLAG_INCLUDE_SHOULD}} + +Ein Schwachstellen-Scanning ({{VULN_SCAN_FREQ}}, BL-OPS-02) ist etabliert. +{{/if}} + +### 3.6 Technische Überprüfung (ISA 5.2.6) + + +**Anforderung** + + +- **[MUSS]** IT-Systeme und Dienste werden technisch überprüft (z. B. Systemhärtung, Penetrationstests). + +**Umsetzung bei {{ORG_NAME}}** + + +Systeme werden nach Härtungsvorgaben (BL-OPS-07, z. B. CIS-Benchmarks) konfiguriert und risikoorientiert technisch geprüft (Penetrationstest {{PENTEST_FREQ}}, BL-OPS-08). + +### 3.7 Netzwerksicherheit (ISA 5.2.7) + + +**Anforderung** + + +- **[MUSS]** Das Netzwerk wird gesteuert und abgesichert (Segmentierung, Zugangskontrolle, Absicherung nach außen). +{{#if FLAG_OT_USED}} + +- **[MUSS]** Produktions-/OT-Netze sind von Office-Netzen getrennt und besonders abgesichert. +{{/if}} +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Ein aktueller Netzplan und ein Segmentierungskonzept liegen vor. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Das Netzwerk ist nach Schutzbedarf segmentiert (BL-NET-01), zugangskontrolliert und nach außen über Firewall (Default-Deny, BL-NET-02) abgesichert. +{{#if FLAG_OT_USED}} + +Produktions-/OT-Netze sind von Office-Netzen getrennt und besonders abgesichert (BL-NET-01). +{{/if}} +{{#if FLAG_INCLUDE_SHOULD}} + +Ein aktueller Netzplan und ein Segmentierungskonzept werden gepflegt. +{{/if}} + +### 3.8 Backup und Wiederherstellung (ISA 5.2.9) + + +**Anforderung** + + +- **[MUSS]** Daten und IT-Dienste werden gesichert; Wiederherstellung ist geregelt. + +- **[MUSS]** Wiederherstellungstests werden regelmäßig durchgeführt. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Backups werden geschützt/ausgelagert aufbewahrt (z. B. offline/immutable). +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Daten und Dienste werden nach Schema {{BACKUP_SCHEME}} über {{TECH_BACKUP}} gesichert (BL-OPS-05); die Wiederherstellung ist geregelt. + +Wiederherstellungstests werden mindestens {{BACKUP_TEST_FREQ}} durchgeführt und dokumentiert (BL-OPS-06). +{{#if FLAG_INCLUDE_SHOULD}} + +Backups werden geschützt und ausgelagert aufbewahrt (offline/immutable), Aufbewahrung {{BACKUP_RETENTION}}. +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_IT_LEAD}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_IT_LEAD}} | Sicherer IT-Betrieb | +| {{ROLE_ISB}} | Ueberwachung der Einhaltung | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_IT_LEAD}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Zugehörige Verfahren: {{LINK:VA-04}}, {{LINK:VA-05}}, {{LINK:VA-06}}, {{LINK:VA-13}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:R04}}, {{LINK:R08}}, {{LINK:R11}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R11_Sichere-Systembeschaffung-und-Entwicklung.md b/seed/isms-vorlagenpaket-v2/richtlinien/R11_Sichere-Systembeschaffung-und-Entwicklung.md new file mode 100644 index 0000000..31c204e --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R11_Sichere-Systembeschaffung-und-Entwicklung.md @@ -0,0 +1,117 @@ +# Richtlinie Sichere Systembeschaffung und Entwicklung + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt die Berücksichtigung der Informationssicherheit bei Beschaffung und Weiterentwicklung von IT-Systemen, Anforderungen an Netzdienste sowie Rückgabe und sichere Löschung von Informationen. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Sicherheit bei Beschaffung/Entwicklung (ISA 5.3.1) + + +**Anforderung** + + +- **[MUSS]** Bei Beschaffung oder Weiterentwicklung von IT-Systemen werden Informationssicherheitsanforderungen ermittelt und berücksichtigt. +{{#if FLAG_DEV_INHOUSE}} + +- **[MUSS]** Für die Eigenentwicklung gelten Vorgaben für sichere Entwicklung (Secure Coding, Tests, Freigaben). +{{/if}} +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Sicherheitsanforderungen sind Bestandteil des Beschaffungs-/Entwicklungsprozesses (Security by Design). +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Sicherheitsanforderungen sind fester Bestandteil von Beschaffungs- und Änderungsprozessen (Security by Design); die Prüfung erfolgt vor Freigabe im {{TOOL_TICKET}}. +{{#if FLAG_DEV_INHOUSE}} + +Für die Eigenentwicklung gelten Secure-Coding-Vorgaben mit Code-Reviews, automatisierten Sicherheitstests (SAST/Dependency-Scan) und dokumentierten Freigaben. +{{/if}} +{{#if FLAG_INCLUDE_SHOULD}} + +Sicherheitsanforderungen werden dokumentiert und ihre Umsetzung vor Produktivsetzung geprüft. +{{/if}} + +### 3.2 Anforderungen an Netzdienste (ISA 5.3.2) + + +**Anforderung** + + +- **[MUSS]** Sicherheitsanforderungen an Netzdienste (intern und extern) sind definiert. + +**Umsetzung bei {{ORG_NAME}}** + + +Für genutzte Netzdienste (intern/extern) sind Sicherheitsanforderungen definiert und vertraglich bzw. technisch vereinbart. + +### 3.3 Rückgabe und sichere Löschung (ISA 5.3.3) + + +**Anforderung** + + +- **[MUSS]** Rückgabe und sichere Entfernung/Löschung von Informationen und Assets sind geregelt. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Löschverfahren entsprechen dem Schutzbedarf; Löschungen werden nachgewiesen. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Rückgabe und sichere Löschung/Vernichtung (bei Vertragsende, Geräteausmusterung) sind nach BL-DEL-01 geregelt und werden nachgewiesen. +{{#if FLAG_INCLUDE_SHOULD}} + +Löschverfahren richten sich nach dem Schutzbedarf; Löschungen werden dokumentiert (Löschprotokoll). +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_IT_LEAD}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_IT_LEAD}} | Beschaffung/Entwicklung | +| {{ROLE_ISB}} | Definition Sicherheitsanforderungen | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_IT_LEAD}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:R02}}, {{LINK:R10}}, {{LINK:R12}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R12_Cloud-KI-und-externe-IT-Dienste.md b/seed/isms-vorlagenpaket-v2/richtlinien/R12_Cloud-KI-und-externe-IT-Dienste.md new file mode 100644 index 0000000..3734e0f --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R12_Cloud-KI-und-externe-IT-Dienste.md @@ -0,0 +1,116 @@ +# Richtlinie Cloud-, KI- und externe IT-Dienste + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_ISB}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt den Schutz von Informationen bei der Nutzung ausgelagerter oder geteilter externer IT-Dienste (Cloud) sowie beim Einsatz von KI-/GenAI-Diensten, einschließlich Auswahl, Freigabe, zulässiger Nutzung und Datenpreisgabe. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Externe/geteilte IT-Dienste und Cloud (ISA 5.3.4) + + +**Anforderung** + + +- **[MUSS]** Bei geteilten externen IT-Diensten ist durch wirksame Mandantentrennung sichergestellt, dass Unbefugte anderer Organisationen nicht auf eigene Informationen zugreifen können. +{{#if FLAG_CLOUD_USED}} + +- **[MUSS]** Cloud-Dienste werden vor Nutzung bewertet und freigegeben; nur freigegebene Dienste werden für Unternehmensinformationen genutzt. +{{/if}} +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Das Segregationskonzept des Anbieters ist dokumentiert und wird bei Aenderungen angepasst. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Bei geteilten externen Diensten wird eine wirksame Mandantentrennung gefordert und vertraglich zugesichert; die Prüfung erfolgt vor Freigabe. +{{#if FLAG_CLOUD_USED}} + +Cloud-Dienste werden vor Nutzung bewertet (Schutzbedarf, Datenlokation/EU, Verschlüsselung, Exit) und von {{ROLE_ISB}} freigegeben; die Freigabeliste wird im ISMS-Tool ({{TOOL_NAME}}) geführt. +{{/if}} +{{#if FLAG_INCLUDE_SHOULD}} + +Das Segregationskonzept des Anbieters wird dokumentiert und bei Änderungen aktualisiert. +{{/if}} + +{{#if FLAG_AI_USED}} +### 3.2 Nutzung von KI-/GenAI-Diensten (ISA 5.3.4-KI) + + +**Anforderung** + + +- **[MUSS]** Der Einsatz von KI-/GenAI-Diensten ist geregelt; es werden nur freigegebene Dienste genutzt. + +- **[MUSS]** Die Eingabe vertraulicher oder personenbezogener Informationen in nicht freigegebene KI-Dienste ist untersagt; zulässige Datenklassen je Dienst sind definiert. + +- **[MUSS]** Bei freigegebenen KI-Diensten ist geklärt, ob Eingaben zum Training genutzt werden; eine Trainings-/Weitergabe von Unternehmensdaten wird ausgeschlossen oder vertraglich untersagt. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Ergebnisse werden vor geschäftskritischer Verwendung geprüft (Human-in-the-Loop); der KI-Einsatz wird dokumentiert; regulatorische Anforderungen (z. B. EU AI Act) werden berücksichtigt. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Der Einsatz von KI-/GenAI-Diensten ist geregelt; nur von {{ROLE_ISB}} freigegebene Dienste (Freigabeliste im ISMS-Tool) dürfen genutzt werden. + +Zulässige Datenklassen je KI-Dienst sind definiert; die Eingabe vertraulicher oder personenbezogener Daten in nicht freigegebene Dienste ist untersagt (Awareness BL-HR-01). + +Bei Freigabe wird geprüft und vertraglich sichergestellt, dass Eingaben nicht zum Training genutzt oder an Dritte weitergegeben werden (Opt-out bzw. Enterprise-Vertrag). +{{#if FLAG_INCLUDE_SHOULD}} + +KI-Ergebnisse werden vor geschäftskritischer Verwendung durch Menschen geprüft (Human-in-the-Loop); der KI-Einsatz wird dokumentiert und regulatorische Anforderungen (EU AI Act) berücksichtigt. +{{/if}} +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_ISB}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_ISB}} | Freigabe Cloud-/KI-Dienste, Pflege der Freigabeliste | +| {{ROLE_IT_LEAD}} | Technische Absicherung | +| Fachbereiche | Nutzung nur freigegebener Dienste | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_ISB}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Zugehörige Verfahren: {{LINK:VA-11}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:R09}}, {{LINK:R11}}, {{LINK:R13}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R13_Lieferanten-und-Dienstleistersteuerung.md b/seed/isms-vorlagenpaket-v2/richtlinien/R13_Lieferanten-und-Dienstleistersteuerung.md new file mode 100644 index 0000000..9e736a5 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R13_Lieferanten-und-Dienstleistersteuerung.md @@ -0,0 +1,126 @@ +# Richtlinie Lieferanten- und Dienstleistersteuerung + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_ISB}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt die Sicherstellung der Informationssicherheit bei Auftragnehmern und Lieferanten, Vertraulichkeitsvereinbarungen sowie die Abgrenzung von Verantwortlichkeiten mit externen IT-Dienstleistern. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Informationssicherheit bei Lieferanten (ISA 6.1.1) + + +**Anforderung** + + +- **[MUSS]** Informationssicherheitsanforderungen an Auftragnehmer/Lieferanten sind ermittelt und werden vertraglich vereinbart und überwacht. + +- **[MUSS]** Lieferanten werden risikoorientiert bewertet. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Die Einhaltung der Anforderungen wird regelmäßig überprüft (z. B. Nachweise, Audits, TISAX-Label). +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Sicherheitsanforderungen an Lieferanten werden ermittelt, vertraglich vereinbart und überwacht; das Lieferantenverzeichnis wird im ISMS-Tool ({{TOOL_NAME}}) geführt. + +Lieferanten werden risikoorientiert nach BL-SUP-01 (Schutzbedarf, Zugriff) klassifiziert. +{{#if FLAG_INCLUDE_SHOULD}} + +Die Einhaltung wird risikobasiert überprüft (Selbstauskunft, Nachweise, Audits, TISAX-Label). +{{/if}} + +### 3.2 Vertraulichkeit (ISA 6.1.2) + + +**Anforderung** + + +- **[MUSS]** Der Austausch von Informationen mit Externen ist durch Vertraulichkeitsvereinbarungen (NDA) abgesichert. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** NDA-Vorlagen sind standardisiert; Geltungsdauer und Rückgabe-/Löschpflichten sind geregelt. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Vor dem Austausch schutzbedürftiger Informationen werden Vertraulichkeitsvereinbarungen (NDA) abgeschlossen und im ISMS-Tool hinterlegt. +{{#if FLAG_INCLUDE_SHOULD}} + +Standardisierte NDA-Vorlagen mit Geltungsdauer sowie Rückgabe-/Löschpflichten werden verwendet. +{{/if}} + +### 3.3 Abgrenzung der Verantwortlichkeiten (ISA 6.1.3) + + +**Anforderung** + +{{#if FLAG_EXTERNAL_IT}} + +- **[MUSS]** Verantwortlichkeiten zwischen der Organisation und externen IT-Dienstleistern sind klar abgegrenzt und dokumentiert. +{{/if}} +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Schnittstellen, Eskalations- und Meldewege mit Dienstleistern sind vereinbart. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + +{{#if FLAG_EXTERNAL_IT}} + +Die Verantwortlichkeiten mit externen IT-Dienstleistern (Betriebs-, Sicherheits-, Melde- und Mitwirkungspflichten) sind abgegrenzt und vertraglich dokumentiert. +{{/if}} +{{#if FLAG_INCLUDE_SHOULD}} + +Schnittstellen sowie Eskalations- und Meldewege sind vertraglich vereinbart (Anbindung an R04). +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_ISB}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_ISB}} | Steuerung der Lieferantensicherheit, Pflege Lieferantenverzeichnis | +| Einkauf | Vertragliche Einbindung der Anforderungen | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_ISB}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Zugehörige Verfahren: {{LINK:VA-10}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:R01}}, {{LINK:R12}} + + diff --git a/seed/isms-vorlagenpaket-v2/richtlinien/R14_Compliance-und-Datenschutz.md b/seed/isms-vorlagenpaket-v2/richtlinien/R14_Compliance-und-Datenschutz.md new file mode 100644 index 0000000..2f1d31d --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/richtlinien/R14_Compliance-und-Datenschutz.md @@ -0,0 +1,102 @@ +# Richtlinie Compliance und Datenschutz + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Richtlinie | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Verantwortlich | {{ROLE_ISB}} | +| Freigabe durch | {{ROLE_MANAGEMENT}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + +## 1. Zweck + +Diese Richtlinie regelt die Einhaltung regulatorischer und vertraglicher Vorgaben sowie den Schutz personenbezogener Daten. Sie konkretisiert die Informationssicherheitsleitlinie ({{LINK:L00}}) und dient der Erfüllung der Anforderungen des VDA ISA 2027. + +## 2. Geltungsbereich + +Diese Richtlinie gilt innerhalb des definierten ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Anforderungen und Umsetzung + +> Aufbau je Abschnitt: **Anforderung** (normativ, aus VDA ISA; [MUSS]/[SOLL]) und **Umsetzung bei {{ORG_NAME}}** (tatsächliche Ausgestaltung, anzupassen wo erforderlich). + +### 3.1 Regulatorische und vertragliche Compliance (ISA 7.1.1) + + +**Anforderung** + + +- **[MUSS]** Relevante gesetzliche, regulatorische und vertragliche Anforderungen an die Informationssicherheit sind identifiziert, dokumentiert und werden eingehalten. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Ein Compliance-/Rechtsregister wird gepflegt und regelmäßig aktualisiert; Verantwortliche sind benannt. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Relevante gesetzliche, regulatorische und vertragliche Anforderungen werden in einem Compliance-/Rechtsregister im ISMS-Tool ({{TOOL_NAME}}) erfasst und ihre Einhaltung nachverfolgt. +{{#if FLAG_INCLUDE_SHOULD}} + +Das Register wird mindestens {{REVIEW_CYCLE}} aktualisiert; je Anforderung ist ein Verantwortlicher benannt. +{{/if}} + +{{#if FLAG_PERSONAL_DATA}} +### 3.2 Schutz personenbezogener Daten (ISA 7.1.2) + + +**Anforderung** + + +- **[MUSS]** Beim Umgang mit personenbezogenen Daten werden die datenschutzrechtlichen Anforderungen (z. B. DSGVO) berücksichtigt. + +- **[MUSS]** Ein Verzeichnis der Verarbeitungstätigkeiten wird geführt. +{{#if FLAG_INCLUDE_SHOULD}} + +- **[SOLL]** Technische und organisatorische Maßnahmen (TOM), Löschkonzepte und Betroffenenrechte sind geregelt. +{{/if}} + +**Umsetzung bei {{ORG_NAME}}** + + +Datenschutzrechtliche Anforderungen (DSGVO) werden berücksichtigt; {{ROLE_DPO}} ist eingebunden und bei relevanten Vorhaben (Datenschutz-Folgenabschätzung) beteiligt. + +Das Verzeichnis der Verarbeitungstätigkeiten wird im ISMS-Tool ({{TOOL_NAME}}) geführt und gepflegt. +{{#if FLAG_INCLUDE_SHOULD}} + +Technische und organisatorische Maßnahmen (TOM), Löschkonzepte (BL-DEL-01) und Prozesse für Betroffenenrechte sind geregelt. +{{/if}} +{{/if}} + +## 4. Verbindlichkeit + +Diese Richtlinie ist für alle betroffenen Rollen im Geltungsbereich verbindlich. Die Einhaltung wird durch {{ROLE_ISB}} überwacht. + +## 5. Rollen und Verantwortlichkeiten + +| Rolle | Verantwortung in dieser Richtlinie | +|-------|-------------------------------------| +| {{ROLE_ISB}} | Compliance-Register | +| {{ROLE_DPO}} | Datenschutz | + +## 6. Überprüfung und Aktualisierung + +Diese Richtlinie wird mindestens {{REVIEW_CYCLE}} sowie anlassbezogen durch {{ROLE_ISB}} überprüft und durch {{ROLE_MANAGEMENT}} freigegeben. + +## 7. Nachweise + +Die Nachweise zur Umsetzung dieser Richtlinie werden nicht in diesem Dokument geführt, sondern zentral im Nachweisregister ({{LINK:NACHWEISREGISTER}}) sowie in den zugehörigen Einträgen des ISMS-Tools ({{TOOL_NAME}}). + +## 8. Verwandte Dokumente + +- Informationssicherheitsleitlinie: {{LINK:L00}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} +- Nachweisregister: {{LINK:NACHWEISREGISTER}} +- Weitere: {{LINK:L00}}, {{LINK:R03}} + + diff --git a/seed/isms-vorlagenpaket-v2/variables.schema.json b/seed/isms-vorlagenpaket-v2/variables.schema.json new file mode 100644 index 0000000..0262527 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/variables.schema.json @@ -0,0 +1,71 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "ISMS-Vorlagenpaket v2 – Wizard-Variablen (VDA ISA 2027 / Information Security)", + "description": "Single Source of Truth aller Wizard-Variablen. Konvention: UPPER_SNAKE_CASE, Platzhalter {{NAME}}. Feature-Flags steuern {{#if FLAG_X}}-Bloecke. Der Programmierer generiert die Wizard-Eingaben aus diesem Schema.", + "version": "2.0", + "type": "object", + "properties": { + "ORG_NAME": { "type": "string", "title": "Organisation (voller Name)", "example": "Muster GmbH" }, + "ORG_SHORT": { "type": "string", "title": "Organisation (Kurzname)", "example": "Muster" }, + + "ISMS_SCOPE": { "type": "string", "title": "Geltungsbereich (Kurzlabel)", "example": "IT & Entwicklung Werk Nord" }, + "ISMS_SCOPE_DESCRIPTION":{ "type": "string", "title": "Geltungsbereich (Beschreibung)" }, + + "ROLE_MANAGEMENT": { "type": "string", "title": "Oberste Leitung", "default": "Geschäftsführung" }, + "ROLE_ISB": { "type": "string", "title": "Informationssicherheitsbeauftragte(r) / CISO", "default": "Informationssicherheitsbeauftragte(r) (ISB)" }, + "ROLE_IT_LEAD": { "type": "string", "title": "IT-Leitung", "default": "IT-Leitung" }, + "ROLE_HR_LEAD": { "type": "string", "title": "Personalleitung", "default": "Personalleitung" }, + "ROLE_DPO": { "type": "string", "title": "Datenschutzbeauftragte(r)", "default": "Datenschutzbeauftragte(r) (DSB)" }, + + "DOC_VERSION": { "type": "string", "title": "Version", "default": "1.0" }, + "DOC_DATE": { "type": "string", "title": "Datum", "format": "date" }, + "DOC_STATUS": { "type": "string", "title": "Status", "enum": ["Entwurf", "In Freigabe", "Freigegeben"], "default": "Entwurf" }, + + "TOOL_NAME": { "type": "string", "title": "Name des ISMS-Tools", "default": "das ISMS-Tool" }, + "REVIEW_CYCLE": { "type": "string", "title": "Revisionszyklus (Freitext)", "default": "jährlich" }, + + "TECH_MFA": { "type": "string", "title": "MFA-Lösung", "default": "die eingesetzte MFA-Lösung" }, + "TECH_MALWARE": { "type": "string", "title": "Malware-Schutz-Lösung", "default": "die eingesetzte Endpoint-Schutzlösung" }, + "TECH_BACKUP": { "type": "string", "title": "Backup-Lösung", "default": "die eingesetzte Backup-Lösung" }, + "TECH_SIEM": { "type": "string", "title": "Logging/SIEM-Lösung", "default": "die zentrale Protokollierung" }, + "TECH_MDM": { "type": "string", "title": "MDM-Lösung", "default": "das eingesetzte MDM" }, + "TECH_VPN": { "type": "string", "title": "VPN/Remote-Access-Lösung", "default": "VPN" }, + "TECH_CRYPTO": { "type": "string", "title": "Krypto-Vorgabe/Standard", "default": "aktuelle BSI-/Branchenempfehlungen" }, + + "TOOL_TICKET": { "type": "string", "title": "Ticket-/Workflow-System (Dokumentationsort)", "default": "das Ticketsystem" }, + "TOOL_IAM": { "type": "string", "title": "Verzeichnis-/IAM-System", "default": "das zentrale Verzeichnis (Entra ID / Active Directory)" }, + + "PW_MIN_LENGTH": { "type": "string", "title": "Passwort-Mindestlänge (BL-IAM-01)", "default": "12" }, + "PW_COMPLEXITY": { "type": "string", "title": "Passwort-Komplexität (BL-IAM-01)", "default": "Komplexität aus mind. 3 von 4 Zeichenkategorien" }, + "PW_ROTATION": { "type": "string", "title": "Passwort-Rotation (BL-IAM-01)", "default": "keine feste Zwangsrotation, Wechsel anlassbezogen bei Verdacht" }, + "MFA_SCOPE": { "type": "string", "title": "MFA-Geltungsbereich (BL-IAM-02)", "default": "alle Fernzugriffe, administrative Zugänge und Cloud-Dienste" }, + "SESSION_TIMEOUT": { "type": "string", "title": "Sitzungs-Timeout (BL-IAM-03)", "default": "15 Min. Inaktivität (privilegiert), 8 Std. (Standard)" }, + "ACCOUNT_LOCKOUT": { "type": "string", "title": "Kontosperrung (BL-IAM-04)", "default": "temporäre Sperre nach 10 Fehlversuchen" }, + "RECERT_FREQ": { "type": "string", "title": "Rezertifizierung (BL-IAM-05)", "default": "halbjährlich" }, + "TLS_MIN": { "type": "string", "title": "Mindest-TLS (BL-CRY-01)", "default": "TLS 1.2 (Empfehlung TLS 1.3)" }, + "CRYPTO_ALGO": { "type": "string", "title": "Zulässige Algorithmen (BL-CRY-02)", "default": "AES-256, RSA ≥ 3072 / ECC ≥ 256, SHA-256 oder stärker" }, + "PATCH_SLA_CRIT": { "type": "string", "title": "Patch-SLA kritisch (BL-OPS-01)", "default": "innerhalb von 72 Stunden" }, + "PATCH_SLA_HIGH": { "type": "string", "title": "Patch-SLA hoch (BL-OPS-01)", "default": "innerhalb von 14 Tagen" }, + "PATCH_SLA_STD": { "type": "string", "title": "Patch-SLA standard (BL-OPS-01)", "default": "im regulären monatlichen Patchzyklus" }, + "VULN_SCAN_FREQ": { "type": "string", "title": "Schwachstellenscan (BL-OPS-02)", "default": "monatlich" }, + "MALWARE_UPDATE": { "type": "string", "title": "Malware-Update (BL-OPS-03)", "default": "mehrmals täglich automatisch" }, + "LOG_RETENTION": { "type": "string", "title": "Log-Aufbewahrung (BL-OPS-04)", "default": "90 Tage, risikoabhängig bis 12 Monate" }, + "BACKUP_SCHEME": { "type": "string", "title": "Backup-Schema (BL-OPS-05)", "default": "3-2-1 (3 Kopien, 2 Medien, 1 offline/ausgelagert)" }, + "BACKUP_RETENTION": { "type": "string", "title": "Backup-Aufbewahrung (BL-OPS-05)", "default": "täglich 30 Tage, monatlich 12 Monate" }, + "BACKUP_TEST_FREQ": { "type": "string", "title": "Wiederherstellungstest (BL-OPS-06)", "default": "jährlich" }, + "PENTEST_FREQ": { "type": "string", "title": "Penetrationstest (BL-OPS-08)", "default": "jährlich" }, + + "FLAG_INCLUDE_SHOULD": { "type": "boolean", "title": "SOLL-Anforderungen einbeziehen (Reifegrad 3 = true)", "default": true }, + "FLAG_CLOUD_USED": { "type": "boolean", "title": "Cloud-Dienste im Einsatz", "default": true }, + "FLAG_AI_USED": { "type": "boolean", "title": "KI-/GenAI-Dienste im Einsatz", "default": true }, + "FLAG_OT_USED": { "type": "boolean", "title": "Produktions-/OT-Umgebung vorhanden", "default": false }, + "FLAG_DEV_INHOUSE": { "type": "boolean", "title": "Eigene Software-Entwicklung", "default": false }, + "FLAG_MOBILE_WORK": { "type": "boolean", "title": "Mobiles Arbeiten / Homeoffice zugelassen", "default": true }, + "FLAG_MOBILE_DEVICES": { "type": "boolean", "title": "Mobile Endgeräte / Datenträger im Einsatz", "default": true }, + "FLAG_CRYPTO_PKI": { "type": "boolean", "title": "Eigene PKI / Zertifikatsverwaltung", "default": false }, + "FLAG_EXTERNAL_IT": { "type": "boolean", "title": "Externe IT-Dienstleister genutzt", "default": true }, + "FLAG_PERSONAL_DATA": { "type": "boolean", "title": "Verarbeitung personenbezogener Daten", "default": true }, + "FLAG_CUSTOMER_SYSTEMS": { "type": "boolean", "title": "Zugriff auf Kundensysteme (z.B. OEM)", "default": false } + }, + "required": ["ORG_NAME", "ISMS_SCOPE", "ISMS_SCOPE_DESCRIPTION", "DOC_VERSION", "DOC_DATE"] +} diff --git a/seed/isms-vorlagenpaket-v2/verfahren/VA-02_IT-Notfall-und-Wiederanlaufverfahren.md b/seed/isms-vorlagenpaket-v2/verfahren/VA-02_IT-Notfall-und-Wiederanlaufverfahren.md new file mode 100644 index 0000000..5a5d38a --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/verfahren/VA-02_IT-Notfall-und-Wiederanlaufverfahren.md @@ -0,0 +1,72 @@ +# IT-Notfall- und Wiederanlaufverfahren (BCM) + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Verfahrensanweisung (VA-02) | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Prozessverantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_ISB}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + + +## 1. Zweck + +Dieses Verfahren regelt die Aufrechterhaltung und Wiederherstellung kritischer IT-Dienste bei Ausfall oder Krise. Es operationalisiert die zugehörige Richtlinie ({{LINK:R04}}). + +## 2. Geltungsbereich + +Gilt innerhalb des ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Auslöser + +Ausfall kritischer IT-Dienste, Notfall oder Krisenfall (Eskalation aus VA-01). + +## 4. Eingaben + +- Liste kritischer IT-Dienste mit RTO/RPO +- Wiederanlaufpläne +- Backup-Status (VA-05) + +## 5. Ablauf + +1. Notfall feststellen & einstufen: Ausmaß bewerten, ggf. Krisenstab einberufen. +2. Kommunikation aktivieren: Interne/externe Stakeholder informieren. +3. Wiederanlauf priorisieren: Dienste nach RTO/RPO in Reihenfolge bringen. +4. Wiederherstellung durchführen: Systeme/Daten aus Backup (VA-05) wiederherstellen. +5. Rückkehr zum Normalbetrieb bestätigen & dokumentieren. +6. Nachbereitung & Test-Update: Plan aktualisieren, {{BACKUP_TEST_FREQ}} üben. + +## 6. RACI + +| # | Schritt | R (Durchführung) | A (Rechenschaft) | C (Konsultiert) | I (Informiert) | +|---|---------|------------------|------------------|-----------------|----------------| +| 1 | Notfall feststellen & einstufen | {{ROLE_IT_LEAD}} | {{ROLE_MANAGEMENT}} | {{ROLE_ISB}} | - | +| 2 | Kommunikation aktivieren | {{ROLE_ISB}} | {{ROLE_MANAGEMENT}} | - | Mitarbeitende | +| 3 | Wiederanlauf priorisieren | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | +| 4 | Wiederherstellung durchführen | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | - | - | +| 5 | Rückkehr zum Normalbetrieb bestätigen & | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | {{ROLE_MANAGEMENT}} | +| 6 | Nachbereitung & Test-Update | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | + +## 7. Ergebnis & Nachweis + +Wiederhergestellte Dienste; dokumentierter Notfall/Test im ISMS-Tool ({{TOOL_NAME}}); aktualisierte Wiederanlaufpläne. Nachweise werden im zentralen Nachweisregister ({{LINK:NACHWEISREGISTER}}) referenziert. + +## 8. Kennzahlen (KPI) + +- Einhaltung RTO/RPO +- Erfolgsquote Wiederherstellungstests +- Aktualität der Notfallpläne + +## 9. Verwandte Dokumente + +- Zugehörige Richtlinie: {{LINK:R04}} +- {{LINK:VA-01}} +- {{LINK:VA-05}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} + + diff --git a/seed/isms-vorlagenpaket-v2/verfahren/VA-03_Berechtigungsverfahren.md b/seed/isms-vorlagenpaket-v2/verfahren/VA-03_Berechtigungsverfahren.md new file mode 100644 index 0000000..95e460d --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/verfahren/VA-03_Berechtigungsverfahren.md @@ -0,0 +1,71 @@ +# Berechtigungsverfahren (Joiner/Mover/Leaver und Rezertifizierung) + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Verfahrensanweisung (VA-03) | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Prozessverantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_ISB}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + + +## 1. Zweck + +Dieses Verfahren regelt Beantragung, Genehmigung, Änderung, Entzug und regelmäßige Überprüfung von Zugriffsrechten. Es operationalisiert die zugehörige Richtlinie ({{LINK:R08}}). + +## 2. Geltungsbereich + +Gilt innerhalb des ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Auslöser + +Eintritt, Rollenwechsel oder Austritt einer Person; Berechtigungsantrag; fällige Rezertifizierung. + +## 4. Eingaben + +- Personalmeldung (HR) +- Rollen-/Rechtekatalog (RBAC) +- Bestehende Berechtigungen aus {{TOOL_IAM}} + +## 5. Ablauf + +1. Antrag erfassen: Zugang/Recht im {{TOOL_TICKET}} beantragen (Joiner/Mover). +2. Fachliche Genehmigung: Erforderlichkeit nach Minimalprinzip prüfen und freigeben. +3. Umsetzung: Rechte rollenbasiert in {{TOOL_IAM}} setzen. +4. Leaver/Änderung: Bei Austritt/Wechsel Rechte unverzüglich entziehen/anpassen. +5. Rezertifizierung ({{RECERT_FREQ}}, BL-IAM-05): Owner bestätigen/entziehen Rechte. +6. Privilegierte Konten: gesondert prüfen und protokollieren (BL-IAM-06). + +## 6. RACI + +| # | Schritt | R (Durchführung) | A (Rechenschaft) | C (Konsultiert) | I (Informiert) | +|---|---------|------------------|------------------|-----------------|----------------| +| 1 | Antrag erfassen | Vorgesetzte/Fachbereich | {{ROLE_IT_LEAD}} | - | - | +| 2 | Fachliche Genehmigung | Fachbereich/Dateneigentümer | Fachbereich/Dateneigentümer | {{ROLE_ISB}} | - | +| 3 | Umsetzung | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | - | Antragsteller | +| 4 | Leaver/Änderung | {{ROLE_IT_LEAD}} | {{ROLE_HR_LEAD}} | - | - | +| 5 | Rezertifizierung ({{RECERT_FREQ}}, BL-IAM-05) | Fachbereich/Dateneigentümer | {{ROLE_ISB}} | {{ROLE_IT_LEAD}} | - | +| 6 | Privilegierte Konten | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | + +## 7. Ergebnis & Nachweis + +Dokumentierte Anträge/Genehmigungen im {{TOOL_TICKET}}; aktueller Berechtigungsstand in {{TOOL_IAM}}; Rezertifizierungsnachweis. Nachweise werden im zentralen Nachweisregister ({{LINK:NACHWEISREGISTER}}) referenziert. + +## 8. Kennzahlen (KPI) + +- Anteil fristgerecht entzogener Leaver-Rechte +- Rezertifizierungsquote +- Zahl verwaister/privilegierter Konten + +## 9. Verwandte Dokumente + +- Zugehörige Richtlinie: {{LINK:R08}} +- {{LINK:VA-01}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} + + diff --git a/seed/isms-vorlagenpaket-v2/verfahren/VA-04_Change-und-Patch-Management-Verfahren.md b/seed/isms-vorlagenpaket-v2/verfahren/VA-04_Change-und-Patch-Management-Verfahren.md new file mode 100644 index 0000000..d8a4f75 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/verfahren/VA-04_Change-und-Patch-Management-Verfahren.md @@ -0,0 +1,71 @@ +# Change- und Patch-Management-Verfahren + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Verfahrensanweisung (VA-04) | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Prozessverantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_ISB}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + + +## 1. Zweck + +Dieses Verfahren regelt geplante Änderungen an IT-Systemen sowie das risikoorientierte Einspielen von Patches. Es operationalisiert die zugehörige Richtlinie ({{LINK:R10}}). + +## 2. Geltungsbereich + +Gilt innerhalb des ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Auslöser + +Änderungsbedarf, verfügbarer Patch oder identifizierte Schwachstelle (VA-06). + +## 4. Eingaben + +- Change-/Patch-Antrag +- Risikoeinschätzung +- Patch-SLA (BL-OPS-01) + +## 5. Ablauf + +1. Change beantragen & klassifizieren (Standard/Normal/Notfall) im {{TOOL_TICKET}}. +2. Risiko-/Auswirkungsbewertung inkl. Rollback-Plan. +3. Genehmigung durch CAB/verantwortliche Rolle. +4. Test in getrennter Umgebung (BL-OPS, R10). +5. Umsetzung in Produktion gemäß Patch-SLA (kritisch {{PATCH_SLA_CRIT}}). +6. Verifikation & Dokumentation des Ergebnisses im {{TOOL_TICKET}}. + +## 6. RACI + +| # | Schritt | R (Durchführung) | A (Rechenschaft) | C (Konsultiert) | I (Informiert) | +|---|---------|------------------|------------------|-----------------|----------------| +| 1 | Change beantragen & klassifizieren (Stan | Antragsteller | {{ROLE_IT_LEAD}} | - | - | +| 2 | Risiko-/Auswirkungsbewertung inkl. Rollb | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | +| 3 | Genehmigung durch CAB/verantwortliche Ro | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | +| 4 | Test in getrennter Umgebung (BL-OPS, R10 | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | - | - | +| 5 | Umsetzung in Produktion gemäß Patch-SLA | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | - | Betroffene | +| 6 | Verifikation & Dokumentation des Ergebni | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | + +## 7. Ergebnis & Nachweis + +Dokumentierte, genehmigte und verifizierte Änderung/Patch im {{TOOL_TICKET}}. Nachweise werden im zentralen Nachweisregister ({{LINK:NACHWEISREGISTER}}) referenziert. + +## 8. Kennzahlen (KPI) + +- Patch-Compliance je Kritikalität +- Anteil erfolgreicher Changes (ohne Rollback) +- Durchlaufzeit kritischer Patches + +## 9. Verwandte Dokumente + +- Zugehörige Richtlinie: {{LINK:R10}} +- {{LINK:VA-06}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} + + diff --git a/seed/isms-vorlagenpaket-v2/verfahren/VA-06_Schwachstellenmanagement-Verfahren.md b/seed/isms-vorlagenpaket-v2/verfahren/VA-06_Schwachstellenmanagement-Verfahren.md new file mode 100644 index 0000000..6068138 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/verfahren/VA-06_Schwachstellenmanagement-Verfahren.md @@ -0,0 +1,69 @@ +# Schwachstellenmanagement-Verfahren + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Verfahrensanweisung (VA-06) | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Prozessverantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_ISB}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + + +## 1. Zweck + +Dieses Verfahren regelt Erkennung, Bewertung, Behandlung und technische Prüfung von Schwachstellen. Es operationalisiert die zugehörige Richtlinie ({{LINK:R10}}). + +## 2. Geltungsbereich + +Gilt innerhalb des ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Auslöser + +Regelmäßiger Scan ({{VULN_SCAN_FREQ}}), Sicherheitsmeldung/CVE, Penetrationstest ({{PENTEST_FREQ}}). + +## 4. Eingaben + +- Scan-/Testberichte +- Asset-Inventar & Kritikalität +- Patch-SLA (BL-OPS-01) + +## 5. Ablauf + +1. Identifikation: Schwachstellen-Scan {{VULN_SCAN_FREQ}} (BL-OPS-02) und Meldungen auswerten. +2. Bewertung & Priorisierung nach Kritikalität und Exponierung. +3. Behandlung anstoßen: Patch/Change (VA-04) oder kompensierende Maßnahme. +4. Technische Prüfung: Härtung (BL-OPS-07) und Penetrationstests ({{PENTEST_FREQ}}, BL-OPS-08). +5. Nachverfolgung & Verifikation der Behebung im {{TOOL_TICKET}}. + +## 6. RACI + +| # | Schritt | R (Durchführung) | A (Rechenschaft) | C (Konsultiert) | I (Informiert) | +|---|---------|------------------|------------------|-----------------|----------------| +| 1 | Identifikation | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | - | - | +| 2 | Bewertung & Priorisierung nach Kritikali | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | +| 3 | Behandlung anstoßen | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | +| 4 | Technische Prüfung | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | Externer Dienstleister | - | +| 5 | Nachverfolgung & Verifikation der Behebu | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | + +## 7. Ergebnis & Nachweis + +Nachverfolgte Schwachstellen mit Behandlungsstatus im {{TOOL_TICKET}}; Testberichte. Nachweise werden im zentralen Nachweisregister ({{LINK:NACHWEISREGISTER}}) referenziert. + +## 8. Kennzahlen (KPI) + +- Mittlere Behebungszeit je Kritikalität +- Offene kritische Schwachstellen +- Scan-Abdeckung + +## 9. Verwandte Dokumente + +- Zugehörige Richtlinie: {{LINK:R10}} +- {{LINK:VA-04}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} + + diff --git a/seed/isms-vorlagenpaket-v2/verfahren/VA-07_Kryptokonzept-und-Schluesselverwaltung.md b/seed/isms-vorlagenpaket-v2/verfahren/VA-07_Kryptokonzept-und-Schluesselverwaltung.md new file mode 100644 index 0000000..238ad14 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/verfahren/VA-07_Kryptokonzept-und-Schluesselverwaltung.md @@ -0,0 +1,69 @@ +# Kryptokonzept und Schlüsselverwaltung + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Verfahrensanweisung (VA-07) | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Prozessverantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_ISB}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + + +## 1. Zweck + +Dieses Verfahren regelt den Einsatz kryptografischer Verfahren und die Verwaltung von Schlüsseln über den Lebenszyklus. Es operationalisiert die zugehörige Richtlinie ({{LINK:R09}}). + +## 2. Geltungsbereich + +Gilt innerhalb des ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Auslöser + +Neuer Bedarf an Verschlüsselung/Zertifikaten; Schlüsselerneuerung/-sperrung; Änderung des Stands der Technik. + +## 4. Eingaben + +- Zulässige Algorithmen (BL-CRY-02) +- Schutzbedarf der Daten +- Zertifikats-/Schlüsselbestand + +## 5. Ablauf + +1. Bedarf & Verfahren festlegen: zulässige Algorithmen {{CRYPTO_ALGO}} (BL-CRY-02) wählen. +2. Schlüssel/Zertifikate erzeugen und sicher verteilen (BL-CRY-05). +3. Speicherung & Zugriffsschutz (getrennte Aufbewahrung, {{#if FLAG_CRYPTO_PKI}}PKI, {{/if}}Berechtigungen). +4. Übertragungsschutz sicherstellen: mindestens {{TLS_MIN}} (BL-CRY-01). +5. Erneuerung/Sperrung/Vernichtung dokumentieren. + +## 6. RACI + +| # | Schritt | R (Durchführung) | A (Rechenschaft) | C (Konsultiert) | I (Informiert) | +|---|---------|------------------|------------------|-----------------|----------------| +| 1 | Bedarf & Verfahren festlegen | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | +| 2 | Schlüssel/Zertifikate erzeugen und siche | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | - | - | +| 3 | Speicherung & Zugriffsschutz (getrennte | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | +| 4 | Übertragungsschutz sicherstellen | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | - | - | +| 5 | Erneuerung/Sperrung/Vernichtung dokument | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | + +## 7. Ergebnis & Nachweis + +Dokumentiertes Kryptokonzept; nachvollziehbarer Schlüssel-/Zertifikatslebenszyklus. Nachweise werden im zentralen Nachweisregister ({{LINK:NACHWEISREGISTER}}) referenziert. + +## 8. Kennzahlen (KPI) + +- Anteil konformer Verfahren/Algorithmen +- Ablaufende Zertifikate ohne Erneuerung +- Abdeckung Transportverschlüsselung + +## 9. Verwandte Dokumente + +- Zugehörige Richtlinie: {{LINK:R09}} +- {{LINK:VA-04}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} + + diff --git a/seed/isms-vorlagenpaket-v2/verfahren/VA-08_Asset-und-Klassifizierungsverfahren.md b/seed/isms-vorlagenpaket-v2/verfahren/VA-08_Asset-und-Klassifizierungsverfahren.md new file mode 100644 index 0000000..b18100e --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/verfahren/VA-08_Asset-und-Klassifizierungsverfahren.md @@ -0,0 +1,69 @@ +# Asset- und Klassifizierungsverfahren + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Verfahrensanweisung (VA-08) | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Prozessverantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_ISB}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + + +## 1. Zweck + +Dieses Verfahren regelt Erfassung, Owner-Zuordnung, Klassifizierung und Pflege von Informationswerten und Assets. Es operationalisiert die zugehörige Richtlinie ({{LINK:R02}}). + +## 2. Geltungsbereich + +Gilt innerhalb des ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Auslöser + +Neues/geändertes Asset; Beschaffung; regelmäßige Inventurprüfung. + +## 4. Eingaben + +- Beschaffungs-/Änderungsmeldung +- Klassifizierungsschema +- Asset-Inventar ({{TOOL_NAME}}) + +## 5. Ablauf + +1. Asset erfassen im Inventar ({{TOOL_NAME}}) mit Attributen. +2. Owner zuordnen. +3. Klassifizieren (Vertraulichkeit/Integrität/Verfügbarkeit) durch Owner. +4. Handhabungsvorgaben je Schutzklasse anwenden (Kennzeichnung/Speicherung/Löschung BL-DEL-01). +5. Pflege & Review ({{REVIEW_CYCLE}}) auf Aktualität. + +## 6. RACI + +| # | Schritt | R (Durchführung) | A (Rechenschaft) | C (Konsultiert) | I (Informiert) | +|---|---------|------------------|------------------|-----------------|----------------| +| 1 | Asset erfassen im Inventar ({{TOOL_NAME}}) | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | - | - | +| 2 | Owner zuordnen. | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | Asset Owner | +| 3 | Klassifizieren (Vertraulichkeit/Integrit | Asset Owner | Asset Owner | {{ROLE_ISB}} | - | +| 4 | Handhabungsvorgaben je Schutzklasse anwe | Asset Owner | {{ROLE_ISB}} | - | Mitarbeitende | +| 5 | Pflege & Review ({{REVIEW_CYCLE}}) auf A | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | + +## 7. Ergebnis & Nachweis + +Aktuelles, klassifiziertes Asset-Inventar im ISMS-Tool ({{TOOL_NAME}}). Nachweise werden im zentralen Nachweisregister ({{LINK:NACHWEISREGISTER}}) referenziert. + +## 8. Kennzahlen (KPI) + +- Inventar-Abdeckung +- Anteil klassifizierter Assets +- Assets ohne Owner + +## 9. Verwandte Dokumente + +- Zugehörige Richtlinie: {{LINK:R02}} +- {{LINK:VA-03}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} + + diff --git a/seed/isms-vorlagenpaket-v2/verfahren/VA-09_Risikomanagement-Verfahren.md b/seed/isms-vorlagenpaket-v2/verfahren/VA-09_Risikomanagement-Verfahren.md new file mode 100644 index 0000000..dbf8039 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/verfahren/VA-09_Risikomanagement-Verfahren.md @@ -0,0 +1,69 @@ +# Risikomanagement-Verfahren + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Verfahrensanweisung (VA-09) | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Prozessverantwortlich | {{ROLE_ISB}} | +| Freigabe durch | {{ROLE_ISB}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + + +## 1. Zweck + +Dieses Verfahren regelt Identifikation, Analyse, Bewertung, Behandlung und Überwachung von Informationssicherheitsrisiken. Es operationalisiert die zugehörige Richtlinie ({{LINK:R03}}). + +## 2. Geltungsbereich + +Gilt innerhalb des ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Auslöser + +Neues System/Projekt, Vorfall, Änderung, regelmäßiger Review-Zyklus. + +## 4. Eingaben + +- Asset-/Prozessliste +- Bewertungsskalen & Akzeptanzschwellen +- Bestehendes Risikoregister + +## 5. Ablauf + +1. Risiken identifizieren (Assets, Bedrohungen, Schwachstellen). +2. Analysieren & bewerten (Eintritt × Schadenshöhe) im ISMS-Tool ({{TOOL_NAME}}). +3. Behandlung festlegen (reduzieren/vermeiden/übertragen/akzeptieren) und Maßnahmen planen. +4. Restrisiko-Akzeptanz dokumentieren. +5. Überwachen & aktualisieren ({{REVIEW_CYCLE}} und anlassbezogen). + +## 6. RACI + +| # | Schritt | R (Durchführung) | A (Rechenschaft) | C (Konsultiert) | I (Informiert) | +|---|---------|------------------|------------------|-----------------|----------------| +| 1 | Risiken identifizieren (Assets, Bedrohun | {{ROLE_ISB}} | {{ROLE_ISB}} | Asset/Prozessverantwortliche | - | +| 2 | Analysieren & bewerten (Eintritt × Schad | {{ROLE_ISB}} | {{ROLE_ISB}} | {{ROLE_IT_LEAD}} | - | +| 3 | Behandlung festlegen (reduzieren/vermeid | {{ROLE_ISB}} | {{ROLE_MANAGEMENT}} | Fachbereich | - | +| 4 | Restrisiko-Akzeptanz dokumentieren. | {{ROLE_MANAGEMENT}} | {{ROLE_MANAGEMENT}} | {{ROLE_ISB}} | - | +| 5 | Überwachen & aktualisieren ({{REVIEW_CYCLE}}) | {{ROLE_ISB}} | {{ROLE_ISB}} | - | - | + +## 7. Ergebnis & Nachweis + +Gepflegtes Risikoregister mit Behandlungsplan und Akzeptanzentscheidungen im ISMS-Tool ({{TOOL_NAME}}). Nachweise werden im zentralen Nachweisregister ({{LINK:NACHWEISREGISTER}}) referenziert. + +## 8. Kennzahlen (KPI) + +- Anteil behandelter Risiken +- Überfällige Maßnahmen +- Aktualität des Risikoregisters + +## 9. Verwandte Dokumente + +- Zugehörige Richtlinie: {{LINK:R03}} +- {{LINK:VA-01}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} + + diff --git a/seed/isms-vorlagenpaket-v2/verfahren/VA-10_Lieferanten-Onboarding-und-Bewertung.md b/seed/isms-vorlagenpaket-v2/verfahren/VA-10_Lieferanten-Onboarding-und-Bewertung.md new file mode 100644 index 0000000..58045cd --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/verfahren/VA-10_Lieferanten-Onboarding-und-Bewertung.md @@ -0,0 +1,69 @@ +# Lieferanten-Onboarding- und Bewertungsverfahren + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Verfahrensanweisung (VA-10) | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Prozessverantwortlich | {{ROLE_ISB}} | +| Freigabe durch | {{ROLE_ISB}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + + +## 1. Zweck + +Dieses Verfahren regelt Auswahl, sicherheitsbezogene Bewertung, vertragliche Bindung und Überwachung von Lieferanten/Dienstleistern. Es operationalisiert die zugehörige Richtlinie ({{LINK:R13}}). + +## 2. Geltungsbereich + +Gilt innerhalb des ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Auslöser + +Neuer Lieferant/Dienstleister mit Zugriff auf Informationen; Vertragsverlängerung; periodische Überprüfung. + +## 4. Eingaben + +- Leistungs-/Schutzbedarfsbeschreibung +- Risikoklassen (BL-SUP-01) +- NDA-/Vertragsvorlagen + +## 5. Ablauf + +1. Bedarf & Risikoklasse bestimmen (Schutzbedarf, Zugriff). +2. Sicherheitsbewertung (Selbstauskunft/Nachweise/TISAX) durchführen. +3. NDA & vertragliche Sicherheitsanforderungen vereinbaren. +4. Verantwortlichkeiten abgrenzen (Betrieb/Sicherheit/Meldung). +5. Ins Lieferantenverzeichnis ({{TOOL_NAME}}) aufnehmen und {{REVIEW_CYCLE}} überprüfen. + +## 6. RACI + +| # | Schritt | R (Durchführung) | A (Rechenschaft) | C (Konsultiert) | I (Informiert) | +|---|---------|------------------|------------------|-----------------|----------------| +| 1 | Bedarf & Risikoklasse bestimmen (Schutzb | Einkauf/Fachbereich | {{ROLE_ISB}} | - | - | +| 2 | Sicherheitsbewertung (Selbstauskunft/Nac | {{ROLE_ISB}} | {{ROLE_ISB}} | Fachbereich | - | +| 3 | NDA & vertragliche Sicherheitsanforderun | Einkauf | {{ROLE_MANAGEMENT}} | {{ROLE_ISB}} | - | +| 4 | Verantwortlichkeiten abgrenzen (Betrieb/ | {{ROLE_ISB}} | {{ROLE_ISB}} | {{ROLE_IT_LEAD}} | - | +| 5 | Ins Lieferantenverzeichnis ({{TOOL_NAME}}) | {{ROLE_ISB}} | {{ROLE_ISB}} | - | - | + +## 7. Ergebnis & Nachweis + +Bewerteter, vertraglich gebundener Lieferant im Lieferantenverzeichnis ({{TOOL_NAME}}); NDA hinterlegt. Nachweise werden im zentralen Nachweisregister ({{LINK:NACHWEISREGISTER}}) referenziert. + +## 8. Kennzahlen (KPI) + +- Anteil bewerteter Lieferanten +- NDA-Abdeckung +- Überfällige Lieferantenprüfungen + +## 9. Verwandte Dokumente + +- Zugehörige Richtlinie: {{LINK:R13}} +- {{LINK:VA-11}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} + + diff --git a/seed/isms-vorlagenpaket-v2/verfahren/VA-11_Cloud-und-KI-Freigabeverfahren.md b/seed/isms-vorlagenpaket-v2/verfahren/VA-11_Cloud-und-KI-Freigabeverfahren.md new file mode 100644 index 0000000..d4225c4 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/verfahren/VA-11_Cloud-und-KI-Freigabeverfahren.md @@ -0,0 +1,69 @@ +# Cloud- und KI-Freigabeverfahren + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Verfahrensanweisung (VA-11) | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Prozessverantwortlich | {{ROLE_ISB}} | +| Freigabe durch | {{ROLE_ISB}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + + +## 1. Zweck + +Dieses Verfahren regelt Bewertung und Freigabe von Cloud- und KI-/GenAI-Diensten sowie die zulässige Nutzung. Es operationalisiert die zugehörige Richtlinie ({{LINK:R12}}). + +## 2. Geltungsbereich + +Gilt innerhalb des ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Auslöser + +Antrag zur Nutzung eines Cloud- oder KI-Dienstes. + +## 4. Eingaben + +- Dienstbeschreibung & Anbieterinfos +- Schutzbedarf/Datenklassen +- Vertrags-/DPA-Unterlagen + +## 5. Ablauf + +1. Antrag erfassen im {{TOOL_TICKET}} (Dienst, Zweck, Datenklassen). +2. Bewertung: Schutzbedarf, Datenlokation/EU, Mandantentrennung, Exit; bei KI Trainings-/Weitergabe-Ausschluss. +3. Vertrag/DPA prüfen (bei KI: Opt-out/Enterprise-Vertrag, EU AI Act). +4. Freigabe & Aufnahme in die Freigabeliste ({{TOOL_NAME}}); zulässige Datenklassen festlegen. +5. Nutzung & Kontrolle: Human-in-the-Loop bei KI, periodische Überprüfung ({{REVIEW_CYCLE}}). + +## 6. RACI + +| # | Schritt | R (Durchführung) | A (Rechenschaft) | C (Konsultiert) | I (Informiert) | +|---|---------|------------------|------------------|-----------------|----------------| +| 1 | Antrag erfassen im {{TOOL_TICKET}} (Dien | Antragsteller/Fachbereich | {{ROLE_ISB}} | - | - | +| 2 | Bewertung | {{ROLE_ISB}} | {{ROLE_ISB}} | {{ROLE_IT_LEAD}} | {{ROLE_DPO}} | +| 3 | Vertrag/DPA prüfen (bei KI | {{ROLE_ISB}} | {{ROLE_MANAGEMENT}} | {{ROLE_DPO}} | - | +| 4 | Freigabe & Aufnahme in die Freigabeliste | {{ROLE_ISB}} | {{ROLE_ISB}} | - | Fachbereich | +| 5 | Nutzung & Kontrolle | Fachbereich | {{ROLE_ISB}} | - | - | + +## 7. Ergebnis & Nachweis + +Freigabeentscheidung und Freigabeliste im ISMS-Tool ({{TOOL_NAME}}); dokumentierte zulässige Datenklassen. Nachweise werden im zentralen Nachweisregister ({{LINK:NACHWEISREGISTER}}) referenziert. + +## 8. Kennzahlen (KPI) + +- Anteil freigegebener vs. genutzter Dienste +- Schatten-IT-Funde +- Überfällige Dienst-Reviews + +## 9. Verwandte Dokumente + +- Zugehörige Richtlinie: {{LINK:R12}} +- {{LINK:VA-10}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} + + diff --git a/seed/isms-vorlagenpaket-v2/verfahren/VA-12_Awareness-und-Schulungsverfahren.md b/seed/isms-vorlagenpaket-v2/verfahren/VA-12_Awareness-und-Schulungsverfahren.md new file mode 100644 index 0000000..0e9cb7a --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/verfahren/VA-12_Awareness-und-Schulungsverfahren.md @@ -0,0 +1,69 @@ +# Awareness- und Schulungsverfahren + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Verfahrensanweisung (VA-12) | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Prozessverantwortlich | {{ROLE_ISB}} | +| Freigabe durch | {{ROLE_ISB}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + + +## 1. Zweck + +Dieses Verfahren regelt Planung, Durchführung und Nachweis von Sensibilisierung und Schulung zur Informationssicherheit. Es operationalisiert die zugehörige Richtlinie ({{LINK:R05}}). + +## 2. Geltungsbereich + +Gilt innerhalb des ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Auslöser + +Eintritt neuer Mitarbeitender; jährlicher Schulungszyklus; anlassbezogen nach Vorfällen. + +## 4. Eingaben + +- Schulungsplan/Curriculum (BL-HR-01) +- Zielgruppen/Rollen +- Teilnahmestatus ({{TOOL_NAME}}) + +## 5. Ablauf + +1. Schulungsbedarf & Zielgruppen planen (rollenspezifisch). +2. Onboarding-Schulung bei Eintritt durchführen. +3. Regelmäßige Schulung ({{REVIEW_CYCLE}}, BL-HR-01) durchführen. +4. Wirksamkeit prüfen (Phishing-Simulation) und nachschulen. +5. Teilnahme nachweisen im ISMS-Tool ({{TOOL_NAME}}). + +## 6. RACI + +| # | Schritt | R (Durchführung) | A (Rechenschaft) | C (Konsultiert) | I (Informiert) | +|---|---------|------------------|------------------|-----------------|----------------| +| 1 | Schulungsbedarf & Zielgruppen planen (ro | {{ROLE_ISB}} | {{ROLE_ISB}} | {{ROLE_HR_LEAD}} | - | +| 2 | Onboarding-Schulung bei Eintritt durchfü | {{ROLE_HR_LEAD}} | {{ROLE_ISB}} | - | Mitarbeitende | +| 3 | Regelmäßige Schulung ({{REVIEW_CYCLE}}, | {{ROLE_ISB}} | {{ROLE_ISB}} | - | Mitarbeitende | +| 4 | Wirksamkeit prüfen (Phishing-Simulation) | {{ROLE_ISB}} | {{ROLE_ISB}} | {{ROLE_IT_LEAD}} | - | +| 5 | Teilnahme nachweisen im ISMS-Tool ({{TOOL_NAME}}) | {{ROLE_HR_LEAD}} | {{ROLE_ISB}} | - | - | + +## 7. Ergebnis & Nachweis + +Dokumentierte Schulungsteilnahme und Wirksamkeitsmessung im ISMS-Tool ({{TOOL_NAME}}). Nachweise werden im zentralen Nachweisregister ({{LINK:NACHWEISREGISTER}}) referenziert. + +## 8. Kennzahlen (KPI) + +- Schulungsquote +- Phishing-Klickrate +- Anteil rollenspezifischer Schulungen + +## 9. Verwandte Dokumente + +- Zugehörige Richtlinie: {{LINK:R05}} +- {{LINK:VA-01}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} + + diff --git a/seed/isms-vorlagenpaket-v2/verfahren/VA-13_Logging-und-Monitoring-Verfahren.md b/seed/isms-vorlagenpaket-v2/verfahren/VA-13_Logging-und-Monitoring-Verfahren.md new file mode 100644 index 0000000..8695b31 --- /dev/null +++ b/seed/isms-vorlagenpaket-v2/verfahren/VA-13_Logging-und-Monitoring-Verfahren.md @@ -0,0 +1,69 @@ +# Logging- und Monitoring-Verfahren + +| Dokumenteninformation | Wert | +|-----------------------|------| +| Dokumententyp | Verfahrensanweisung (VA-13) | +| Geltungsbereich | {{ISMS_SCOPE}} | +| Organisation | {{ORG_NAME}} | +| Prozessverantwortlich | {{ROLE_IT_LEAD}} | +| Freigabe durch | {{ROLE_ISB}} | +| Version | {{DOC_VERSION}} | +| Datum | {{DOC_DATE}} | +| Status | {{DOC_STATUS}} | + + + +## 1. Zweck + +Dieses Verfahren regelt Erhebung, Schutz, Auswertung und Aufbewahrung sicherheitsrelevanter Protokolldaten. Es operationalisiert die zugehörige Richtlinie ({{LINK:R10}}). + +## 2. Geltungsbereich + +Gilt innerhalb des ISMS-Geltungsbereichs ({{ISMS_SCOPE_DESCRIPTION}}). + +## 3. Auslöser + +Kontinuierlicher Betrieb; sicherheitsrelevantes Ereignis; Alarm aus {{TECH_SIEM}}. + +## 4. Eingaben + +- Log-Quellen/Systeme +- Aufbewahrungsvorgaben (BL-OPS-04) +- Alarmierungsregeln + +## 5. Ablauf + +1. Log-Quellen anbinden und zentral in {{TECH_SIEM}} erfassen (BL-OPS-04). +2. Manipulationsschutz & Aufbewahrung {{LOG_RETENTION}} sicherstellen. +3. Auswertung & Alarmierung: Regeln pflegen, Auffälligkeiten prüfen. +4. Verdachtsfall an Incident-Response (VA-01) übergeben. +5. Regelmäßige Überprüfung der Abdeckung und Regeln. + +## 6. RACI + +| # | Schritt | R (Durchführung) | A (Rechenschaft) | C (Konsultiert) | I (Informiert) | +|---|---------|------------------|------------------|-----------------|----------------| +| 1 | Log-Quellen anbinden und zentral in {{TECH_SIEM}} | {{ROLE_IT_LEAD}} | {{ROLE_IT_LEAD}} | - | - | +| 2 | Manipulationsschutz & Aufbewahrung {{LOG_RETENTION}} | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | +| 3 | Auswertung & Alarmierung | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | +| 4 | Verdachtsfall an Incident-Response (VA-0 | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | +| 5 | Regelmäßige Überprüfung der Abdeckung un | {{ROLE_IT_LEAD}} | {{ROLE_ISB}} | - | - | + +## 7. Ergebnis & Nachweis + +Zentrale, geschützte Protokollierung mit Auswertung; Nachweis im ISMS-Tool ({{TOOL_NAME}}). Nachweise werden im zentralen Nachweisregister ({{LINK:NACHWEISREGISTER}}) referenziert. + +## 8. Kennzahlen (KPI) + +- Log-Quellen-Abdeckung +- Mittlere Zeit bis Alarmreaktion +- Anteil auswertbarer Ereignisse + +## 9. Verwandte Dokumente + +- Zugehörige Richtlinie: {{LINK:R10}} +- {{LINK:VA-01}} +- Technische Sicherheits-Baseline: {{LINK:BASELINE}} +- ISA-Mapping-Matrix: {{LINK:ISA_MAPPING}} + + diff --git a/src/app/(app)/layout.tsx b/src/app/(app)/layout.tsx index 1d206b2..58515fa 100644 --- a/src/app/(app)/layout.tsx +++ b/src/app/(app)/layout.tsx @@ -39,7 +39,7 @@ export default async function AppLayout({ { href: "/soa", label: t("soa"), icon: ClipboardCheck, enabled: false }, { href: "/measures", label: t("measures"), icon: KanbanSquare, enabled: true }, { href: "/incidents", label: t("incidents"), icon: Siren, enabled: false }, - { href: "/policies", label: t("policies"), icon: BookOpenText, enabled: false }, + { href: "/policies", label: t("policies"), icon: BookOpenText, enabled: true }, { href: "/chat", label: t("chat"), icon: MessagesSquare, enabled: false }, { href: "/dependencies", label: t("dependencies"), icon: Network, enabled: true }, { href: "/evidence", label: t("evidence"), icon: FolderCheck, enabled: false }, diff --git a/src/app/(app)/policies/page.tsx b/src/app/(app)/policies/page.tsx new file mode 100644 index 0000000..3b4d06c --- /dev/null +++ b/src/app/(app)/policies/page.tsx @@ -0,0 +1,233 @@ +import Link from "next/link"; +import { getTranslations } from "next-intl/server"; +import { requireSession } from "@/server/auth"; +import { dbForTenant } from "@/server/db"; +import { requirePermission } from "@/server/rbac"; +import { PageHead, Pill, Tag, KpiCard } from "@/components/mockup-ui"; +import { FilterTabs } from "@/components/filter-tabs"; +import { PolicyReadModal } from "@/components/policy-modals"; +import { + Table, + TableBody, + TableCell, + TableHead, + TableHeader, + TableRow, +} from "@/components/ui/table"; + +const DOC_TYPES = ["LEITLINIE", "RICHTLINIE", "VERFAHREN", "REGISTER"] as const; +const TYPE_LABEL: Record = { + LEITLINIE: "Leitlinie", + RICHTLINIE: "Richtlinie", + VERFAHREN: "Verfahren", + REGISTER: "Register", + HANDBUCH: "Handbuch", + EIGENES: "Eigenes", +}; +const STATUS_TONE: Record = { + FREIGEGEBEN: "ok", + IN_FREIGABE: "info", + ENTWURF: "warn", + ARCHIVIERT: "mut", +}; +const STATUS_LABEL: Record = { + FREIGEGEBEN: "Freigegeben", + IN_FREIGABE: "In Freigabe", + ENTWURF: "Entwurf", + ARCHIVIERT: "Archiviert", +}; + +export default async function PoliciesPage({ + searchParams, +}: { + searchParams: Promise<{ type?: string; q?: string; doc?: string; view?: string }>; +}) { + const session = await requireSession(); + requirePermission(session, "policy:read"); + const t = await getTranslations("policies"); + const db = dbForTenant(session.user.tenantId); + const params = await searchParams; + + const [docs, requirements] = await Promise.all([ + db.policyDocument.findMany({ orderBy: { orderIdx: "asc" } }), + db.policyRequirement.findMany({ orderBy: [{ control: "asc" }, { reqId: "asc" }] }), + ]); + + // Ableitung: je Richtlinie ihre Controls + operationalisierende Verfahren + const byPolicy = new Map; vas: Set }>(); + for (const r of requirements) { + if (!byPolicy.has(r.policyCode)) byPolicy.set(r.policyCode, { controls: new Set(), vas: new Set() }); + const e = byPolicy.get(r.policyCode)!; + e.controls.add(r.control); + r.vaCodes.forEach((v) => e.vas.add(v)); + } + + /* ── Modal (Lesemodus) ── */ + const modalDoc = params.doc ? docs.find((d) => d.code === params.doc) : null; + const modalData = modalDoc + ? { + doc: modalDoc, + variables: await db.policyVariable.findMany({ orderBy: { orderIdx: "asc" } }), + controls: [...(byPolicy.get(modalDoc.code)?.controls ?? [])].sort(), + relatedVas: [...(byPolicy.get(modalDoc.code)?.vas ?? [])].sort(), + } + : null; + + const isCoverage = params.view === "coverage"; + const head = ( + + } + /> + ); + + /* ── Coverage-Matrix (Control → Richtlinie → Verfahren) ── */ + if (isCoverage) { + const byControl = new Map }>(); + for (const r of requirements) { + if (!byControl.has(r.control)) byControl.set(r.control, { policy: r.policyCode, must: 0, should: 0, ids: [], vas: new Set() }); + const e = byControl.get(r.control)!; + if (r.obligation === "MUSS") e.must++; + else e.should++; + e.ids.push(r.reqId.split("-").slice(1).join("-")); + r.vaCodes.forEach((v) => e.vas.add(v)); + } + const rows = [...byControl.entries()]; + return ( +
+ {head} +

{t("coverageHint", { controls: rows.length, reqs: requirements.length })}

+
+ + + + {t("control")} + {t("policy")} + MUSS + SOLL + {t("procedures")} + {t("reqIds")} + + + + {rows.map(([control, e]) => ( + + {control} + + {e.policy} + + {e.must} + {e.should || "–"} + + + {e.vas.size === 0 ? ( + – + ) : ( + [...e.vas].sort().map((va) => ( + + {va} + + )) + )} + + + {e.ids.join(", ")} + + ))} + +
+
+ {modalData && } +
+ ); + } + + /* ── Bibliothek ── */ + const activeType = DOC_TYPES.includes(params.type as (typeof DOC_TYPES)[number]) ? params.type : null; + const q = params.q?.toLowerCase(); + const filtered = docs.filter( + (d) => + (!activeType || d.type === activeType) && + (!q || d.title.toLowerCase().includes(q) || d.code.toLowerCase().includes(q)) + ); + + const kpiControls = new Set(requirements.map((r) => r.control)).size; + const kpiMust = requirements.filter((r) => r.obligation === "MUSS").length; + const kpiShould = requirements.length - kpiMust; + + const typeHref = (v: string | null) => `/policies${v ? `?type=${v}` : ""}`; + + return ( +
+ {head} + +
+ + + + +
+ +
+ ({ href: typeHref(v), label: TYPE_LABEL[v], active: activeType === v })), + ]} + /> +
+ +
+ + + + {t("code")} + {t("docTitle")} + {t("type")} + {t("version")} + {t("status")} + {t("coverageCol")} + + + + {filtered.length === 0 && ( + + {t("empty")} + + )} + {filtered.map((d) => { + const cov = byPolicy.get(d.code); + return ( + + {d.code} + + {d.title} + + {TYPE_LABEL[d.type]} + v{d.version} + {STATUS_LABEL[d.status]} + + {d.type === "RICHTLINIE" && cov ? t("controlsN", { n: cov.controls.size }) + : d.type === "VERFAHREN" && d.policyCode ? `→ ${d.policyCode}` + : "–"} + + + ); + })} + +
+
+ + {modalData && } +
+ ); +} diff --git a/src/app/globals.css b/src/app/globals.css index 9c6ab54..7f2c6e5 100644 --- a/src/app/globals.css +++ b/src/app/globals.css @@ -203,3 +203,89 @@ body { .react-flow__edge-text { fill: var(--muted-foreground); } + +/* Gerenderte Richtlinien/Verfahren (Lesemodus) — Typografie ohne Plugin */ +.policy-prose { + font-size: 13.5px; + line-height: 1.7; + color: var(--foreground); +} +.policy-prose h2 { + font-family: var(--font-heading, inherit); + font-size: 16px; + font-weight: 700; + margin: 1.6em 0 0.5em; + padding-top: 0.9em; + border-top: 1px solid var(--border); + scroll-margin-top: 1rem; +} +.policy-prose h2:first-child { + border-top: 0; + padding-top: 0; + margin-top: 0; +} +.policy-prose h3 { + font-family: var(--font-heading, inherit); + font-size: 14px; + font-weight: 700; + margin: 1.3em 0 0.4em; +} +.policy-prose h4 { + font-size: 13px; + font-weight: 700; + margin: 1em 0 0.3em; +} +.policy-prose p { + margin: 0.55em 0; +} +.policy-prose ul, +.policy-prose ol { + margin: 0.5em 0; + padding-left: 1.3em; + list-style: revert; +} +.policy-prose li { + margin: 0.25em 0; +} +.policy-prose strong { + font-weight: 700; +} +.policy-prose a { + color: var(--info); + text-decoration: none; +} +.policy-prose a:hover { + text-decoration: underline; +} +.policy-prose blockquote { + border-left: 3px solid var(--band-brd); + background: var(--band); + color: var(--band-text); + padding: 0.5em 0.9em; + margin: 0.8em 0; + border-radius: 0 8px 8px 0; + font-size: 12.5px; +} +.policy-prose table { + width: 100%; + border-collapse: collapse; + margin: 0.9em 0; + font-size: 12.5px; +} +.policy-prose th, +.policy-prose td { + border: 1px solid var(--border); + padding: 6px 10px; + text-align: left; + vertical-align: top; +} +.policy-prose th { + background: var(--elevated); + font-weight: 700; +} +.policy-prose code { + background: var(--elevated); + padding: 1px 5px; + border-radius: 4px; + font-size: 12px; +} diff --git a/src/components/policy-modals.tsx b/src/components/policy-modals.tsx new file mode 100644 index 0000000..a466357 --- /dev/null +++ b/src/components/policy-modals.tsx @@ -0,0 +1,110 @@ +import Link from "next/link"; +import { getTranslations } from "next-intl/server"; +import type { PolicyDocument, PolicyVariable } from "@prisma/client"; +import { Button } from "@/components/ui/button"; +import { Modal } from "@/components/modal"; +import { Pill, Tag } from "@/components/mockup-ui"; +import { buildContext, renderPolicyHtml, splitPolicyDoc } from "@/lib/policy-render"; + +const TYPE_LABEL: Record = { + LEITLINIE: "Leitlinie", + RICHTLINIE: "Richtlinie", + VERFAHREN: "Verfahren", + REGISTER: "Register", + HANDBUCH: "Handbuch", + EIGENES: "Eigenes", +}; +const STATUS_TONE: Record = { + FREIGEGEBEN: "ok", + IN_FREIGABE: "info", + ENTWURF: "warn", + ARCHIVIERT: "mut", +}; +const STATUS_LABEL: Record = { + FREIGEGEBEN: "Freigegeben", + IN_FREIGABE: "In Freigabe", + ENTWURF: "Entwurf", + ARCHIVIERT: "Archiviert", +}; + +export interface PolicyReadData { + doc: PolicyDocument; + variables: PolicyVariable[]; + /** ISA-Controls dieser Richtlinie (für Chips). */ + controls: string[]; + /** Operationalisierende Verfahren (Codes) — aus den Anforderungen der Richtlinie. */ + relatedVas: string[]; +} + +/** Lesemodus-Popup: gerendertes Dokument aus der echten Markdown-Vorlage. */ +export async function PolicyReadModal({ data, backHref }: { data: PolicyReadData; backHref: string }) { + const t = await getTranslations("policies"); + const { doc, variables, controls, relatedVas } = data; + const ctx = buildContext(variables); + const { infoMd, bodyMd } = splitPolicyDoc(doc.rawMarkdown); + + const stripBaseline = doc.code !== "BASELINE"; + const infoHtml = renderPolicyHtml(infoMd, ctx, { readMode: true, stripBaseline: false }); + const bodyHtml = renderPolicyHtml(bodyMd, ctx, { readMode: true, stripBaseline }); + + return ( + + {TYPE_LABEL[doc.type]} + {STATUS_LABEL[doc.status]} + v{doc.version} + + } + closeHref={backHref} + closeLabel={t("close")} + footer={} + > +
+ {/* Kontext: Controls / operationalisiert-durch */} + {(controls.length > 0 || doc.policyCode || relatedVas.length > 0) && ( +
+ {doc.type === "VERFAHREN" && doc.policyCode && ( + + {t("operationalizes")}{" "} + + {doc.policyCode} + + + )} + {controls.map((c) => ( + + ISA {c} + + ))} + {doc.type !== "VERFAHREN" && relatedVas.length > 0 && ( + + {t("procedures")}: + {relatedVas.map((va) => ( + + {va} + + ))} + + )} +
+ )} + + {/* Einklappbare Dokumenten-Info (§7a.5, Standard: eingeklappt) */} + {infoMd && ( +
+ + {t("docInfo")} + +
+
+ )} + + {/* Gerendertes Dokument */} +
+
+ + ); +} diff --git a/src/lib/policy-render.ts b/src/lib/policy-render.ts new file mode 100644 index 0000000..0b3add1 --- /dev/null +++ b/src/lib/policy-render.ts @@ -0,0 +1,165 @@ +import Handlebars from "handlebars"; +import { marked } from "marked"; + +/** + * Rendering-Engine für Richtlinien & Verfahren (VDA-ISA 2027 Vorlagenpaket). + * + * Pipeline (§7 der Spezifikation): + * 1. {{LINK:…}} vorab auflösen (Doppelpunkt/#-Ziele würde Handlebars sonst brechen). + * 2. Handlebars mit noEscape:true → verschachtelte {{#if FLAG}} und {{VARIABLE}}. + * 3. Lesemodus-Nachbearbeitung: Hidden-Anker entfernen, wiederholtes + * „Umsetzung bei " reduzieren, zentral verwaltete Abschnitte + * unterdrücken (§7a.3), BL-Referenzen entfernen (Wert bleibt, §7). + * 4. Markdown → HTML (marked). + */ + +export type RenderContext = Record; + +/** Baut den Render-Kontext (Variablen + Flags) aus den PolicyVariable-Zeilen. */ +export function buildContext(vars: { key: string; kind: string; value: string }[]): RenderContext { + const ctx: RenderContext = {}; + for (const v of vars) ctx[v.key] = v.kind === "boolean" ? v.value === "true" : v.value; + return ctx; +} + +// Abschnitte, die das Tool zentral verwaltet und daher im Lese-/Exportmodus ausblendet (§7a.3) +const SUPPRESS_SECTIONS = [ + "Verwandte Dokumente", + "Nachweise", + "Überprüfung und Aktualisierung", + "Verbindlichkeit", +]; + +/** {{LINK:ZIEL}} → interner Deep-Link nach /policies. */ +export function resolveLink(target: string): { href: string; label: string } { + const [code, anchor] = target.split("#"); + const q = (c: string) => `/policies?doc=${encodeURIComponent(c)}${anchor ? `#${anchor}` : ""}`; + switch (code) { + case "NACHWEISREGISTER": + return { href: "/policies?doc=NACHWEIS", label: "Nachweisregister" }; + case "ISA_MAPPING": + return { href: "/policies?view=coverage", label: "ISA-Mapping-Matrix" }; + case "BASELINE": + return { href: "/policies?doc=BASELINE", label: "Technische Sicherheits-Baseline" }; + default: + return { href: q(code), label: anchor ? `${code} §${anchor}` : code }; + } +} + +function resolveLinks(md: string): string { + return md.replace(/\{\{LINK:([^}]+)\}\}/g, (_m, target: string) => { + const { href, label } = resolveLink(target.trim()); + return `[${label}](${href})`; + }); +} + +function stripHiddenAnchors(md: string): string { + return md.replace(//g, ""); +} + +/** §7a.1 — wiederkehrende Zwischenüberschrift „Umsetzung bei " auf ein dezentes „Umsetzung:" reduzieren. */ +function reduceImplHeadings(md: string): string { + return md.replace(/^\*\*Umsetzung bei .+?\*\*\s*$/gm, "_Umsetzung:_"); +} + +/** §7a.3 — zentral verwaltete Abschnitte ausblenden (## bis zur nächsten ##-Überschrift). */ +function suppressSections(md: string): string { + const lines = md.split("\n"); + const out: string[] = []; + let skipping = false; + for (const line of lines) { + const h2 = line.match(/^##\s+(?:\d+\.?\s*)?(.+?)\s*$/); + if (h2) { + const title = h2[1].trim(); + skipping = SUPPRESS_SECTIONS.some((s) => title.toLowerCase().startsWith(s.toLowerCase())); + } + if (!skipping) out.push(line); + } + return out.join("\n"); +} + +/** + * §7 — Baseline-Referenzen (BL-…) im Lesemodus entfernen; nur der konkrete + * Variablenwert bleibt. Behandelt Klammerzusätze „(BL-IAM-01)", Kombiformen + * „(BL-CRY-01/04)", einleitende Wendungen „nach/gemäß/laut BL-…" und Resttokens. + */ +function stripBaselineTokens(md: string): string { + // "(… BL-XXX-01 …)" — Klammern, die BL-Referenzen enthalten, ganz entfernen + md = md.replace(/\s*\([^()]*BL-[A-Z]+-\d+[^()]*\)/g, ""); + // "nach/gemäß/laut BL-XXX-01" (auch /04-Kombi) + md = md.replace(/\s*(?:nach|gemäß|gemaess|laut|per)\s+BL-[A-Z]+-\d+(?:\/\d+)?/gi, ""); + // verbleibende bloße Tokens + md = md.replace(/\s*BL-[A-Z]+-\d+(?:\/\d+)?/g, ""); + return md; +} + +/** Nachsichtiger Fallback-Renderer (rekursiv, verschachtelungsfähig) für defekte Vorlagen. */ +function lenientRender(md: string, ctx: RenderContext): string { + const ifPat = /\{\{#if (\w+)\}\}((?:(?!\{\{#if )(?!\{\{\/if\}\})[\s\S])*?)\{\{\/if\}\}/g; + let prev = ""; + while (prev !== md) { + prev = md; + md = md.replace(ifPat, (_m, flag: string, inner: string) => (ctx[flag] ? inner : "")); + } + return md.replace(/\{\{(\w+)\}\}/g, (_m, key: string) => (key in ctx ? String(ctx[key]) : "")); +} + +export interface RenderOptions { + readMode?: boolean; // Default true — Lesefassung ohne Anker/BL/verwaltete Abschnitte + stripBaseline?: boolean; // Default = readMode; für das Baseline-Register selbst false +} + +/** Vorlagen-Markdown → gerenderte Markdown-Lesefassung. */ +export function renderPolicyMarkdown(raw: string, ctx: RenderContext, opts: RenderOptions = {}): string { + const readMode = opts.readMode ?? true; + const stripBaseline = opts.stripBaseline ?? readMode; + + let md = resolveLinks(raw); + try { + const tpl = Handlebars.compile(md, { noEscape: true }); + md = tpl(ctx); + } catch { + // Defensiv: beschädigte Tokens dürfen keine ganze Seite zerlegen — + // nachsichtiger, verschachtelungsfähiger Fallback (analog _verify.py). + md = lenientRender(md, ctx); + } + + if (readMode) { + md = stripHiddenAnchors(md); + md = reduceImplHeadings(md); + md = suppressSections(md); + if (stripBaseline) md = stripBaselineTokens(md); + } + return md.replace(/[ \t]+$/gm, "").replace(/\n{3,}/g, "\n\n").trim(); +} + +/** Vorlagen-Markdown → HTML (Lesemodus). */ +export function renderPolicyHtml(raw: string, ctx: RenderContext, opts: RenderOptions = {}): string { + const md = renderPolicyMarkdown(raw, ctx, opts); + return marked.parse(md, { async: false }) as string; +} + +/** + * Zerlegt ein Dokument in Titel, Info-Tabelle (Kopf) und Rumpf (ab erster + * `## `-Überschrift). Ermöglicht die einklappbare Dokumenten-Info (§7a.5). + */ +export function splitPolicyDoc(raw: string): { title: string; infoMd: string; bodyMd: string } { + const titleM = raw.match(/^#\s+(.+?)\s*$/m); + const title = titleM ? titleM[1].trim() : ""; + const idx = raw.search(/^##\s+/m); + const head = idx >= 0 ? raw.slice(0, idx) : raw; + const bodyMd = idx >= 0 ? raw.slice(idx) : ""; + const tableM = head.match(/(\|[^\n]*\|\n(?:\|[^\n]*\|\n?)+)/); + return { title, infoMd: tableM ? tableM[1] : "", bodyMd }; +} + +/** + * Prüft eine gerenderte Fassung auf Rückstände (offene {{…}}, «MISS»-Marker). + * Referenz: `_verify.py`-Gate über alle Flag-Kombinationen. + */ +export function findRenderResidue(rendered: string): string[] { + const issues: string[] = []; + const open = rendered.match(/\{\{[^}]*\}\}/g); + if (open) issues.push(...open); + return issues; +} diff --git a/src/server/db.ts b/src/server/db.ts index e575416..12dfe3e 100644 --- a/src/server/db.ts +++ b/src/server/db.ts @@ -47,6 +47,11 @@ const TENANT_MODELS = new Set([ "Subcontractor", "ManagementDecision", "MaturityAssessment", + "PolicyDocument", + "PolicyRequirement", + "PolicyVariable", + "PolicyBaselineParam", + "PolicyEvidence", ]); /**