Category

Hast du dich auch schon gefragt:

„Wie mache ich eine gute Software für sicherheitskritische Anwendungen?“

Ich habe dir die besten und wichtigsten Punkte für eine sichere Software zusammengetragen und in einem 6-Schritte-Plan zusammengefasst!

Nun aber zu den Details, damit dir die 6 Schritte auch gelingen!

Schritt 1: Definiere dein Vorgehen

Für deine sichere Software musst du zuerst ein Vorgehen für den gesamten Entwicklungsprozess und Lebenszyklus definieren. Aus Sicht der Normen gehören dazu folgende Punkte:

• Qualitätsmanagement, also wie kannst du die Qualität mittels Anforderungen, Reviews und Tracing sicherstellen.

• Risikomanagement, also wie kannst du das Risiko analysieren, erkennen, dokumentieren und bewerten.

• Softwaresicherheitszyklus, also wie stellst du sicher, dass die Software am Schluss auch das macht was sie soll und keine systematischen Fehler entstehen.

• Templates und Vorgehensanweisungen für die Architektur-Dokumentation, die Architektur-Bewertung und weitere Artefakte.

Ich hoffe, du hast für diesen Schritt viel Manpower und Erfahrung in deiner Firma zu Verfügung, denn allein stemmen geht hier (fast) nicht.

Schritt 2: Kenne dein Produkt

Damit du die richtige Software erstellst, musst du natürlich dein Produkt kennen. Dazu musst du eine Anforderungsanalyse und eine Risikoanalyse machen. Sie dienen dir als Grundlage für die Qualitäts- und Sicherheitsanforderungen.

Die genaue Kenntnis der Qualitätsanforderungen ist essenziell bei einer Software im normativen Umfeld. Denn nur dadurch kannst du die richtige Architektur erstellen und am Schluss mittels Bewertung richtig analysieren. Achte darauf, dass du die Qualitätsanforderungen mittels Qualitätsszenarios definierst.

Die wichtigsten Qualitätsanforderungen, welche immer wieder im Zusammenhang mit funktionaler Sicherheit fallen und auch in deiner Architektur abgedeckt werden sollten sind:
Korrektheit, Robustheit, Deterministisch, Modular, Kapselung, Einfachheit, Aufdeckung von Fehlern.
Die Qualitätsanforderungen erfüllst du mit den richtigen Methoden, Modulen und Muster.

Die Sicherheitsanforderungen ergänzen die funktionalen Anforderungen, also was will der Benutzer vom System, mit sicherheitskritischen Anforderungen, also alles, damit der Benutzer nicht zu Schaden kommt. Die Risikoanalyse dient hier neben deiner Erfahrung als bester Input. Ein detailliertes Verständnis der Anforderungen und des Umfelds, in welchem die Software eingesetzt wird ist ebenfalls von Nöten.

Nicht zuletzt solltest du in diesem Schritt den Systemkontext definieren. Achte darauf, dass du eine saubere Trennung der Umsysteme und verständliche Verantwortlichkeiten der Schnittstellen notierst.

Und natürlich musst du alle oben genannten Punkte sauber dokumentieren.

Schritt 3: Get Ready!

Bevor du mit der Architektur anfängst empfehle ich dir wärmstens, dich in allen Belangen bereit zu machen. Dazu gehört für mich, dass du:

• Bereits eine Coding-Guideline aufstellst
• Deine Toolchain bereits in Betrieb nimmst

• Dich bereits der Themen Code-Review, Statische Code-Analyse, Testing und Continiuous Integration annimmst

• Mit DevOps und der Produktion Kontakt aufnimmst

Alle diese Themen musst du nicht fertig abarbeiten, aber sie geben einen solch wichtigen Input für deine Architektur, dass ein herausschieben meist keinen Sinn macht.

Schritt 4: Starte mit Bewährtem

Wenn du eine gute Software machst, startest du immer mit einer Architektur-Vision und Architektur-Prinzipien. Sie zwingen dich – auch wenn du voller Elan und Ideen bist – kurz inne zuhalten und das grosse Ganze in einfachen und verständlichen Punkten zu dokumentieren.

Lehne dich dabei an bestehende Architektur-Prinzipien deiner Firma an! Dies wird die Akzeptanz stark steigern und allen Projektbeteiligten helfen, eine sichere Software zu entwickeln.

In der Architektur-Vision wählst du bereits ein Architektur-Muster und legst damit den wichtigsten Baustein deiner Software. Für Embedded-Systems im normativen Umfeld eignen sich am besten Hierarchische-Systeme. Sie sind aus Bausteinen in unterschiedlichen Ebenen in einer Hierarchie angeordnet.
Der prominenteste Vertreter daraus ist das Schichten-Modell. Es biete gute Lösungen für Themen wie: Modularität, Kapselung, Einfachheit und Determinismus.

Zudem solltest du die folgenden bewährten Module in deine Software einplanen. Sie lösen dir die grundlegendsten querschnittlichen Architektur-Themen:

• Logger, also zum Loggen von Fehlern und Debug-Informationen aus allen Schichten
• Error- oder Assert-Handler, also ein systemweiter Anlauf-Punkt für Fehlerhandling
• Protective/Sanity, ein Sicherheitsmodul, welches viele Sicherheitsanforderungen realisiert
• SafetyContainers, eine Sammlung an Containers mit sichergestellter Daten-Integrität

Schritt 5: Implementiere sicher

Kommst du zur Realisierung des Systems, musst du auch sicher implementieren. Dazu gehört, dass du Safety-Measures anwendest, auf Fehleraufdeckung achtest und natürlich umfangreich testest.

Die Safety-Measures sind Massnahmen, welche du im Design und der Implementierung umsetzt, um die Software sicher zu gestalten. Die meisten Safety-Measures wurden bereits durch die Risikoanalyse gefunden, die weiteren findest du auf Grund deiner Erfahrung oder der anzuwendenden Norm. Die Safety-Measures, welche ich immer wieder angetroffen habe sind:

• Bereichsprüfungen an Schnittstellen von Komponenten
• Prüfung der zwischengespeicherten Daten mit CRC oder redundanten Daten
• Plausibilitätsprüfungen über verschiedene Daten-Arten
• Programmflussüberwachung
• Runtime-Tests zur Sicherstellung der Korrektheit des Prozessors, wie z.B. RAM, ROM
• Prüfungen auf nullptr
• Zyklisches verarbeiten und versenden der Daten

Auch beim Klassen-Design gilt es, auf bewährtes zu setzten. Dazu gehören insbesondere Design-Patterns. Die im Safety-Bereich immer wieder angetroffenen sind: Singleton, State, Observer, Factory-Pattern. Achte auch auf saubere Interfaces an Schnittstellen der Komponenten. Dies erleichtert nicht nur die Dokumentation, sondern auch das Testing.

Es ist aber auch wichtig, dass in deiner Software Fehler nicht unbemerkt bleiben. Die Fehleraufdeckung erreichst du, indem du die Fehler in der Hierarchie weiter hinauf gibst und/oder den Error- oder Assert-Handler involvierst.

Natürlich ist Testing auf allen Ebenen auch für dein sichere Software wichtig. Getestet wird wie in anderen Systemen auch. Trotzdem möchte ich dir noch ein paar Punkte mitgeben, welche mich beim Testing nach Norm immer wieder beschäftigt haben:

• Teste möglichst zeitnah und periodisch.
• Tests müssen von allen Projekt-beteiligten auch lokal ausgeführt werden können.
• Achte auf sauberes Tracing zu den Anforderungen.

Schritt 6: Reflektiere

Die Reflexion der entstandenen Software wird meist vernachlässigt. Dabei kann sie sehr viele wichtige Rückmeldungen über verbleibende Risiken geben. Ich selbst durfte auch noch nie ein „schöne“ Architektur-Bewertung nach z.B. ATAM durchführen. Dazu fehlten in jedem bisherigen Projekt Zeit und Budget. Es gibt zum Glück aber noch andere Orte, wo Reflexion stattfinden kann!

Wird zum Beispiel die Architektur-Arbeit nicht nur vom Architekten alleine, sondern vom Entwicklungs-Team erledigt, bringt dies bereits bei der Erarbeitung wichtige und kritische Einblicke.

Oder du machst im Entwicklungs-Team kleine Reviews von ausgewählten Aspekten, z.B. in Form eines Walkthrough. Dies bringt trotz der Kürze bereits viele Erkenntnisse und Akzeptanz im Team mit sich.

Nutze auch die Sprint-Reviews, um wichtige Architektur-Entscheide kurz vorzustellen. Da an den Reviews meist ein interdisziplinäres Team anwesend ist, kommen die richtigen Fragen und Risiken werden so besser aufgedeckt.

In einem sicheren System ist zudem meist ein Sicherheitsnachweis normativ gefordert. Er ist eine Beweisführung, warum das System aus Sicht des Autors sicher ist und wie es die normativen Anforderungen erfüllt. Meist wird der Sicherheitsnachweis parallel oder nach der Realisierung-Phase des Projekts von einem Safety-Manager erstellt. Nutze den Austausch mit dem Safety-Manager und arbeitet wo möglich die Verbesserungen ein.

Sind wir nun fertig?

Ja, denn wenn du das alles Umsetzten kannst, hast du deine Software im Griff! Eine Prüfung nach Norm ist dann nur noch eine Formsache. Damit das gelingt und du ein Grossteil mit in dein Projekt nehmen kannst, habe ich die genannten Punkte nochmals zusammen gefasst: „Best Practice“ sichere Software.

Viel Erfolg!

In unserem regulierten Zeitalter ist es als Entwickler kaum mehr möglich, an der Funktionalen Sicherheit, kurz FuSi, vorbei zu kommen. Egal ob in der Maschinenindustrie, der Medizintechnik, der Automobilindustrie oder der Bahntechnik; in allen Branchen taucht sie auf und nimmt einen wichtigen Stellenwert ein.

Für viele Entwickler ist Funktionale Sicherheit gleichgestellt mit Normen wälzen und sich herumschlagen mit Zertifizierungen. Doch FuSi ist etwas ganz anderes, etwas viel fundamentaleres. Etwas, was jeder Entwickler eigentlich schon kann und meist (in gewissem Masse) bereits anwendet!

