Seminar PikeOS Intensivseminar Safety, Security und Zertifizierung

Dieses Intensivseminar vermittelt die Architektur, Konfiguration, Verifikation und Nachweisführung für PikeOS-Systeme mit hohen Safety- und Security-Anforderungen. Die Inhalte sind auf technische Umsetzbarkeit, nachvollziehbare Konfiguration und einen kontrollierten Betrieb ausgerichtet. Theorie, Demonstrationen und Laboraufgaben greifen unmittelbar ineinander.

Jeder Arbeitsschritt beginnt mit einer fachlichen Entscheidung, wird anschließend in CODEO oder am Zielsystem umgesetzt und endet mit einer prüfbaren Kontrolle. Dadurch entsteht kein reines Produktwissen, sondern ein belastbarer Arbeitsablauf für Entwicklung, Integration, Prüfung und Betrieb.

Inhaltsübersicht

1. Einsatzszenarien und Entscheidungsrahmen
2. Kritikalitäts- und Vertrauensanalyse
3. Mixed-Criticality-Partitionsdesign
4. Echtzeitmodell und Zeitbudgets
5. Zeitpartitionierung und Major Frame
6. Kommunikationsarchitektur zwischen Partitionen
7. Fehlerbegrenzung und Wiederanlauf
8. Safety-Planung und Systemabgrenzung
9. Anforderungen und Rückverfolgbarkeit
10. Konfigurationsmanagement und reproduzierbare Baselines
11. Verifikationsstrategie und Unabhängigkeit
12. Nachweisobjekte und Auditvorbereitung
13. Bedrohungsmodell und Schutzbedarf
14. MILS-Prinzipien und starke Separation
15. Rechte-, Ressourcen- und Geräteminimierung
16. Sichere Kommunikation und Informationsflusskontrolle
17. Hardening und sichere Betriebsbaseline
18. Security-Verifikation und Schwachstellenbehandlung
19. Multi-Core-Messkampagne und Nachweisstruktur
20. Fault Injection und Robustheitsprüfung

Zielgruppe

Safety- und Security-Ingenieure, Systemarchitekten, Verifikationsverantwortliche, technische Projektleiter und Integratoren kritischer Systeme.

Voraussetzungen

PikeOS-Grundlagen, Erfahrung mit Systementwicklung und Anforderungen; Kenntnisse einschlägiger Safety- oder Security-Prozesse sind hilfreich.

Lernziele

• Mixed-Criticality- und MILS-orientierte Architekturen aus Schutz- und Safety-Zielen ableiten.
• Zeit-, Speicher-, Kommunikations- und Gerätepartitionierung begründet festlegen.
• Anforderungen, Baselines, Tests und Nachweisobjekte rückverfolgbar strukturieren.
• Fehler- und Angriffsszenarien durch Fault Injection und Negativtests prüfen.
• Änderungen, Wiederverwendung und Freigabeentscheidungen nachvollziehbar bewerten.

Abgedeckte Themenfelder

• PikeOS Core Training – Grundlagen und Systemkonfiguration
• PikeOS Echtzeit, Scheduling und Zeitpartitionierung
• PikeOS Grundlagen für technische Entscheider
• PikeOS Mixed-Criticality-Systemarchitektur
• PikeOS Multi-Core und Interferenzmanagement
• PikeOS Safety Engineering und Zertifizierung
• PikeOS Security Engineering, MILS und Hardening
• PikeOS Sichere Inter-Partition-Kommunikation

Seminarinhalte

Einsatzszenarien und Entscheidungsrahmen

1. Schritt 1: Produktziele, Kritikalitätsstufen und regulatorische Randbedingungen erfassen.
2. Schritt 2: Monolithische, containerbasierte und hypervisorbasierte Ansätze sachlich abgrenzen.
3. Schritt 3: Nutzen und Aufwand einer PikeOS-Plattform für den konkreten Lebenszyklus bewerten.
4. Schritt 4: Entscheidungskriterien in einer prüfbaren Bewertungsmatrix zusammenführen.

Kritikalitäts- und Vertrauensanalyse

1. Schritt 1: Funktionen nach Kritikalität, Vertrauensniveau und Ausfallwirkung klassifizieren.
2. Schritt 2: Gemeinsame Ressourcen und unerwünschte Kopplung identifizieren.
3. Schritt 3: Sicherheits-, Safety- und Verfügbarkeitsziele voneinander abgrenzen.
4. Schritt 4: Partitionierungsentscheidungen aus den Analyseergebnissen begründen.

Mixed-Criticality-Partitionsdesign

1. Schritt 1: Funktionen zu Partitionen und Laufzeitumgebungen bündeln.
2. Schritt 2: Minimale Berechtigungen, Speichergrenzen und Gerätezugriffe festlegen.
3. Schritt 3: Zeitbudgets und Kommunikationspfade an Kritikalitätsgrenzen ausrichten.
4. Schritt 4: Architekturregeln für spätere Änderungen und Erweiterungen formulieren.

