Sicherheit von Go-Anwendungen: Top-10 Schwachstellen

Sicherheit von Go-Anwendungen: Top-10 Schwachstellen

Go (Golang) ist eine kompilierte, statisch typisierte Sprache, die bei Google entwickelt wurde. Dank der integrierten Unterstützung für Nebenläufigkeit, hoher Leistung und einem einfachen Speichermodell ist sie für die Erstellung von Microservices, API-Gateways, Cloud-Anwendungen und DevOps-Tools beliebt geworden. Wie jede andere Sprache ist jedoch auch Go nicht vor Sicherheitsfehlern gefeit. Entwickler verlassen sich oft auf "Sicherheit standardmäßig", was zum Auftreten schwerwiegender Schwachstellen führt. In diesem Artikel analysieren wir die Top-10 der kritischsten Sicherheitsprobleme in Go-Anwendungen und zeigen, wie man sie vermeidet.

1. SQL-Injection

Obwohl Go leistungsstarke Datenbanktreiber (database/sql) bereitstellt, machen Entwickler oft den klassischen Fehler der String-Konkatenation beim Erstellen von Abfragen.

Verwundbarer Code:

package main

import (    "database/sql"    "fmt"    _ "github.com/lib/pq")

func getUser(db *sql.DB, username string) {    // Tun Sie das niemals!    query := fmt.Sprintf("SELECT * FROM users WHERE username = '%s'", username)    rows, _ := db.Query(query)    // ...}

Lösung: Verwenden Sie parametrisierte Abfragen (prepared statements).

func getUserSafe(db *sql.DB, username string) {    query := "SELECT * FROM users WHERE username = $1"    rows, err := db.Query(query, username)    if err != nil {        // Fehlerbehandlung    }    // ...}

Die Parametrisierung maskiert automatisch Sonderzeichen und macht Injection unmöglich.

2. Cross-Site Scripting (XSS)

Go wird oft für den serverseitigen Teil von Webanwendungen verwendet. Wenn Sie Benutzereingaben ohne Maskierung zurückgeben, öffnen Sie den Weg für XSS-Angriffe.

Verwundbarer Code (Verwendung von fmt.Fprintf):

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {    name := r.URL.Query().Get("name")    fmt.Fprintf(w, "<h1>Hallo, %s!</h1>", name) // XSS!})

Lösung: Verwenden Sie das Paket html/template für automatische Maskierung.

import "html/template"

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {    tmpl := template.Must(template.New("index").Parse("<h1>Hallo, {{.}}!</h1>"))    name := r.URL.Query().Get("name")    tmpl.Execute(w, name) // Sicher})

Die Template-Engine html/template maskiert automatisch HTML-, JavaScript- und CSS-Kontexte.

3. Race Conditions

Go ist bekannt für seine leichtgewichtige Nebenläufigkeit (Goroutinen und Channels). Die falsche Verwendung gemeinsamer Ressourcen (z. B. Maps oder Zähler) ohne Synchronisation führt jedoch zu data races.

Verwundbarer Code:

var counter int

func increment() {    for i := 0; i < 1000; i++ {        counter++ // Nicht atomar!    }}

func main() {    go increment()    go increment()}

Lösung: Verwenden Sie Mutexe (sync.Mutex) oder atomare Operationen (sync/atomic).

import "sync"

var (    counter int    mu      sync.Mutex)

func increment() {    for i := 0; i < 1000; i++ {        mu.Lock()        counter++        mu.Unlock()    }}

Führen Sie Tests immer mit dem Flag -race aus: go test -race.

4. Speicher- und Goroutine-Leaks

Eine der heimtückischsten Schwachstellen in Go sind "vergessene" Goroutinen. Wenn eine Goroutine für immer blockiert (z. B. auf Daten aus einem Channel wartet, der nie geschlossen wird), führt dies zu Speicherlecks und zum Ausfall der Anwendung.

Beispiel für einen Leak: