Checkliste zur Überprüfung des Sicherheitscodes

Stellen Sie sich vor, Ihr Marktwert fällt innerhalb von neun Stunden um 80 %. Genau das ist mit Holograph passiert. Eine kürzlich erfolgte Datenpanne deckte eine verborgene Schwachstelle im Smart-Contract-Code von Holograph auf – eine bittere Erinnerung daran, dass die Cyberkriminalität boomt. An dieser Stelle ist ein Code-Sicherheitsaudit unverzichtbar.

Unternehmen, die mit sensiblen Daten zu tun haben, sind dafür verantwortlich, robusten Sicherheitsmaßnahmen Priorität einzuräumen. Ganz gleich, ob Sie ein E-Commerce-Riese, eine Regierungsbehörde oder ein Finanzdienstleister sind, dieser Leitfaden vermittelt Ihnen das Wissen und die Werkzeuge, die Sie zur Verbesserung Ihrer Codesicherheit benötigen. Viele Vorschriften erfordern einen strengen Datenschutz, und Audits helfen Ihnen, diese Vorschriften zu erfüllen.

Dieser Artikel enthält eine umfassende Checkliste für die Durchführung einer eingehenden Überprüfung der Codesicherheit. Wenn Sie diese Schritte befolgen, können Sie Ihre Codesicherheit erheblich verbessern und das Vertrauen Ihrer Kunden und Investoren erhalten.

Leitfaden für eine umfassende Prüfung der Codesicherheit

Eine Code-Sicherheitsprüfung ist ein tiefes Eintauchen in den Code Ihrer Anwendung, bei dem nach versteckten Schwachstellen gesucht wird. In Hochrisikobranchen kann selbst ein kleiner Sicherheitsfehler verheerende Folgen haben. Eine Code-Sicherheitsprüfung hilft, diese Probleme zu erkennen und zu beheben, bevor sie zu einem großen Problem werden.

Vorläufige Überprüfungen

Bevor Sie sich in die Feinheiten Ihrer Code-Sicherheitsprüfung stürzen, ist es wichtig, die potenziellen Bedrohungen und Schwachstellen zu verstehen, die in Ihrer Anwendung lauern. Diese ersten Schritte helfen, die Voraussetzungen für einen gründlichen und effektiven Überprüfungsprozess zu schaffen.

Verstehen Sie den Anwendungskontext:

• Sammeln Sie Informationen über den Zweck, die Architektur und den Technologie-Stack der Anwendung.
• Identifizieren Sie die wichtigsten Komponenten und Module, die eine Sicherheitsüberprüfung erfordern.
• Verstehen des Bedrohungsmodells, einschließlich potenzieller Angreifer und deren Fähigkeiten.
• Überprüfung der vorhandenen Sicherheitsdokumentation und früherer Sicherheitsbewertungen.
• Identifizierung der für die Anwendung relevanten rechtlichen und Compliance-Anforderungen.

Versionskontrolle und Änderungsverwaltung:

• Sicherstellen, dass der Code in einem sicheren Versionskontrollsystem wie Git gespeichert ist.
• Prüfen Sie den Commit-Verlauf, um die jüngsten Änderungen zu verstehen und potenzielle Sicherheitsprobleme zu erkennen.
• Überprüfen Sie, ob Codeänderungen in einem formalen Prozess überprüft und genehmigt werden.
• Prüfen Sie, ob sicherheitsrelevante Commit-Meldungen und Dokumentationen vorhanden sind.
• Identifizierung direkter Übertragungen auf sensible Bereiche der Codebasis ohne gegenseitige Überprüfung.

Build- und Bereitstellungsprozesse:

• Überprüfung der Build- und Deployment-Prozesse im Hinblick auf bewährte Sicherheitsverfahren.
• Sicherstellen, dass Build-Skripte und Konfigurationsdateien sicher sind und keine vertraulichen Informationen preisgeben.
• Überprüfen Sie die Verwendung automatisierter Sicherheitstests in der CI/CD-Pipeline.
• Überprüfung des sicheren Umgangs mit Geheimnissen und Anmeldeinformationen während des Build- und Deployment-Prozesses.
• Identifizieren Sie alle manuellen Schritte im Bereitstellungsprozess, die Sicherheitsrisiken bergen könnten.

Teamzusammenarbeit und Kommunikation:

• Klare Kommunikationskanäle und -protokolle für den Sicherheitsüberprüfungsprozess einrichten.
• Sicherstellen, dass alle an der Überprüfung beteiligten Teammitglieder ihre Rollen und Verantwortlichkeiten kennen.
• Planen Sie regelmäßige Treffen, um die Ergebnisse zu besprechen und Abhilfemaßnahmen zu koordinieren.
• Bereitstellung von Schulungen und Ressourcen für Teammitglieder zu sicheren Kodierungspraktiken und Sicherheitsüberprüfungstechniken.

Codequalität und Schwachstellenüberprüfung

In diesem Schritt geht es vor allem darum, die Qualität des Codes sicherzustellen und Schwachstellen auszumerzen, die gehackt werden könnten. Wir durchkämmen den Code, um häufige Sicherheitsprobleme zu finden und sicherzustellen, dass alles nach bewährten Verfahren kodiert ist.

Lesbarkeit und Wartbarkeit des Codes:

• Prüfen Sie auf klaren, prägnanten und selbsterklärenden Code mit entsprechenden Kommentaren.
• Sicherstellen, dass die Funktionen und Methoden nur einem Zweck dienen und nicht übermäßig komplex sind.
• Überprüfen Sie die konsistente Verwendung von Namenskonventionen und Code-Formatierung in der gesamten Code-Basis.
• Identifizierung und Refaktorierung von dupliziertem Code, um das Fehlerpotenzial zu verringern.
• Sicherstellung einer modularen Codestruktur zur Vereinfachung von Tests und Wartung.

// Schlechte Praxis
public void ProcessOrder(Order order) {
    ValidateOrder(order);
    SaveOrder(order);
    SendConfirmationEmail(order);
}

// Bewährte Verfahren
public void ProcessOrder(Order order) {
    ValidateOrder(order);
    SaveOrder(order);
    NotifyCustomer(order);
}

private void NotifyCustomer(Order order) {
    SendConfirmationEmail(order);
    LogNotification(order);
}

Monolithischer Code, der nicht in kleinere Teile aufgeteilt ist, kann zu Code-Duplizierung führen und erhöht das Risiko von Fehlern bei Änderungen. Refactoring großer Codeblöcke in kleinere, wiederverwendbare Methoden oder Klassen

Statische Analyse:

• Verwenden Sie statische Analysetools, um den Code auf potenzielle Sicherheitsschwachstellen zu untersuchen.
• Identifizieren Sie häufige Codeprobleme wie Pufferüberläufe, Race Conditions und Speicherlecks.
• Sicherstellen, dass die statischen Analysetools so konfiguriert sind, dass sie Codierungsstandards und Sicherheitsrichtlinien durchsetzen.
• Überprüfung und Behebung der Ergebnisse aus den Berichten der statischen Analyse.
• Integration der statischen Analyse in die kontinuierliche Integrationspipeline (CI) für laufende Überprüfungen.

Kodierungsstandards und bewährte Praktiken:

• Überprüfung der Einhaltung sprachspezifischer und branchenüblicher Kodierungspraktiken.
• Überprüfen Sie die Verwendung von sicheren Kodierungsbibliotheken und Frameworks.
• Sicherstellen, dass der Code das Prinzip der geringsten Privilegien einhält.
• Überprüfung, dass veraltete oder unsichere Funktionen nicht verwendet werden.
• Förderung des Einsatzes defensiver Kodierungstechniken zur Vorwegnahme und Behandlung unerwarteter Eingaben oder Zustände.

// Schlechte Praxis
public void ProcessInput(string input) {
    Console.WriteLine("Processing: " + input.Substring(5));
}

// Bewährte Verfahren
public void ProcessInput(string input) {
    if (string.IsNullOrEmpty(input) || input.Length < 5)
    {
        throw new ArgumentException("Input must be at least 5 characters long.");
    }
    Console.WriteLine("Processing: " + input.Substring(5));
}

Beispiel für defensive Kodierung, die den Code sicherer, aber auch einfacher zu debuggen und zu warten macht

Sichere Verwendung von Sprachfunktionen:

• Überprüfung der ordnungsgemäßen Verwendung sprachspezifischer Funktionen, z. B. Ausnahmebehandlung in Java oder Fehlerprüfung in Go.
• Sicherstellen, dass die Speicherverwaltung korrekt gehandhabt wird, um Lecks und Korruption zu verhindern (relevant für Sprachen wie C/C++).
• Überprüfung der sicheren Verwendung nebenläufiger Programmierkonstrukte zur Vermeidung von Race Conditions und Deadlocks.
• Sicherstellen, dass Typsicherheit durchgesetzt wird, um typbezogene Schwachstellen zu verhindern.
• Validierung der sicheren Handhabung von Eingabe-/Ausgabeoperationen, um Injektionsangriffe zu verhindern.

// Schlechte Praxis
char* buffer = new char[100];
strcpy(buffer, "This is a buffer.");
// Missing delete[] buffer;

// Bewährte Verfahren
#include 
std::unique_ptr buffer(new char[100]);
strcpy(buffer.get(), "This is a buffer.");
// No need to manually delete, handled by unique_ptr

Beispiel für schlechte vs. gute Speicherverwaltung in C/C++. Speicherprobleme können zu Anwendungsabstürzen, Leistungseinbußen und Sicherheitslücken führen

Erkennung von Schwachstellenmustern:

• Identifizierung und Behebung allgemeiner Schwachstellenmuster, wie z. B. fest kodierte Anmeldedaten oder Geheimnisse im Quellcode.
• Überprüfung auf unsichere Verwendung von Zufallszahlengeneratoren (stellen Sie sicher, dass kryptografische RNGs verwendet werden, wo dies erforderlich ist).
• Sicherstellen, dass es keine unsanitären Benutzereingaben gibt, die direkt an Datenbankabfragen oder Befehlszeilenargumente weitergegeben werden.
• Dokumentieren Sie alle Fälle von unsicheren Kommunikationskanälen ohne Verschlüsselung.
• Achten Sie auf unzureichende Zugriffskontrollen innerhalb der Anwendungslogik.
• Dokumentieren Sie diese Muster und geben Sie sie an das Entwicklungsteam weiter, um das Bewusstsein zu schärfen und künftige Vorkommnisse zu verhindern.

// Schlechte Praxis (SQL Injection risk)
string query = "SELECT * FROM Users WHERE Username = '" + username + "'";

// Bewährte Verfahren
string query = "SELECT * FROM Users WHERE Username = @username";
SqlCommand command = new SqlCommand(query, connection);
command.Parameters.AddWithValue("@username", username);

Die direkte Verwendung von nicht sanitisierten Eingaben kann zu SQL-Injection, Command-Injection und anderen Arten von Injection-Angriffen führen

Analyse der Code-Komplexität:

• Verwendung von Tools zur Messung der Codekomplexität, z. B. der zyklomatischen Komplexität.
• Identifizieren Sie hochkomplexe oder “Hotspot”-Bereiche des Codes, die anfällig für Fehler und Sicherheitsprobleme sind.
• Vereinfachen Sie komplexe Codepfade, um die Lesbarkeit zu verbessern und die Wahrscheinlichkeit von Fehlern zu verringern.
• Sicherstellen, dass kritische Sicherheitslogik einfach und leicht zu überprüfen ist.
• Refactoring des Codes, wo dies zur Verringerung der Komplexität und zur Verbesserung der Klarheit erforderlich ist.

// Schlechte Praxis
public void ProcessOrder(Order order) {
    ValidateOrder(order);
    if (order.IsValid) {
        SaveOrder(order);
        SendConfirmationEmail(order);
    }
}

// Bewährte Verfahren
public void ProcessOrder(Order order) {
    if (!ValidateOrder(order)) return;
    SaveOrder(order);
    SendConfirmationEmail(order);
}

private bool ValidateOrder(Order order) {
    // Validation logic
    return order.IsValid;
}

Refaktorierung großer Methoden in kleinere Methoden, die jeweils nur eine Aufgabe erfüllen, was die Testbarkeit, Lesbarkeit und Wartbarkeit verbessert

Dokumentation und Kommentierung:

• Sicherstellen, dass sicherheitsrelevanter Code gut dokumentiert ist und die Gründe für die Sicherheitskontrollen erläutert werden.
• Sicherstellen, dass Kommentare keine sensiblen Informationen oder Details der Sicherheitsimplementierung preisgeben.
• Sicherstellen, dass die Dokumentation Richtlinien für eine sichere Interaktion mit dem Code enthält, z. B. wie eine Funktion, die sensible Operationen durchführt, korrekt aufgerufen wird.
• Überprüfen Sie, ob alle kryptografischen Implementierungen und Schlüsselverwaltungsprozesse gründlich dokumentiert sind.
• Sicherstellen, dass Inline-Kommentare sinnvoll eingesetzt werden, um komplexe Codesegmente zu verdeutlichen, ohne die Codebasis zu überfrachten.

