Sprache:
Deutsch

Zielgruppe:
Safety Experten, Software und Systementwickler

Voraussetzungen:
Erste Erfahrungen mit sicherheitskritischen Systemen

Überblick und Zusammenfassungen:
Die Entwicklungsprozesse in sicherheitskritischen Industrien basieren aktuell häufig auf dem V-Modell. Dies ist unter anderem darin begründet, dass die vorherrschenden Sicherheitsnormen, z.B. die ISO 26262 in der Automobilindustrie, auf dem V-Modell basieren. Der Fokus dieser Entwicklungsprozesse und Sicherheitsnormen liegt dabei vor allem auf dem Erreichen eines akzeptablen Restrisikos vor Produktionsstart (SOP), während die kontinuierliche Verbesserung des Sicherheitskonzept basierend auf Felddaten nach SOP mit weniger Aufwand betrieben wird.

Für hochautomatisierte und autonome Fahrzeuge, die in einem offenen Kontext operieren, der sowohl a-priori nicht vollständig beschrieben werden und sich zudem auch noch nach Produkteinführung wandeln kann, muss diese Strategie allerdings angepasst werden. Aus diesem Grund und aus dem Bestreben heraus, in einer VUCA-Welt konkurrenzfähig zu bleiben, gibt es auch in sicherheitskritischen Industrien den Trend DevOps einzusetzen, einen agilen Entwicklungsprozess, der Produktentwicklung und -betrieb iterativ betrachtet.

Dies führt zu der grundlegenden Frage, wie man Safety und DevOps kombinieren kann. In diesem Vortrag werde ich die Antwort auf diese Frage anhand konkreter Beispiele aus der Praxis skizzieren. Ein wichtiger Aspekt dabei ist das Identifizieren und Beseitigen von Lücken in der Automatisierung von Aufgaben des Safety Engineerings und des Safety Managements. Ein zweiter wichtiger Aspekt ist die gezielte Nutzung der steigenden Konnektivität der Produkte, um Safety Eigenschaften im Betrieb zu überwachen und so eine kontinuierliche Anpassung und Verbesserung des Sicherheitskonzepts zu ermöglichen.


Art der Vermittlung:
Methodenerklärung mit Projektbeispielen

Nutzen:
Das Publikum erhält einen Überblick über die Herausforderung der Integration von sicherheitskritischer Produktentwicklung und agile Produktentwicklungsprozesse, insbesondere DevOps. Gleichzeitig werden Lösungskonzepte anhand praktischer Beispiele aus der Automobilindustrie aufgezeigt, die sich prinzipiell auch in andere Domänen übertragen lassen.

Sprache:
deutsch

Zielgruppe:
Software-Entwickler, Software-Architekten, Software-Tester, FuSi-Manager

Voraussetzungen:
Informatik-Studium oder Programmiererfahrung mit eingebetteten Systemen

Überblick und Zusammenfassungen:
Stacküberläufe in sicherheitskritischen Systemen können schwere Fehler verursachen. Gemeint ist hierbei der Laufzeitstack, in dem dynamische Daten über die derzeit ausgeführten Funktionen gespeichert sind, z.B. Werte von lokalen Variablen, Rücksprungadressen und Zwischenergebnisse von Ausdrucksauswertungen. Der maximale Speicherbedarf des Stacks muss statisch bekannt sein: zur Konfigurationszeit des Systems muss ausreichend viel Stackplatz für jede Task reserviert werden. Die maximale Stacktiefe ist nicht einfach vom Quellcode abzulesen, da sie von der dynamischen Aufruftiefe von Funktionen abhängt, aber auch von Compiler- und Linkeroptimierungen. Wird der verfügbare Speicherplatz unterschätzt, können Stacküberläufe auftreten. Eine Überschätzung des Stackverbrauchs ist ebenfalls unerwünscht, da Speicher verschwendet wird.
Stacküberläufe sind schwerwiegende Fehler, die dazu führen können, dass das System abstürzt, bzw. fehlerhaft oder erratisch reagiert. Ein Beispielfall sind die Unfälle durch unbeabsichtigte Beschleunigung beim Toyota Camry Modell 2014, die aller Wahrscheinlichkeit nach von Stacküberläufen ausgelöst wurden [1]. Die Ermittlung oberer Schranken des maximalen Stackbedarfs wird von allen aktuellen Sicherheitsnormen gefordert, darunter ISO 26262, IEC 61508, DO-178C.
Garantierte obere Schranken des maximalen Stackverbrauchs können durch sichere statische Analysatoren auf Binärcode berechnet werden. Hierbei wird die formale Methode der statischen Analyse, Abstrakte Interpretation, eingesetzt, die einen formalen Beweis ermöglicht, dass der maximale Stackverbrauch nicht unterschätzt wird. Im Gegensatz zur statischen Analyse von Codierrichtlinien wird dabei nicht der Quellcode analysiert, sondern der ausführbare Binärcode. Der Maschinencode wird disassembliert, und der Aufrufgraph berechnet, in dem die Stackeffekte jeder Maschineninstruktion auf jedem möglichen Ausführungspfad zur Berechnung des Maximums berücksichtigt werden. Eine wichtige Anforderung an statische Binärcodeanalysatoren ist die Minimierung der erforderlichen Benutzerinteraktionen, z.B. zur Angabe der möglichen Ziele von Funktionszeigeraufrufen. Die Analyse sollte hochpräzise sein, um möglichst viele Funktionszeigerziele automatisch zu bestimmen, der Annotationsmechanismus sollte flexibel und einfach zu bedienen sein, und es sollte die Möglichkeit bestehen, fehlende Informationen automatisch von Quellcode-Analysatoren oder Trace-Informationen zu übernehmen.
In diesem Vortrag stellen wir die Methodik der statische Stack-Analyse vor, erläutern Automatisierungs-Konzepte, diskutieren automatische Tool-Qualifizierung gemäß Safety-Normen, und stellen praktische Erfahrungen aus industriellen Luftfahrt- und Automobilprojekten vor.

[1] M. Barr. Bookout v. Toyota, 2005 Camry software Analysis by Michael Barr, 2013, http://www.safetyresearch.net/Library/BarrSlides_FINAL_SCRUBBED.pdf.



Art der Vermittlung:
Vortrag mit Methodenerklärung und Beispielen, sowie Erfahrungen aus der Industrie-Praxis

Nutzen:
Der Vortrag erklärt das Problem von Stacküberläufen, und erläutert die Methodik statischer Analysen des Stackverbrauchs. Eine Abgrenzung zu anderen Verfahren wird hergestellt. Auch die Integration in existierende Tool- und Prozessketten, sowie die Einbindung in automatisierte Systeme zur kontinierlichen Verifikation wird besprochen. Der Vortrag zeigt verständliche Beispiele und berichtet über praktische Erfahrungen aus Industrieprojekten.

Sprache:
deutsch oder English

Zielgruppe:
Software-Entwickler

Voraussetzungen:
C++ Grundkenntnisse

Überblick und Zusammenfassungen:
Der Autor arbeitet seit einiger Zeit in der MISRA C++ Arbeitsgruppe, die eine neue Version der Safety Guidelines für C++ zusammenstellt. Es ist geplant, dass diese im Jahr 2021 fertig gestellt werden. Der Vortrag gibt einen Überblick zu den wichtigsten Änderungen und wie neue Sprachmittel sinnvoll eingesetzt werden sollen. Nach einen kurzen Überblick der Entstehungsgeschichte, werden einzelne der neuen Regel exemplarisch vorgstellt und die zugrundeliegende Philosophie erläutert. Ein Ausblick auf zukünftige Arbeiten im Umfeld und andere Safety- und Security-relevante C++ Guidelines wird gegeben.

Art der Vermittlung:
Präsentation