Funktionale Sicherheit kurz erklärt

Was FuSi ist, lässt sich in einem kurzen Satz zusammenfassen:

Dem kurzen Satz muss jedoch eine Erläuterung nachgeschoben werden, denn die FuSi besagt auch gleich das Was, Wann und Wie:

Daraus ist klar, dass jeder Entwickler, der Entwicklungsprozesse befolgt, Überwachungen implementiert und klare, sichere Zustände definiert, bereits FuSi anwendet. Denn alles sind Instrumente, die im Entwickleralltag längst normal sind. Ohne Sie würde Chaos herrschen, Wiederverwendbarkeit ein Fremdwort und Fehlerbehebung ein Alptraum sein – kein Entwickler kann ruhig schlafen ohne für sein Produkt diese Instrumente angewendet zu haben!

Grundsätzlich kann nun jeder seine eigene FuSi definieren, denn die Grundinstrumente besitzen wir bereits. Nun kommen aber doch die Normen ins Spiel. Schliesslich braucht es eine Richtlinie für angemessene Prozesse, ein Mindestmass an Überwachung und klaren sicheren Zuständen. Und noch viel wichtiger: eine Legitimation für den Entwickler trotz Zeit- und Budgetdruck sauber und sicher arbeiten zu können.

Das Prinzip der FuSi-Normen

Das Prinzip sämtlicher FuSi-Normen ist einfach und in vier Schritten erklärt:

Als Entwickler muss ich für eine erfolgreiche FuSi also folgende Schritte befolgen:

1. Die Risikoanalyse durchführen und die Risiken und Sicherheitsfunktionen definieren.
2. Basierend auf den Risiken einen erforderlichen Level ermitteln.
3. Die vom Level definierten Anforderungen an Architektur, Sicherheitsfunktionen und Dokumentation umsetzen.
4. Mittels Bewertung den erreichten Level ermitteln.

Nach erfolgreicher FuSi muss der erreichte Level gleich (oder grösser) als der erforderliche Level sein.

Erfolgreiches Entwickeln mit dem Sicherheitslebenszyklus

Die Schritte der Normen sind immer  noch relativ abstrakt und so noch schlecht in einen Projektplan einzugliedern. Für die Entwicklung wird deshalb der Sicherheitslebenszyklus zum Tragen kommen:

Weiter verallgemeinern lässt sich leider kaum, denn die Schritte im Detail sind abhängig von der Norm die angewendet werden muss.

Wichtigste FuSi-Normen

Die Mutter aller FuSi-Normen ist die EN/IEC 61508. Sie ist sozusagen der direkte Vorfahre für die FuSi in den bekannten Normen der Automobilindustrie (ISO 26262), der Medizintechnik (IEC 62304) , der Bahntechnik (EN 50128) oder der Prozessindustrie (IEC 61511).

Ein Sonderfall stellt die Maschinen Industrie dar. Bei ihr gilt neben der EN/IEC 61508 auch die EN ISO 13849, welche kein direkter Nachkomme der EN/IEC 61508, sondern eher ein entfernter Verwandter ist.

Kurzgesagt, sind die beiden Normen EN/IEC 61508 und EN ISO 13849 für den Entwickler relevant. Die Normen unterscheiden sich in zwei wichtigen Punkten:

Vor allem das vereinfachte Verfahren der EN ISO 13849 macht diese Norm und somit die FuSi für Entwickler zugänglich, Einfach und Verständlich.

SIL und PL kurz erklärt

Die beiden Level-Definitionen der Normen EN/IEC 61508 und EN ISO 13849 sind so essentiell und so tief in der FuSi verankert, dass jeder Entwickler sich damit beschäftigt haben muss. Hier das Wichtigste in Kürze:

• Die Levels stellen eine Masseinheit der Risikominderung dar. Konkret heisst das:

Je höher der Level, desto geringer ist das Rest-Risiko und desto höher sind die Anforderungen.

• Safety Integrity Level, kurz SIL, ist aus der EN/IEC 61508 (und deren Derivaten) und definiert sich in 4 Stufen:

SIL wird von 1 bis maximal 4 definiert.

• Der Performance Level, kurz PL, ist aus der EN ISO 13849 und definiert sich in 5 Stufen:

PL wird von a bis maximal e definiert.

• Die beiden Levels entsprechen einander ziemlich gut, trotzdem darf keine direkte Transformation gemacht werden – es benötigt immer einen zusätzlichen Aufwand. Grundsätzlich gilt:

• Neben der Einteilung braucht es ein Verständnis dafür, was bei welchem Level gefordert wird:

Fazit

Es kann also kein Entwickler behaupten, noch nie FuSi angewendet zu haben – auch wenn es seine eigene FuSi-Definition war. FuSi nach Normen bedeutet zwar mehr Aufwand, ist aber nicht nur für das Produkt, sondern auch für den Entwickler, den Projektleiter und die Firma ein perfektes Instrument um anständige und sicherer Produkte zu kriegen.