Validierung der Eingaben

Eine ordnungsgemäße Eingabevalidierung ist entscheidend, um sicherzustellen, dass nur gültige und erwartete Daten von der Anwendung verarbeitet werden. Dies hilft, eine Vielzahl von Angriffen wie SQL-Injection, Cross-Site-Scripting (XSS) und Pufferüberläufe zu verhindern. Alle Eingaben müssen vor der Verarbeitung korrekt validiert und bereinigt werden, und hier erfahren Sie, wie Sie das überprüfen können.

Client-seitige Validierung:

• Überprüfen Sie, ob die clientseitige Validierung implementiert ist, um den Benutzern ein unmittelbares Feedback zu geben.
• Stellen Sie sicher, dass die clientseitige Validierung nicht nur zu Sicherheitszwecken erfolgt.
• Prüfen Sie, ob zwischen der Client- und der Serverseite konsistente Validierungsregeln vorhanden sind.

Server-seitige Validierung:

• Sicherstellen, dass alle Eingaben unabhängig von der clientseitigen Validierung serverseitig validiert werden.
• Prüfen, ob Eingaben mit Zulassen-Listen validiert werden.
• Prüfen, ob Verweigerungslisten als sekundäre Maßnahme implementiert werden können.
• Sicherstellung der ordnungsgemäßen Validierung aller Eingabetypen, einschließlich Zeichenketten, Zahlen, Daten und Dateien.

// Schlechte Praxis
public bool ValidateUsername(string username) {
    // Checks only if input is not null or empty
    return !string.IsNullOrEmpty(username);
}

//Bewährte Verfahren
public bool ValidateUsername(string username) {
    // Allow only alphanumeric characters and underscores
    Regex allowedPattern = new Regex(@"^\w+$");
    return allowedPattern.IsMatch(username);
}

Verwendung von generischen und allzu freizügigen Validierungsmustern im Vergleich zur Verwendung von Zulassen-Listen, um erlaubte Zeichen oder Muster explizit anzugeben

Bereinigung von Eingaben:

• Überprüfen Sie, ob HTML-, JavaScript- und SQL-Eingaben ordnungsgemäß bereinigt werden, um Injektionsangriffe zu verhindern.
• Sicherstellen, dass spezialisierte Bibliotheken oder Funktionen verwendet werden, um gängige Sanitization-Aufgaben zu erledigen.
• Sicherstellen, dass die bereinigten Eingaben in der gesamten Anwendung konsistent verwendet werden.

Längen- und Formatüberprüfungen:

• Sicherstellen, dass die Länge der Eingaben überprüft wird, um Pufferüberläufe und die Erschöpfung von Ressourcen zu verhindern.
• Sicherstellen, dass Eingaben den erwarteten Formaten entsprechen, z. B. E-Mail-Adressen, Telefonnummern und URLs.
• Prüfen Sie, ob reguläre Ausdrücke für die Validierung komplexer Formate implementiert sind, und stellen Sie sicher, dass sie effizient und sicher sind.

// Schlechte Praxis
public IActionResult SubmitForm(string userInput) {
    // No length check
    Database.Save(userInput); // Risk of buffer overflow or inefficient database use
}

//Bewährte Verfahren
public IActionResult SubmitForm(string userInput) {
    if (userInput.Length > 100) {
        return BadRequest("Input too long.");
    }
    Database.Save(userInput); // Input length is controlled
}

Überprüfen Sie immer die Länge der Eingaben, bevor Sie sie verarbeiten, um sicherzustellen, dass sie den Anforderungen Ihrer Anwendung entsprechen und einen Ressourcenmissbrauch verhindern

Grenzwertanalyse:

• Testen Sie die Eingabevalidierung anhand von Grenzwerten, wie z. B. maximal und minimal zulässigen Werten.
• Stellen Sie sicher, dass Werte, die außerhalb des zulässigen Bereichs liegen, ordnungsgemäß verarbeitet werden und nicht zum Absturz der Anwendung führen.
• Validierung numerischer Eingaben, um sicherzustellen, dass sie in akzeptable Bereiche fallen und korrekt typisiert sind (z. B. Ganzzahlen vs. Gleitkommazahlen).

// Schlechte Praxis
public IActionResult CreateAccount(User user) {
    if (user.Age < 18) { // No upper boundary check
        return BadRequest("You must be at least 18 years old.");
    }
    UserRepository.Add(user);
}

//Bewährte Verfahren
public IActionResult CreateAccount(User user) {
    if (user.Age < 18 || user.Age > 99) {
        return BadRequest("Invalid age. Age must be between 18 and 99.");
    }
    UserRepository.Add(user);
}

Das Ignorieren von Grenzwerten bei der Validierung kann zu unerwartetem Verhalten oder Fehlern führen, wenn extreme Werte eingegeben werden

Typ-Prüfung:

• Stellen Sie sicher, dass Eingaben auf korrekte Datentypen wie Strings, Ganzzahlen und Boolesche Werte geprüft werden.
• Prüfen Sie, ob typsichere Funktionen und Bibliotheken verwendet werden, um Datentypbeschränkungen durchzusetzen.
• Validierung von JSON- und XML-Eingaben, um sicherzustellen, dass sie den erwarteten Schemata und Strukturen entsprechen.

// Schlechte Praxis
public void ProcessJson(string jsonString) {
    var data = JsonConvert.DeserializeObject(jsonString); // No validation against schema
    // Process data
}

// Bewährte Verfahren
public IActionResult ProcessJson(string jsonString) {
    JSchema schema = JSchema.Parse(File.ReadAllText("MyObjectSchema.json"));
    JObject jsonObject = JObject.Parse(jsonString);
    if (!jsonObject.IsValid(schema)) {
        return BadRequest("Invalid JSON format.");
    }
    var data = jsonObject.ToObject();
    // Process data
}

Akzeptieren von JSON- oder XML-Daten ohne Validierung anhand eines Schemas, was dazu führen kann, dass ungeeignete Datenstrukturen durchgelassen werden

Kodierung:

• Sicherstellen, dass die Eingabedaten vor der Verarbeitung oder Speicherung ordnungsgemäß kodiert werden.
• Prüfen Sie, ob für verschiedene Kontexte geeignete Kodierungstechniken verwendet werden, z. B. URL-Kodierung, HTML-Kodierung und base64-Kodierung.
• Überprüfen Sie, ob die kodierten Daten vor der weiteren Verarbeitung korrekt dekodiert und validiert werden.

