Verhindern von Problemen mit GitHub Copilot

  • 6 Minuten

Das Verhindern von Sicherheitsproblemen, bevor sie auftreten, ist effizienter als das Beheben nach der Bereitstellung. In dieser Lektion wird erläutert, wie Sie GitHub Copilot proaktiv während der Entwicklung verwenden, um sicheren Code von Anfang an zu schreiben.

Proaktive Sicherheits-Denkweise

Der kostengünstigste Fehler ist der, den Sie nie einführen. Während es wertvoll ist, zu lernen, Sicherheitsprobleme schnell zu beheben, ist es weitaus besser, sie von vornherein zu verhindern. Diese Umstellung von reaktiv zu proaktiver Sicherheit erfordert die Integration sicherer Codierungsmethoden und -tools wie GitHub Copilot in Ihren täglichen Entwicklungsworkflow.

Berücksichtigen Sie die relativen Kosten:

  • Während der Codierung: Minimale Kosten – schreiben Sie sie beim ersten Mal richtig.
  • Während der Codeüberprüfung: Niedrige Kosten – Erkennen und Beheben vor dem Zusammenführen.
  • Während der QA-Tests: Moderate Kosten – erfordert erneute Tests und potenziell Auswirkungen auf den Zeitplan.
  • In der Produktion: Hohe Kosten – Notfallkorrekturen, potenzielle Sicherheitsvorfälle, Reputationsschäden.

Durch die Erstellung von Sicherheit von Anfang an reduzieren Sie sowohl Kosten als auch Risiken erheblich.

GitHub Copilot als sicherheitsorientierter Codierungspartner

GitHub Copilot kann Ihnen beim Schreiben von sicherem Code am Anfang der Entwicklung helfen, nicht nur beim Beheben von Problemen.

Schreiben von sicherem Code von Grund auf

Kommunizieren Sie beim Starten neuer Funktionen oder Features die Sicherheitsabsicht durch Kommentare und Eingabeaufforderungen. GitHub Copilot verwendet diesen Kontext, um sichere Implementierungen vorzuschlagen.

Beachten Sie den folgenden Codekommentar:

// Query database for user by name using parameterized query to prevent SQL injection

GitHub Copilot wertet die im Kommentar beschriebene Absicht aus, überprüft den Kontext des codes, der im Editor geöffnet ist, und generiert dann vorgeschlagenen Code mithilfe sicherer Codierungsmuster. In diesem Fall schlägt GitHub Copilot wahrscheinlich etwas ähnliches wie den folgenden Code vor, anstatt eine Zeichenfolgenverkettung für SQL-Abfragen vorzuschlagen:

string query = "SELECT * FROM Users WHERE Name = @name";
using (SqlCommand command = new SqlCommand(query, connection))
{
    command.Parameters.AddWithValue("@name", userName);
    using (SqlDataReader reader = command.ExecuteReader())
    {
        // Process results
    }
}

Indem Sie klar beabsichtigte Kommentare schreiben, die GitHub Copilot auf sichere Muster ausrichten, wenden Sie die KI-Schulung auf Millionen von Codebeispielen an, um standardmäßig bewährte Implementierungen zu erhalten.

Sie können auch die Chatansicht von GitHub Copilot verwenden, um sichere Codierungsmethoden zu erkunden. Wenn Sie beispielsweise Hilfe bei der Implementierung von Kennworthashing benötigen, können Sie die folgende Eingabeaufforderung in die Chatansicht eingeben:

How do I hash a password using a secure, industry-standard algorithm with automatic salting?

GitHub Copilot wertet Ihre Eingabeaufforderung aus, verwendet den code, der im Editor für den Kontext geöffnet ist, und schlägt dann Code vor, der eine gut angesehene Bibliothek und sichere Methoden verwendet. Beispielsweise könnte der folgende Code vorgeschlagen werden:

string hashedPassword = BCrypt.Net.BCrypt.HashPassword(password);

Die Verwendung von GitHub Copilot kann Ihnen dabei helfen, sichere Muster von Anfang an zu implementieren, wodurch die Wahrscheinlichkeit verringert wird, dass Sicherheitsrisiken eingeführt werden.

Kontinuierliche Validierung während der Entwicklung

GitHub Copilot kann während des Codes als Echtzeit-Sicherheitsberater fungieren. Sie können GitHub Copilot Fragen stellen, um Ihren Ansatz beim Schreiben von Code zu überprüfen.

Hier sind einige Beispielaufforderungen, die für die Sicherheitsüberprüfung verwendet werden können:

  • "Gibt es einen potenziellen Sicherheitsfehler im ausgewählten Authentifizierungsansatz?"
  • "Welche Eingabeüberprüfung soll ich zur ausgewählten Dateiuploadfunktion hinzufügen?"
  • "Entspricht der ausgewählte Verschlüsselungscode den aktuellen bewährten Methoden?"
  • "Überprüfen Sie die im Code-Editor geöffnete Datei. Gibt es Sicherheitsbedenken hinsichtlich der Art und Weise, wie ich Benutzersitzungen handhabe?