Echtzeitmodell und Zeitbudgets

1. Schritt 1: Ende-zu-Ende-Zeitanforderungen in messbare Teilbudgets zerlegen.
2. Schritt 2: Partitionszeit, Thread-Laufzeit, Kommunikation und Geräteverhalten getrennt betrachten.
3. Schritt 3: Perioden, Fristen, Jitter und Überlastbedingungen eindeutig definieren.
4. Schritt 4: Annahmen und Sicherheitsmargen für spätere Messungen dokumentieren.

Zeitpartitionierung und Major Frame

1. Schritt 1: Zeitfenster aus Kritikalität, Last und Reaktionsanforderungen ableiten.
2. Schritt 2: Major Frame und Partitionsfenster ohne unzulässige Lücken oder Überbuchung konfigurieren.
3. Schritt 3: Kommunikationsketten über mehrere Partitionen zeitlich ausrichten.
4. Schritt 4: Normalbetrieb und degradierte Betriebsarten getrennt bewerten.

Kommunikationsarchitektur zwischen Partitionen

1. Schritt 1: Datenflüsse, Produzenten, Verbraucher und Vertrauensgrenzen erfassen.
2. Schritt 2: Direkte Kopplung durch klar definierte Kanäle und Nachrichtenmodelle ersetzen.
3. Schritt 3: Richtung, Datenformat, Aktualität und Ausfallverhalten spezifizieren.
4. Schritt 4: Unnötige Kommunikationsbeziehungen konsequent entfernen.

Fehlerbegrenzung und Wiederanlauf

1. Schritt 1: Fehlertypen nach Ursprung, Ausbreitungsweg und beobachtbarer Wirkung ordnen.
2. Schritt 2: Partitionale Reaktionen, Neustarts und degradierte Modi festlegen.
3. Schritt 3: Fehler gezielt injizieren und die Einhaltung der Begrenzungsgrenzen beobachten.
4. Schritt 4: Wiederanlaufbedingungen und Eskalationspfade anhand von Prüfkriterien bewerten.

Safety-Planung und Systemabgrenzung

1. Schritt 1: Systemgrenze, beabsichtigte Funktion und Safety-Kontext eindeutig festlegen.
2. Schritt 2: Kritikalität, Entwicklungsziele und anzuwendende Prozesse zuordnen.
3. Schritt 3: Rollen, Konfigurationsgegenstände und Prüfverantwortung definieren.
4. Schritt 4: Einen realistischen Plan für Entwicklung, Verifikation und Freigabe erstellen.

Anforderungen und Rückverfolgbarkeit

1. Schritt 1: Systemanforderungen in PikeOS-Konfigurations- und Integrationsanforderungen zerlegen.
2. Schritt 2: Anforderungen eindeutig, prüfbar und widerspruchsfrei formulieren.
3. Schritt 3: Zuordnung zu Architektur, Konfiguration, Quelltext und Testfällen herstellen.
4. Schritt 4: Änderungen auf betroffene Nachweisobjekte und Prüfungen auswirken.

Konfigurationsmanagement und reproduzierbare Baselines

1. Schritt 1: Werkzeuge, Systemsoftware, BSP, Konfiguration und Anwendungen als Konfigurationsobjekte führen.
2. Schritt 2: Freigabestände gegen unbeabsichtigte Änderung schützen.
3. Schritt 3: Build und Systemabbild aus dokumentierten Eingaben reproduzieren.
4. Schritt 4: Abweichungen und Problemberichte mit Entscheidungen und Korrekturständen verknüpfen.

Verifikationsstrategie und Unabhängigkeit

1. Schritt 1: Anforderungs-, Architektur-, Konfigurations- und Testprüfungen sinnvoll kombinieren.
2. Schritt 2: Normale, Grenzwert- und Fehlerfälle aus den Anforderungen ableiten.
3. Schritt 3: Unabhängigkeit und Prüftiefe nach Kritikalität festlegen.
4. Schritt 4: Nicht bestandene Prüfungen kontrolliert bewerten, korrigieren und wiederholen.

Nachweisobjekte und Auditvorbereitung

1. Schritt 1: Benötigte Pläne, Spezifikationen, Prüfprotokolle und Konfigurationslisten strukturieren.
2. Schritt 2: Vollständigkeit und Konsistenz über Querverbindungen prüfen.
3. Schritt 3: Annahmen, Einschränkungen und offene Risiken transparent dokumentieren.
4. Schritt 4: Ein prüfbares Paket für interne oder externe Begutachtung zusammenstellen.

Bedrohungsmodell und Schutzbedarf

1. Schritt 1: Werte, Angreiferfähigkeiten, Schnittstellen und Vertrauensgrenzen erfassen.
2. Schritt 2: Angriffspfade über Gäste, Geräte, Kommunikation und Wartungszugänge analysieren.
3. Schritt 3: Schutzziele für Vertraulichkeit, Integrität, Verfügbarkeit und Authentizität priorisieren.
4. Schritt 4: Technische Sicherheitsanforderungen aus den wesentlichen Risiken ableiten.

MILS-Prinzipien und starke Separation

1. Schritt 1: Minimale Vertrauensbasis und klar abgegrenzte Sicherheitsdomänen definieren.
2. Schritt 2: Informationsflüsse nach erlaubter Richtung und Zweck modellieren.
3. Schritt 3: Partitionen, Kommunikationsdienste und Gerätezugriffe auf geringste Rechte begrenzen.
4. Schritt 4: Bypass- und Seiteneffektpfade systematisch suchen und schließen.

Rechte-, Ressourcen- und Geräteminimierung

1. Schritt 1: Berechtigungen je Partition aus tatsächlich benötigten Funktionen ableiten.
2. Schritt 2: Speicher-, CPU-, Kommunikations- und Gerätezugriffe einzeln rechtfertigen.
3. Schritt 3: Standardrechte und ungenutzte Dienste entfernen.
4. Schritt 4: Unzulässige Zugriffe als negative Tests gezielt nachweisen.

Sichere Kommunikation und Informationsflusskontrolle

1. Schritt 1: Datenflüsse an Vertrauensgrenzen mit Format, Richtung und Schutzbedarf beschreiben.
2. Schritt 2: Validierung, Sequenzierung, Aktualität und Fehlerbehandlung einführen.
3. Schritt 3: Sicherheitskritische Vermittlungsfunktionen klein und prüfbar halten.
4. Schritt 4: Manipulation, Wiederholung und Überlast als Angriffsszenarien testen.

Hardening und sichere Betriebsbaseline

1. Schritt 1: Nicht benötigte Gäste, Dienste, Gerätepfade und Diagnosezugänge deaktivieren.
2. Schritt 2: Sichere Start- und Wartungsverfahren mit kontrollierten Rollen festlegen.
3. Schritt 3: Protokollierung auf relevante Ereignisse und geschützte Ablage ausrichten.
4. Schritt 4: Konfiguration mit automatisierten Negativ- und Konsistenzprüfungen absichern.

Security-Verifikation und Schwachstellenbehandlung

1. Schritt 1: Sicherheitsanforderungen in positive und negative Prüfungen übersetzen.
2. Schritt 2: Fehlkonfigurationen, fehlerhafte Nachrichten und Ressourcenmissbrauch gezielt erzeugen.
3. Schritt 3: Befunde nach Ausnutzbarkeit, Wirkung und Behebbarkeit priorisieren.
4. Schritt 4: Korrektur, Regression und verbleibendes Risiko nachvollziehbar dokumentieren.

Multi-Core-Messkampagne und Nachweisstruktur

1. Schritt 1: Szenarien, Störlasten, Messpunkte und Akzeptanzgrenzen definieren.
2. Schritt 2: Messungen automatisiert und über ausreichend viele Wiederholungen durchführen.
3. Schritt 3: Ausreißer, Trends und Worst-Case-nahe Beobachtungen klassifizieren.
4. Schritt 4: Konfiguration, Messdaten und Bewertung eindeutig miteinander verknüpfen.

Fault Injection und Robustheitsprüfung

1. Schritt 1: Fehlerfälle aus Architektur, Schnittstellen und bisherigen Befunden ableiten.
2. Schritt 2: Zeitüberschreitung, ungültige Daten, Ressourcenausfall und Absturz kontrolliert erzeugen.
3. Schritt 3: Begrenzung, Diagnose und Wiederanlauf anhand erwarteter Zustände beobachten.
4. Schritt 4: Test nach Korrektur automatisiert als Regression erhalten.

Praxisübungen

• Kritikalitäts-, Vertrauens- und Datenflussmodell für ein gemischtes System erstellen.
• Partitionierungs- und Zeitkonfiguration aus Anforderungen ableiten und überprüfen.
• Fehler- und Angriffsszenarien mit erwarteten Begrenzungsreaktionen definieren.
• Rückverfolgbarkeit von Anforderung über Konfiguration bis Test prototypisch aufbauen.
• Auditfähiges Freigabepaket mit Baseline, Prüfergebnissen und offenen Einschränkungen erstellen.

Arbeitsweise

Kurze Fachblöcke werden unmittelbar durch Demonstrationen und geführte Übungen ergänzt. Konfigurationen, Quelltexte, Prüfprotokolle und Checklisten werden in einer konsistenten Laborumgebung geführt. Fehlerbilder werden nicht nur behoben, sondern systematisch eingegrenzt und dokumentiert.