// Schlechte Praxis
public string GetUserProfileHtml(string username) {
    return $"
Hello, {username}!
"; // Risk of XSS if username contains HTML/JS
}

// Bewährte Verfahren
public string GetUserProfileHtml(string username) {
    return $"
Hello, {HttpUtility.HtmlEncode(username)}!
"; // Safely encode to prevent XSS
}

Anzeige von unverschlüsselten Benutzereingaben in HTML, die zu Cross-Site Scripting (XSS)-Schwachstellen führen können

Datei-Uploads:

• Überprüfen Sie den Dateityp, die Größe und den Inhalt, bevor Sie Datei-Uploads akzeptieren.
• Stellen Sie sicher, dass hochgeladene Dateien an einem sicheren Ort mit eingeschränktem Zugriff gespeichert sind.
• Überprüfen Sie, ob Virenscans und Malware-Erkennung für hochgeladene Dateien implementiert sind.
• Überprüfen Sie, ob Dateinamen und -pfade bereinigt sind, um Angriffe auf Verzeichnistraversal zu verhindern.

Eingaben von Drittanbietern:

• Validierung und Bereinigung von Eingaben, die von Drittanbieterquellen wie APIs und Webhooks stammen.
• Sicherstellen, dass Daten von Drittanbietern mit dem gleichen Maß an Sorgfalt behandelt werden wie Benutzereingaben.
• Überprüfen Sie die Integrität und Authentizität der von externen Quellen erhaltenen Daten.

Authentifizierung

Die Authentifizierung ist entscheidend, um die Identität des Benutzers zu überprüfen und sicherzustellen, dass nur legitime Benutzer auf das System zugreifen können. Eine ordnungsgemäße Authentifizierung schützt Ihre Daten und alles andere, was sich im System befindet, vor neugierigen Blicken. Ein kürzlich aufgetretener Datenschutzverstoß bei Snowflake bestätigte, dass Benutzer mit Ein-Faktor-Authentifizierung für Hacker das Tor zur Kompromittierung hunderter anderer Konten sein können.

Passwort-Verwaltung:

• Stellen Sie sicher, dass Passwörter mit starken Hashing-Algorithmen wie bcrypt, Argon2 oder Scrypt gespeichert werden.
• Überprüfen Sie die Umsetzung von Passwortrichtlinien, einschließlich der Anforderungen an Mindestlänge, Komplexität und Ablaufdatum.
• Prüfen Sie, ob es sichere Mechanismen zum Zurücksetzen und Wiederherstellen von Kennwörtern gibt, die keine sensiblen Informationen preisgeben.
• Sicherstellen, dass die Benutzer bei der ersten Anmeldung aufgefordert werden, ihre Standardkennwörter zu ändern.

// Schlechte Praxis
public bool IsValidPassword(string password) {
    return !string.IsNullOrEmpty(password); // Only checks if password is not empty
}

// Bewährte Verfahren
public bool IsValidPassword(string password) {
    var hasMinimum8Chars = password.Length >= 10;
    var hasUpperCase = password.Any(char.IsUpper);
    var hasLowerCase = password.Any(char.IsLower);
    var hasDecimalDigit = password.Any(char.IsDigit);
    var hasSpecialChar = password.Any(p => !char.IsLetterOrDigit(p));

    return hasMinimum8Chars && hasUpperCase && hasLowerCase && hasDecimalDigit && hasSpecialChar;
}

Implementierung und Durchsetzung von Kennwortrichtlinien, die eine Mindestlänge vorschreiben und Komplexitätsanforderungen enthalten

Multi-Faktor-Authentifizierung (MFA):

• Sicherstellen, dass MFA für wichtige Benutzerkonten und Vorgänge implementiert und durchgesetzt wird.
• Überprüfen Sie die Verwendung sicherer zweiter Faktoren, wie Hardware-Token, SMS-Codes oder Authentifizierungs-Apps.
• Sicherstellen, dass die MFA-Mechanismen gegen gängige Angriffe wie Phishing und Man-in-the-Middle widerstandsfähig sind.
• Validierung der MFA-Implementierung für verschiedene Authentifizierungsabläufe, wie Anmeldung und Zurücksetzen des Passworts.

Sichere Login-Mechanismen:

• Validieren Sie die Implementierung sicherer Anmeldeformulare und stellen Sie sicher, dass die Daten über HTTPS übertragen werden.
• Sicherstellen, dass die Anzahl der Anmeldeversuche begrenzt ist, um Brute-Force-Angriffe zu verhindern.
• Überprüfen Sie den sicheren Umgang mit Sitzungs-Token und Cookies während des Authentifizierungsprozesses.
• Sicherstellen, dass Fehlermeldungen bei der Anmeldung nicht erkennen lassen, ob der Benutzername oder das Passwort falsch war.

// Schlechte Praxis
public IActionResult Login(string username, string password) {
    if (Authenticate(username, password)) {
        // User authenticated
    } else {
        // Authentication failed
    }
}

// Bewährte Verfahren
public IActionResult Login(string username, string password) {
    if (!IsAllowedToAttempt(username)) {
        return BadRequest("Too many failed login attempts. Please try again later.");
    }

    if (Authenticate(username, password)) {
        ResetAttemptCounter(username);
        // User authenticated
    } else {
        IncrementAttemptCounter(username);
        // Authentication failed
    }
}

Erlauben unbegrenzter Anmeldeversuche ohne jegliche Prüfung vs. Implementierung einer Ratenbegrenzung zur Verhinderung von Brute-Force-Angriffen

Token-basierte Authentifizierung:

• Gewährleistung der sicheren Generierung, Speicherung und Validierung von Authentifizierungs-Tokens, wie z. B. JWT und OAuth.
• Überprüfen Sie, ob die Token mit starken Algorithmen signiert und verschlüsselt werden.
• Prüfen Sie, ob kurzlebige Token und Refresh-Tokens implementiert sind, um die Auswirkungen eines Token-Diebstahls zu minimieren.
• Sicherstellen, dass Token beim Abmelden des Benutzers oder bei Ablauf der Sitzung ungültig gemacht werden.

Autorisierung

Nach der Authentifizierung des Benutzers wird bei der Autorisierung geprüft, was der Benutzer tun darf. Dieser Teil der App stellt sicher, dass nur Benutzer mit den richtigen Berechtigungen auf bestimmte Dinge zugreifen oder bestimmte Aktionen durchführen können. Bei der Überprüfung achten wir auf folgende Punkte.

Rollenbasierte Zugriffskontrolle (Role-Based Access Control, RBAC):

