Die Sicherheit von Go (aka golang)

Facebooktwittergoogle_plusredditpinterestlinkedinmail
Wie sicher ist Go?

Go ist eine sehr schöne Sprache, doch wie sicher ist sie für z.B. Web-Anwendungen?
Hier das Maskottchen von Go, der Gopher.

Go (oder auch golang) ist eine seit 2009 entwickelte und seit 2012 als stabil verfügbare Programmiersprache. Sie ist natürlich open-source und wird von einem kleinen Google Team betreut, wobei sich mehr und mehr eine Community bildet.
Die Sprache selbst ist eine imperative und objektorientierte Sprache, welche das Prinzip der Nebenläufigkeit direkt und unkompliziert zur Verfügung stellt. Sie wurde entwickelt, da Robert Griesemer, Rob Pike und Ken Thompson (die Initiatoren des Projektes) bisher vorhandene Sprachen für die Entwicklung von u.A. Cluster- oder Cloud-Computing Software für ungeeignet erachten. Golang soll dort einiges besser und einfacher machen.

Und jetzt?

Klingt ja erst mal ziemlich nice, dass eine Sprache Nebenläufigkeit einfach so out-of-the-box mitbringt. Auch, dass es eine sehr performante open-source Sprache ist (nicht nur wegen der Nebenläufigkeit), spricht nicht gerade gegen Go.

Doch wie sieht es da bezüglich der Nebenläufigkeit und dem bevorzugten Einsatzgebiet der Web basierten Software eigentlich in Hinsicht auf die IT-Sicherheit aus?

Eine enzige Bekannte Sicherheitslücke

Im Vergleich zu Java mit über 430 offenen Sicherheitslücken (allein in der JRE) von denen 170 als kritisch (mehr als 9/10 Punkten im Score) eingestuft sind, gibt es bei Go genau eine Sicherheitslücke, welche eher als medium eingestuft ist. Und ja, Java ist eine – im Vergleich zu Go – sehr gereifte Programmiersprache (’95er Jahrgang) und da hat sich einiges angesammelt und auch der Umfang an Bibliotheken weitaus größer als der von Go. Dennoch ist es recht interessant, dass innerhalb von sechs Jahren nur eine Sicherheitslücke gefunden wurde und Oracle permanent mit neuen zu kämpfen hat.

Die oben genannte Sicherheitslücke betrifft das Modul crpyto/tls in Go 1.1 bis 1.3.1 und ermöglicht man-in-the-middle Attacken. Mit 1.3.2 (aktuell ist 1.5.2) wurde sie bereits gefixt, was ein gutes Zeichen dafür ist, dass Go relativ sicher ist.

Go Bibliotheken sicher, fremde nicht unbedingt

Was man dennoch beachten sollte ist, dass die Benutzung von Bibliotheken (z.B. verschiedener C-Bibliotheken) eine Gefahrenquelle birgt. Es kann also trotzdem sein, dass man ein unsicheres Programm schreibt. Dies ist dann jedoch nicht die Schuld von Go, sondern entweder des Go-Entwicklers (er kann ja ggf. Alternativen wählen) und die der Bibliotheks-Entwickler.

Die Bibliotheken von Go sind dagegen relativ sicher. Klar kann man absichtlich unsicheren Code schreiben und unverschlüsselt Passwörter versenden, doch das ist keine Sicherheitslücke in Go, dass ist dann Dummheit/Unwissen/Unachtsamkeit.

Beispielsweise ist in der sql Bibliothek database/sql eine SQL-Injection (also das einschleusen von fremden SQL-Befehlen um Daten abzugreifen) zwar theoretisch möglich, jedoch wird das direkt durch geeignete Schnittstellen und einfache Verfahren zur Erstellung von Anfragen verhindert.
Des weiteren wird XSS (Cross-site-scripting) direkt von Go’s Standard HTML-Bibliothek verhindert.
Auch gibt es diverse Hashing-Verfahren für z.B. Passwörter wie etwa MD5 oder SHA1, welche teils zwar veraltet und bereits geknackt sind, doch das ist keine Sicherheitslücke, sondern in Risiko. Für wirklich sichere Hashes gibt es jedoch diverse crypto-Bibliotheken.

Sicherheit der Nebenläufigkeit

Wenn man von Nebenläufigkeit hört, stäuben sich eigentlich als Java- oder C++-Entwickler die Haare, da es relativ viel Aufwand bedeutet Prozesse zu synchronisieren und Abläufe fehlerfrei zu parallelisieren.

Benutzen vom Schlüsselwort go
package main

import (
    "fmt"
    "net/http"
    "strconv"
    "time"
)

func main() {
    t := time.Now()
    c := make(chan bool)
    for i := 0; i < 10; i++ {
        // In dick: Diese Funktion wird parallel ausgeführt
        go func(c chan bool, i int) {
            http.Get("https://de.wikipedia.org/wiki/" + strconv.Itoa(i))
            c <- true
        }(c, i)
    }
        for i := 0; i < 10; i++ {
        <-c
    }
    fmt.Println("Vergangene Zeit: ", time.Since(t))
}

In Go sieht das ganze anders aus. Hier gibt es das Schlüsselwort go, welches eine Funktion parallel zum bisherigen Thread laufen lässt. Das ganze heißt hier nicht coroutine, sondern goroutine. Auch die Synchronisation ist mit dem Channel-System sehr einfach gehalten und Speicherzugriffe können – da goroutinen non-blocking sind – durch einen Mutex kontrolliert werden.

Als Entwickler wird man hierbei nicht an die Hand genommen und es werden keine Speicherzugriffsfehler vom Compiler oder der Laufzeitumgebung verhindert, doch es werden sehr einfach zu benutzende Mittel bereitgestellt um Fehler zu verhindern.

Fazit

Allgemein ist Go eine sehr sichere Sprache und bietet viele Features, welche Fehler mit wenig Arbeit vermeiden können. Dennoch muss man natürlich beim Entwickeln ein wenig denken und muss aufpassen, dass man keine Fehler macht.

Facebooktwittergoogle_plusredditpinterestlinkedinmail

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.