Diese Echtzeitüberprüfung wirkt wie ein sicherheitsbewusster Codeprüfer, der sofort verfügbar ist.

Integrieren von Sicherheitstools und -praktiken

GitHub Copilot ergänzt andere Sicherheitstools und -praktiken in Ihrem Entwicklungsworkflow.

Statische Analyse und Linter

Automatisierte Codeanalysetools arbeiten zusammen mit GitHub Copilot zusammen, um eine umfassende Sicherheitsabdeckung während des gesamten Entwicklungsprozesses bereitzustellen.

Kombinieren Sie Copilot mit automatisierten Codeanalysetools:

  • .NET Analyzers: Erzwingen von Codierungsstandards und Abfangen häufiger Probleme.
  • GitHub CodeQL: Suchen Sie nach Sicherheitsrisiken in Pullanforderungen.
  • Sicherheitslinters: Sprachspezifische Tools, die gefährliche Muster kennzeichnen.

GitHub Copilot hilft Ihnen beim Schreiben von Code, der weniger wahrscheinlich die Warnungen dieser Tools auslöst. Wenn Sie GitHub Copilot anweisen, parametrisierte Abfragen zu verwenden, sollte der vorgeschlagene Code SQL-Einfügeprüfungen bestehen, ohne Dass Änderungen erforderlich sind.

Berücksichtigen Sie die folgende Workflowintegration:

  1. Schreiben Sie Code mit Copilot-Unterstützung mithilfe von sicherheitsbewussten Anweisungen.
  2. Führen Sie lokale Linters und Analyzer während der Entwicklung aus.
  3. Beheben Sie alle Probleme vor dem Commit.
  4. Automatisierte CI/CD-Pipeline führt umfassende Sicherheitsüberprüfungen durch.
  5. Die Codeüberprüfung umfasst sowohl menschliche als auch automatisierte Sicherheitsprüfungen.

Dieser mehrschichtige Ansatz erfasst Probleme an mehreren Punkten. Die Verwendung von GitHub Copilot hilft Ihnen, Probleme in der frühesten Phase zu verhindern.

Codierungsstandards und Teampraktiken

Einheitliche Sicherheitsstandards in Ihrem Entwicklungsteam stellen sicher, dass alle Sicherheitsmaßnahmen einheitlich und effektiv implementieren.

Einrichten und Erzwingen sicherer Codierungsstandards:

  • Definieren Sie Teamrichtlinien für allgemeine Sicherheitspraktiken.
  • Verwenden Sie nur genehmigte kryptografische Bibliotheken (geben Sie an, welche).
  • Verketten Sie nie die Benutzereingabe in SQL-Abfragen.
  • Überprüfen Sie immer Dateipfade von der Benutzereingabe.
  • Protokollieren sie Ereignisse, keine vertraulichen Daten.
  • Verwenden Sie genehmigte Authentifizierungs-/Autorisierungsmuster.

Wenn Teammitglieder an Code arbeiten, können sie in ihren GitHub Copilot-Eingabeaufforderungen auf diese Standards verweisen. GitHub Copilot kann die Konsistenz gewährleisten, indem Code generiert wird, der mit etablierten Mustern übereinstimmt.

Präventive Sicherheitsmaßnahmen

Wenden Sie diese Methoden konsistent an, um Sicherheitsrisiken zu reduzieren.

Eingabeüberprüfung und Bereinigung

Die Überprüfung aller Benutzereingaben vor der Verarbeitung ist eine der grundlegendsten Sicherheitspraktiken zum Verhindern von Einfügungsangriffen und anderen Sicherheitsrisiken.

Jeder Einstiegspunkt für Benutzerdaten sollte eine Überprüfung enthalten. Verwenden Sie Längenbeschränkungen, Formatüberprüfung, Zulassungslistenansätze, Typüberprüfung und Bereichsüberprüfung, um Pufferüberläufe, DoS-Angriffe und böswillige Eingaben zu verhindern.

Sie können GitHub Copilot auffordern, Validierungscode zu generieren. So überprüfen Sie beispielsweise eine E-Mail-Adresse:

// Validate email address format and length before processing

GitHub Copilot schlägt möglicherweise Code vor, der auf Null-/leere Werte überprüft, Längenbeschränkungen überprüft und regex zum Überprüfen des Formats verwendet.

Prinzip des geringsten Privilegs

Das Einschränken von Berechtigungen auf das, was erforderlich ist, reduziert den potenziellen Schaden, wenn eine Sicherheitsverletzung auftritt.