• Sicherstellen, dass Benutzerrollen und -berechtigungen klar definiert und implementiert sind.
• Überprüfen Sie, ob die Zugriffskontrolle auf der Serverseite für jede sensible Operation durchgeführt wird.
• Sicherstellen, dass Benutzer nur Aktionen durchführen und auf Ressourcen zugreifen können, die ihren Rollen entsprechen.

// Schlechte Praxis
public bool CanAccessResource(string role)
{
    if (role == "Admin" || role == "User") // Unclear distinction
        return true;
    return false;
}

// Bewährte Verfahren
public bool CanAccessResource(string role)
{
    if (role == "Admin")
        return true;
    if (role == "User")
        return false; // Specific access defined per role
}

Mehrdeutige Rollendefinitionen vs. klar definierte Rollen und Berechtigungen

Prinzip der geringsten Berechtigung:

• Überprüfen Sie, ob die Anwendung das Prinzip der geringsten Berechtigung durchsetzt, indem sie den Benutzern die erforderlichen Mindestberechtigungen erteilt.
• Sicherstellen, dass sensible Aktionen eine zusätzliche Autorisierung oder Bestätigung erfordern.
• Prüfen Sie, ob die Aufgabentrennung zur Vermeidung von Interessenkonflikten umgesetzt wurde.
• Erkundigen Sie sich, ob es eine regelmäßige Überprüfung und Kontrolle der Benutzerrollen und -berechtigungen gibt, um übermäßige Privilegien zu erkennen.

Zugriffskontrolllisten (ACLs):

• Sicherstellen, dass ACLs implementiert sind, um den Zugriff auf Ressourcen auf der Grundlage von Benutzerrollen und -attributen zu kontrollieren.
• Überprüfen Sie die sichere Speicherung und Handhabung von ACLs.
• Überprüfung der einheitlichen Durchsetzung von ACLs in der gesamten Anwendung.
• Prüfen Sie, ob ACLs regelmäßig aktualisiert werden, um Änderungen der Benutzerrollen und -berechtigungen zu berücksichtigen.

Attribut-basierte Zugriffskontrolle (ABAC):

• Überprüfen Sie die Implementierung von ABAC und stellen Sie sicher, dass die Zugriffsentscheidungen auf Benutzerattributen und Umgebungsbedingungen basieren.
• Sicherstellen, dass die Richtlinien für ABAC klar definiert sind und regelmäßig überprüft werden.
• Validierung der einheitlichen Durchsetzung von ABAC-Regeln in der gesamten Anwendung.
• Sicherstellen, dass die Richtlinien flexibel sind, um Änderungen der Benutzerrollen und Umgebungsbedingungen zu berücksichtigen.

Erzeugung und Speicherung von Sitzungs-Token:

• Überprüfen Sie die Verwendung von kryptographisch sicheren Zufallszahlengeneratoren für die Token-Erstellung.
• Überprüfen Sie, ob die Sitzungs-Tokens ausreichend lang und komplex sind, um Ratenangriffe zu verhindern.
• Sicherstellen, dass Sitzungs-Tokens sicher auf der Client-Seite gespeichert werden, indem sichere Cookies mit geeigneten Attributen wie HttpOnly, Secure, SameSite verwendet werden.
• Sicherstellen, dass Sitzungs-Tokens nicht in URLs oder an anderen unsicheren Stellen offengelegt werden.

// Schlechte Praxis
public string GenerateSimpleToken() {
    return Guid.NewGuid().ToString().Substring(0, 8);  // Too short and not complex enough
}

// Bewährte Verfahren
public string GenerateSecureToken() {
    using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider()) {
        byte[] tokenData = new byte[64]; // 512 bits
        rng.GetBytes(tokenData);
        return Convert.ToBase64String(tokenData);  // Long and complex
    }
}

Sicherstellen, dass die Sitzungs-Tokens lang und komplex genug sind, um Ratenangriffe zu verhindern

Ablauf von Sitzungen und Ungültigmachung:

• Implementieren Sie Richtlinien zum Ablauf von Sitzungen, um die Dauer von Sitzungen zu begrenzen und so das Risiko eines Hijacking-Angriffs zu verringern.
• Sicherstellen, dass Sitzungen bei Abmeldung oder Inaktivität des Benutzers ungültig gemacht werden.
• Sicherstellen, dass Sitzungs-Tokens bei Passwortänderungen oder anderen kritischen Sicherheitsereignissen für ungültig erklärt werden.
• Implementierung von Mechanismen zur Erkennung und Beendigung doppelter oder gleichzeitiger Sitzungen desselben Benutzers.
• Implementierung von Timeouts für inaktive Sitzungen, um Benutzer nach einer gewissen Zeit der Inaktivität automatisch abzumelden.
• Überprüfen Sie, ob die Sitzungszeitüberschreitungen angemessen konfiguriert sind, um ein Gleichgewicht zwischen Sicherheit und Benutzerfreundlichkeit herzustellen.

// Schlechte Praxis
public void ChangePassword(string newPassword) {
    // Password is changed, but session remains valid
    UpdatePassword(newPassword);
}

// Bewährte Verfahren
public void Logout() {
    Session.Abandon();  // Invalidate the session upon logout
}

public void ChangePassword(string newPassword) {
    UpdatePassword(newPassword);
    Session.Abandon();  // Invalidate the session after a password change
}

Ungültigmachen von Sitzungs-Tokens bei sicherheitsrelevanten Ereignissen, um Session-Hijacking zu verhindern

Auditing und Protokollierung:

• Sicherstellen, dass Authentifizierungs- und Autorisierungsereignisse zu Überwachungs- und Prüfzwecken protokolliert werden.
• Überprüfen Sie, ob die Protokolle Details wie Benutzer-ID, durchgeführte Aktion und Zeitstempel enthalten.
• Sicherstellen, dass die Protokolle keine sensiblen Informationen enthalten und sicher gespeichert werden.

Sicherheit von Verwaltungsfunktionen:

• Sicherstellen, dass administrative Funktionen und Schnittstellen durch starke Authentifizierungs- und Autorisierungsmechanismen geschützt sind.

Überprüfen Sie, ob Verwaltungsaktionen protokolliert und auf verdächtige Aktivitäten überwacht werden.

Prüfen Sie, ob zusätzliche Sicherheitsmaßnahmen, wie MFA und IP-Whitelisting, für Administratorkonten implementiert sind.

Sicherstellen, dass die Verwaltungsfunktionen segmentiert und nur für autorisierte Benutzer zugänglich sind.

Datenschutz

Der Datenschutz gewährleistet, dass sensible Informationen während ihres gesamten Lebenszyklus sicher gehandhabt werden, von der Erfassung und Speicherung bis zur Verarbeitung und Entsorgung. Im Folgenden erfahren Sie, wie Sie die Daten Ihrer Nutzer schützen können, um unbefugten Zugriff, Datenschutzverletzungen und Datenlecks zu verhindern.

Datenverschlüsselung:

• Stellen Sie sicher, dass sensible Daten sowohl im Ruhezustand als auch bei der Übertragung mit starken Verschlüsselungsalgorithmen (AES-256, TLS 1.2/1.3) und Kommunikationsprotokollen (HTTPS, SSH) verschlüsselt werden.
• Sicherstellen, dass die Verschlüsselungsschlüssel sicher verwaltet werden, mit ordnungsgemäßer Schlüsselrotation und Aufbewahrungspraktiken.
• Sicherstellen, dass nur befugtes Personal Zugang zu Verschlüsselungsschlüsseln und anderen Sicherheitsnachweisen hat.
• Sicherstellen, dass Datenbankfelder mit sensiblen Informationen verschlüsselt werden.

// Schlechte Praxis
string encryptionKey = "1234567890123456";  // Hard-coded encryption key

//Bewährte Verfahren
// Using Azure Key Vault for managing encryption keys
var keyVault = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(securityTokenService));
var secret = await keyVault.GetSecretAsync("https://myvault.vault.azure.net/secrets/mysecret/");

Verwenden Sie ein sicheres Schlüsselverwaltungssystem, wie Azure Key Vault oder AWS Key Management Service, um Verschlüsselungsschlüssel zu verwalten

Datenmaskierung und Anonymisierung:

• Stellen Sie sicher, dass sensible Daten maskiert oder anonymisiert werden, wenn sie in Benutzeroberflächen oder Protokollen angezeigt werden.
• Implementieren Sie Datenmaskierungstechniken für Nicht-Produktionsumgebungen, um die Offenlegung von echten Daten zu verhindern.
• Überprüfen Sie die Wirksamkeit von Anonymisierungstechniken, um eine erneute Identifizierung von Personen zu verhindern.
• Sicherstellen, dass sensible Daten nicht in Fehlermeldungen oder Debugging-Protokollen angezeigt werden.

Sichere Datenspeicherung:

• Sicherstellen, dass sensible Daten in sicheren, zugangskontrollierten Umgebungen gespeichert werden.
• Sicherstellen, dass Datenbanken und Dateisysteme mit geeigneten Sicherheitseinstellungen konfiguriert sind.
• Prüfen Sie, ob Sicherungs- und Notfallwiederherstellungspläne implementiert sind, die eine sichere Speicherung von Sicherungsdaten vorsehen.
• Testen Sie Sicherungs- und Wiederherstellungsprozesse, um sicherzustellen, dass die Daten sicher wiederhergestellt werden können.

Integrität der Daten:

• Implementierung von Prüfungen zur Sicherstellung der Datenintegrität während der Speicherung und Übertragung.
• Überprüfung der Verwendung von kryptographischen Hashes zur Erkennung von Datenmanipulationen.
• Sicherstellen, dass Datenvalidierungsprozesse Integritätsprüfungen beinhalten.
• Überwachung und Protokollierung von Datenintegritätsproblemen zur Prüfung und Fehlerbehebung.

Datenaufbewahrung und -entsorgung:

• Sicherstellen, dass die Richtlinien zur Datenaufbewahrung eingehalten werden und Daten nur so lange wie nötig gespeichert werden.
• Prüfen Sie, ob sichere Datenlöschverfahren vorhanden sind, um sensible Daten dauerhaft zu entfernen, wenn sie nicht mehr benötigt werden.
• Überprüfen Sie, ob die Datenvernichtungsprozesse gründlich und dokumentiert sind.

Einhaltung gesetzlicher Vorschriften:

• Stellen Sie sicher, dass die Anwendung die einschlägigen Datenschutzbestimmungen wie GDPR, CCPA und HIPAA einhält.
• Überprüfen Sie die Implementierung von Mechanismen zur Einwilligung der Nutzer in die Datenerfassung und -verarbeitung.
• Sicherstellen, dass die Nutzer ihre Datenschutzrechte ausüben können, z. B. Zugriff, Korrektur und Löschung.
• Prüfen Sie, ob die Datenschutzpraktiken und -richtlinien dokumentiert sind, um die Einhaltung der Vorschriften bei Audits nachzuweisen.

Überwachung und Protokollierung:

• Prüfen Sie, ob Überwachungssysteme implementiert sind, um unbefugten Zugriff auf sensible Daten zu erkennen.
• Überprüfung der Protokolle auf Anzeichen von Datenschutzverletzungen oder anderen Sicherheitsvorfällen.

Reaktion auf Datenverletzungen:

• Sicherstellen, dass ein Plan zur Reaktion auf Datenschutzverletzungen vorhanden ist und regelmäßig getestet wird.
• Überprüfen Sie, ob der Plan Verfahren zur Erkennung, Eindämmung und Begrenzung von Datenschutzverletzungen enthält.

Umgang mit Daten von Drittanbietern:

• Sicherstellen, dass Drittanbieter die Datenschutzanforderungen einhalten.
• Überprüfen Sie, ob die mit Dritten geteilten Daten verschlüsselt und sicher übertragen werden.
• Prüfen Sie, ob Vereinbarungen über die gemeinsame Nutzung von Daten, in denen die Verantwortlichkeiten und Sicherheitsmaßnahmen festgelegt sind, umgesetzt werden.

Fehlerbehandlung

Eine ordnungsgemäße Fehlerbehandlung stellt sicher, dass die Anwendung Fehler ordnungsgemäß behandelt, die Funktionalität aufrechterhält und keine sensiblen Informationen preisgibt. Verfügt Ihre Anwendung über robuste Mechanismen zur Fehlerbehandlung? Es ist höchste Zeit, dies herauszufinden!

Anständige Fehlerbehandlung:

• Stellen Sie sicher, dass die Anwendung Fehler zuverlässig behandelt, ohne sensible Informationen preiszugeben.
• Überprüfen Sie, ob benutzerfreundliche Fehlermeldungen angezeigt werden und vermeiden Sie technische Details, die Angreifern helfen könnten.
• Prüfen Sie, ob die Mechanismen zur Fehlerbehandlung einen Absturz der Anwendung verhindern und die Funktionalität so weit wie möglich aufrechterhalten.

Fehler bei der Eingabevalidierung:

• Überprüfen Sie, ob alle Eingabevalidierungsfehler angemessen behandelt werden, und geben Sie den Benutzern eine klare Rückmeldung.
• Sicherstellen, dass Validierungsfehler keine sensiblen Informationen oder Details der Anwendungslogik preisgeben.

• Prüfen Sie, ob die Behandlung von Validierungsfehlern in der gesamten Anwendung einheitlich ist.

// Schlechte Praxis
if (!UserExists(username)) {
    return Error("Username not found.");
}
if (!CorrectPassword(username, password)) {
    return Error("Incorrect password.");
}

// Bewährte Verfahren
if (!Authenticate(username, password)) {
    return Error("Invalid username or password.");
}

Verwendung allgemeiner Fehlermeldungen, aus denen nicht hervorgeht, welcher Teil der Authentifizierung fehlgeschlagen ist

Behandlung von Ausnahmen:

• Stellen Sie sicher, dass alle Ausnahmen abgefangen und ordnungsgemäß behandelt werden, um einen Absturz der Anwendung zu verhindern.
• Stellen Sie sicher, dass try-catch-Blöcke in geeigneter Weise verwendet werden, um Ausnahmen zu behandeln, ohne dass der Benutzer Details erfährt.
• Prüfen Sie, ob globale Exception-Handler implementiert sind, um unerwartete Fehler zu behandeln und sicher zu protokollieren.

Ressourcen-Management:

• Sicherstellen, dass Ressourcen wie Datenbankverbindungen, Dateien und Netzwerk-Sockets nach einem Fehler ordnungsgemäß geschlossen und freigegeben werden.
• Vergewissern Sie sich, dass Ressourcenlecks durch die Implementierung einer robusten Fehlerbehandlung für die Ressourcenverwaltung verhindert werden.

Spezifische Fehlerbehandlungsszenarien:

• Überprüfen Sie, ob die Anwendung bestimmte Fehlerszenarien wie Netzwerkausfälle, Datenbankfehler und Ausfälle von Drittanbieterdiensten korrekt behandelt.
• Sicherstellen, dass Fallback-Mechanismen vorhanden sind, um die Anwendungsfunktionalität während dieser Fehler aufrechtzuerhalten.

Protokollierung

Sichere Protokollierungspraktiken sind entscheidend für die Überwachung des Betriebs der App, die Diagnose von Problemen und die Unterstützung von Sicherheitsuntersuchungen. Denken Sie daran, dass die Protokolle detailliert und sicher sein und den Vorschriften entsprechen müssen.

Sensibilität der Protokolle:

• Stellen Sie sicher, dass sensible Informationen wie Kennwörter, API-Schlüssel und persönliche Daten niemals protokolliert werden.
• Überprüfen Sie, ob die Protokolle bereinigt wurden, um sensible Informationen vor der Speicherung zu entfernen oder zu maskieren.
• Prüfen Sie, ob es Protokollierungsrichtlinien gibt, die festlegen, welche Informationen protokolliert werden dürfen und welche nicht.

Vollständigkeit und Detailliertheit der Protokolle:

• Sicherstellen, dass die Protokolle genügend Details erfassen, um Probleme zu diagnostizieren und Aktivitäten nachzuvollziehen.
• Überprüfen Sie, ob die Protokolle wichtige Informationen wie Zeitstempel, Benutzer-IDs, IP-Adressen und Fehlerdetails enthalten.
• Sicherstellen, dass die Protokolleinträge konsistent und für eine einfache Analyse strukturiert sind.

// Schlechte Praxis
Log.Error("Operation failed"); // Bad: No context or details provided

// Bewährte Verfahren
Log.Error($"Operation failed at {DateTime.UtcNow} by UserID {userID}. Error: {errorDetail}");

Protokolle, denen die notwendigen Details fehlen, erschweren die Fehlersuche

Sicherheit der Protokollspeicherung:

• Überprüfen Sie, ob die Protokolle an einem sicheren Ort mit eingeschränktem Zugriff gespeichert werden.
• Sicherstellen, dass Protokolle durch Integritätsprüfungen oder kryptografische Schutzmaßnahmen vor Manipulationen geschützt sind.
• Prüfen Sie, ob Aufbewahrungsrichtlinien implementiert sind, um Protokolle nach einem bestimmten Zeitraum sicher zu archivieren oder zu löschen.

// Schlechte Praxis
var logFilePath = @"C:\SharedFolder\applog.txt";

// Bewährte Verfahren
var logFilePath = @"C:\SecureLogs\applog.txt";
FileSystemAccessRule rule = new FileSystemAccessRule("LogAccessGroup", FileSystemRights.ReadData, AccessControlType.Allow);

Speicherung von Protokollen in einem gemeinsamen Ordner vs. Speicherung von Protokollen an einem sicheren Ort mit eingeschränktem Zugriff auf Basis von Rollen

Protokollüberwachung und Alarmierung:

• Sicherstellen, dass die Protokollierungsmechanismen eine Echtzeitüberwachung umfassen, um Sicherheitsereignisse zu erkennen und darauf zu reagieren.
• Überprüfen Sie, ob Warnungen für kritische Fehler, Sicherheitsvorfälle und verdächtige Aktivitäten konfiguriert sind.
• Überprüfen Sie, ob Überwachungswerkzeuge implementiert sind, um Protokolldaten zu analysieren und verwertbare Erkenntnisse zu gewinnen.

Log Rotation und Wartung:

• Prüfen Sie, ob Richtlinien zur Protokollrotation implementiert sind, um die Größe der Protokolldateien zu verwalten und die Leistung aufrechtzuerhalten.
• Sicherstellen, dass alte Protokolle sicher archiviert werden und bei Bedarf zur Analyse abgerufen werden können..
• Überprüfen Sie, ob die Protokollrotation und -archivierung die Protokollierungsfunktionalität nicht unterbricht..

Bibliotheken und Abhängigkeiten von Drittanbietern

Um Funktionen schneller zu entwickeln, verwenden Entwickler häufig Bibliotheken von Drittanbietern. Aber so wie ein fehlerhafter Ziegelstein eine Mauer schwächt, kann eine anfällige Bibliothek oder eine unsichere Integration Ihre Anwendung gefährden. Ein Beispiel hierfür ist Cylance, dessen Daten von einer Drittanbieterplattform gestohlen wurden. Aus diesem Grund sollten externe Komponenten ordnungsgemäß gewartet werden, um solche Folgen zu minimieren.

Verwaltung von Abhängigkeiten:

• Stellen Sie sicher, dass alle Bibliotheken und Abhängigkeiten von Drittanbietern mit einem Paketmanager wie npm, pip oder Maven verwaltet werden.
• Überprüfen Sie, ob es eine klare Richtlinie für das Hinzufügen neuer Abhängigkeiten gibt, einschließlich Sicherheitsbewertungen und Genehmigungen.
• Überprüfen Sie das Vorhandensein einer Manifestdatei für Abhängigkeiten (z. B. package.json, requirements.txt), in der alle Abhängigkeiten und ihre Versionen aufgeführt sind.

Versionskontrolle und Updates:

• Prüfen Sie, ob die Bibliotheken von Drittanbietern auf die neuesten sicheren Versionen aktualisiert sind.
• Prüfen, ob Aktualisierungen von Abhängigkeiten in einer Staging-Umgebung getestet werden, bevor sie in der Produktion eingesetzt werden.
• Überwachen Sie Sicherheitshinweise und Datenbanken für Sicherheitslücken (z. B. CVE, NVD) auf Aktualisierungen für verwendete Abhängigkeiten.
• Verwendung automatischer Schwachstellen-Scan-Tools wie Snyk, Dependabot, OWASP Dependency-Check, um bekannte Schwachstellen in Bibliotheken von Drittanbietern zu erkennen.
• Überprüfung der Reputation und der Wartungsaktivitäten der Autoren und Mitwirkenden der Bibliothek.

Einhaltung von Lizenzen:

• Sicherstellen, dass alle Bibliotheken von Drittanbietern mit den Lizenzrichtlinien des Unternehmens übereinstimmen.
• Überprüfen Sie, ob die Lizenzen für alle Abhängigkeiten dokumentiert und auf rechtliche Konformität überprüft wurden.
• Achten Sie auf Bibliotheken mit restriktiven oder inkompatiblen Lizenzen, die zu rechtlichen Problemen führen könnten.

Isolierung und Sandboxing:

• Prüfen Sie, ob Bibliotheken von Drittanbietern in einer kontrollierten Umgebung isoliert werden, um ihre Auswirkungen auf die Anwendung zu begrenzen.
• Überprüfen Sie, ob Sandboxing-Techniken implementiert sind, um Code von Drittanbietern mit eingeschränkten Rechten auszuführen.
• Sicherstellen, dass Komponenten von Drittanbietern keinen unnötigen Zugriff auf sensible Daten oder Systemressourcen haben.

Codeüberprüfung und Auditing:

• Überprüfen Sie den Quellcode kritischer Bibliotheken von Drittanbietern, um potenzielle Sicherheitsprobleme zu identifizieren.
• Sicherstellen, dass die Bibliotheken von Drittanbietern regelmäßigen Sicherheitsprüfungen durch ihre Betreuer oder externe Prüfer unterzogen werden.
• Überprüfen Sie, ob die Bibliotheken über ein transparentes Verfahren zur Meldung und Behebung von Sicherheitslücken verfügen.

Konfiguration und Anpassung:

• Stellen Sie sicher, dass die Bibliotheken von Drittanbietern gemäß den bewährten Verfahren sicher konfiguriert sind.
• Prüfen Sie ggf. alle Anpassungen und untersuchen Sie sie auf Sicherheitsaspekte.

Überwachung und Alarmierung:

• Prüfen Sie, ob Überwachungswerkzeuge implementiert sind, um die Leistung und das Verhalten von Drittanbieter-Bibliotheken in der Produktion zu verfolgen.
• Prüfen Sie, ob Warnmeldungen für abnormale Aktivitäten oder Leistungsprobleme im Zusammenhang mit Komponenten von Drittanbietern eingerichtet sind.
• Überprüfung von Protokollen und Metriken zur Identifizierung potenzieller Sicherheitsvorfälle im Zusammenhang mit Bibliotheken von Drittanbietern.

Audit der Codesicherheit: Was Sie von diesem Service erwarten können

Ihr Produkt benötigt eine gründliche Überprüfung der Codesicherheit. Sie vergleichen Anbieter, fragen sich aber vielleicht – was genau bekomme ich? Wie kann ich die Ergebnisse nutzen? Wir können Ihnen helfen! Bei Redwerk gliedern wir die Ergebnisse Ihres Code-Audits in klare, umsetzbare Schritte.

1. Leicht verständlicher Berich

Wir stellen Ihnen eine Liste der Probleme mit Erklärungen zur Verfügung und erläutern, warum sie wichtig sind. Der Bericht ist gut strukturiert und unterteilt in Architekturüberprüfung, Datenbanküberprüfung, Codequalität, Testabdeckung und Sicherheitsüberprüfung.

Dieser Bericht wird zu Ihrem Fahrplan für die Behebung von Problemen und die Verbesserung Ihres Produkts. Wir haben Complete Network zum Beispiel dabei geholfen, ein kritisches Sicherheitsproblem im Zusammenhang mit der Speicherung sensibler Daten in einem öffentlich zugänglichen Ordner zu identifizieren. Außerdem haben wir drei einfache Möglichkeiten aufgezeigt, wie die Leistung der Anwendung verbessert werden kann, sowie weitere Verbesserungen der Codequalität, die zu einer um 80 % höheren Wartungsfreundlichkeit führten.

2. Experten-Empfehlungen

Wir weisen nicht nur auf Probleme hin, wir bieten auch Lösungen an. Unser Bericht enthält Empfehlungen zur Behebung der einzelnen Probleme und zur Verbesserung der Gesamtqualität Ihres Codes. Außerdem kategorisieren wir die Schwachstellen nach ihrem Schweregrad, damit Sie wissen, was Sie zuerst angehen müssen.

Bei der Überprüfung einer Network Mapping App haben wir beispielsweise festgestellt, dass die Codequalität der Hauptgrund für die Schwachstellen war. Die Architektur war solide, und es gab keine Sicherheitsprobleme. Der Backend-Code war jedoch so geschrieben, dass die zukünftige Entwicklung und das Onboarding neuer Entwickler teuer werden würde.

3. Reparieren Sie es selbst oder lassen Sie uns helfen

Sie haben die Kontrolle! Verwenden Sie unseren Bericht mit jedem Entwickler – Ihrem internen Team, Freiberuflern oder wem auch immer Sie vertrauen. Wenn Sie jedoch Hilfe wünschen, können wir die Probleme auch selbst beheben. Unser Bericht enthält sogar eine Schätzung der Zeit, die für die Behebung aller Fehler benötigt wird.

Stoppen Sie Code-Probleme, bevor sie entstehen. Wenden Sie sich jetzt an uns, um ein klares Bild vom Zustand Ihrer Anwendung zu erhalten!