Nutzen:
Entwickler erhalten einen kurzen Überblick über die Neuerungen und erhalten Tipps für zukünftiges MISRA-C++ konformes Arbeiten. Solch sicherer C++ Code ist nicht nur im Automobilsektor, sondern generell bei der Embedded Entwicklung hilfreich.

Sprache:
English

Zielgruppe:
embedded systems engineers, functional safety engineers, system security engineers

Voraussetzungen:
computer engineering background

Überblick und Zusammenfassungen:
In Mixed-Criticality Systems (MCS), low-critical applications (e.g. network connectivity, user-interface ) have a larger attack surface compared to high-critical applications. Even though MCS isolate criticality domains of execution by design, a threat affecting a low-critical service can alter the system behaviour: e.g by degrading the system availability or user-experience. Such attacks on low-critical tasks can even introduce an entry point for propagating the attack further to high-critical tasks. So detecting such threats at runtime is becoming a growing necessity for MCS security. Among the different threat classes, code-reuse attacks such as Return Oriented Programming (ROP) are prominent ones in embedded systems. Control Flow Integrity (CFI) monitoring is a proven security technique for detecting code-reuse attacks. CFI identifies deviations from the baseline Control Flow Graph (CFG) as malicious control-flow transitions.

For monitoring a program’s control-flow, CFI approaches require instruction-level knowledge of the program including forward-edge and backward-edge CFG branches. For this, CFI implementations rely on source code or binary instrumentation in order to check the validity of control-flow transitions during run-time. In the context of safety-critical systems, especially in multi-supplier product development, these constraints prohibit a straightforward deployment of CFI. For safety-critical system requiring certification, the system developer has to ensure freedom from interference and independence between components to prevent fault propagation and to enable easy verification. For the deployment of CFI in safety-critical system, this means the resource usage (e.g. memory, CPU time) of CFI checking shall be deterministically upper-bounded at runtime. For the industrial deployment of CFI, it shall also use commonly available hardware assistance features, such as CFI solutions based on Intel Processor Trace (PT) and ARM CoreSight. In this talk, we will present a separation kernel-based approach to integrate CFI monitoring in a  safety-critical system with real-time constraints. Our solution leverages ARM Coresight to transparently monitor control flow (CF) transfers and using the CF traces, we realize both forward-edge and backward-edge CFI in software. Our approach reliably protects the control flow of the monitored application, however it comes with a high performance overhead. The overhead depends on the monitored program execution path (the more executed CF transitions, the higher the overhead). 

Therefore in the second part of the talk, we will extend the framework to deal with the performance overhead introduced by the first solution. The goal is to address the trade-off between CF monitoring coverage and performance overhead. First, we present a monitoring framework to control the performance overhead for CF tracing by adapting the CF monitoring coverage at runtime. Our framework leverages a predictable periodic-server based approach together with separation kernel framework for safety-aware integration of hardware-assisted CF monitoring into MCS. Then, we use this framework to deploy an anomaly detection service to monitor the full scope of the task’s execution, identifying anomalies from the observation of inter-arriving times of CF monitoring instances. We validate our monitoring framework on an industrial MCS platform using a set of applications from TACLeBench benchmark.

We conclude our talk discussing alternative approaches to use hardware assisted processor tracing for runtime threat detection: i.e. dealing with the  high performance overhead, combining our framework with complementary security solutions like reaction upon threat detection and multi-stage detection using artificial intelligence.

Art der Vermittlung:
technical presentation

Nutzen:
In this talk, we present a generic method based on separation kernel to integrate security mechanisms in Mixed-Criticality System (MCS). In particular, we present the integration of hardware-assisted control flow (CF) based security monitoring. We will share our experience working with ARM CoreSight tracing for implementing Control Flow Integrity checking and runtime CF based anomaly detection. We will introduce metrics to evaluate the trade-off between performance impact and security monitoring coverage and discuss our experiment results. We validate our approach on an industrial MCS platform with ARM CoreSight support, using a set of programs from TACLeBench benchmark.