Wenden Sie minimale erforderliche Berechtigungen in der gesamten Anwendung für Datenbankverbindungen, Dateisystemzugriff, API-Zugriff und Benutzerberechtigungen an. Obwohl GitHub Copilot die Infrastruktur nicht konfigurieren kann, kann es Ihnen helfen, die richtigen Berechtigungsprüfungen im Code zu implementieren.

Sichere Bibliotheksnutzung

Die Verwendung bewährter Sicherheitsbibliotheken reduziert das Risiko von Implementierungsfehlern in kritischen Sicherheitsfunktionen.

Verwenden Sie gut getestete, verwaltete Bibliotheken, anstatt sicherheitskritische Funktionen selbst zu implementieren. Wählen Sie etablierte Bibliotheken wie Entity Framework für Datenbankabfragen, ASP.NET Identität für Authentifizierung, BCrypt.Net für Kennworthashing und das Azure Key Vault SDK für die Verwaltung geheimer Schlüssel aus.

Schreiben Sie Eingabeaufforderungen, die GitHub Copilot anweisen, genehmigte Bibliotheken zu verwenden. Beispiel: "Implementieren von Passwort-Hashing mithilfe der BCrypt.Net-Bibliothek".

Testen von Sicherheitsanforderungen

Sicherheitstests überprüfen, ob Ihre Schutzmaßnahmen wie beabsichtigt funktionieren und Sicherheitsrisiken vor der Bereitstellung abfangen.

Integrieren Sie Sicherheitstests in Ihren Entwicklungsprozess. Testen Sie Randfälle für die Eingabevalidierung, Authentifizierungs- und Autorisierungsszenarien, Verschlüsselungsvorgänge, Fehlerbehandlung mit sensiblen Daten und Berechtigungsrahmen.

Sie können GitHub Copilot auffordern, Sicherheitstests zu generieren. Beispiel: "Schreiben Sie xUnit-Tests für die Funktion ValidatePath, die überprüfen, ob sie Verzeichnisüberquerungsangriffe verhindert."

Verwenden von GitHub Copilot in Codeüberprüfungen

Codeüberprüfungen sind kritische Sicherheitsprüfpunkte. GitHub Copilot für Pull-Anforderungen kann verdächtige Muster automatisch kennzeichnen, potenzielle Sicherheitsrisiken identifizieren und Verbesserungen vorschlagen.

Sie können auch GitHub Copilot Chat während manueller Überprüfungen verwenden, indem Sie Fragen wie "Gibt es Sicherheitsbedenken bei diesen Änderungen?" oder "Welche potenziellen Sicherheitsrisiken sind in diesem Code vorhanden?"

Ausgleich von Sicherheit und Produktivität

Gebäudesicherheit von Anfang an einzubauen ist schneller als nachzurüsten. Das Schreiben von sicherem Code fügt zunächst 5-10% Entwicklungszeit hinzu, während bei der Behebung von Sicherheitsproblemen später 30-50%hinzugefügt wird, und das Reagieren auf Sicherheitsvorfälle kann 200-500% oder mehr hinzufügen. GitHub Copilot beschleunigt die sichere Entwicklung, indem geeignete Muster schnell vorgeschlagen werden.

Entwickeln einer Sicherheits-first-Denkweise

Die Pflege einer Sicherheits-First-Denkweise ist für alle Entwickler unerlässlich. Ein sicherheitsorientierter Ansatz priorisiert Sicherheitsüberlegungen während des gesamten Entwicklungsprozesses, vom Design bis zur Bereitstellung.

Sie können Sicherheitsprobleme verhindern, indem Sie diese Prinzipien konsistent anwenden:

  • Gehen Sie davon aus, dass alle Eingaben bösartig sind und alles überprüfen.
  • Sicherheit trotz Fehler, ohne Daten offenzulegen oder Sicherheitsrisiken zu erstellen.
  • Verwenden Sie die Tiefenverteidigung mit mehreren Sicherheitsebenen.
  • Gewähren Sie nur die unbedingt notwendigen Berechtigungen.
  • Protokollieren Von Sicherheitsereignissen ohne Einschließen vertraulicher Daten.

Verwenden Sie GitHub Copilot, um diese Prinzipien konsistent zu implementieren, indem Sie sie in Ihre Eingabeaufforderungen und Kommentare einschließen.

Zusammenfassung

Das Verhindern von Sicherheitsproblemen während der Entwicklung ist effizienter und kostengünstiger, als sie später zu beheben. GitHub Copilot dient als proaktiver Sicherheitspartner und hilft Ihnen beim Schreiben von sicherem Code von Anfang an durch sicherheitsorientierte Eingabeaufforderungen, Echtzeitüberprüfung und Implementierung bewährter Methoden. Durch die Integration von GitHub Copilot in andere Sicherheitstools, das Einrichten von Teamstandards und die Aufrechterhaltung einer denkweise aus Sicherheitsgründen können Sie Sicherheitsrisiken in Ihrer Codebasis erheblich reduzieren.