Golang-Fehler-Expositionspfad

Golang ist eine effiziente, prägnante und sichere Programmiersprache, weist jedoch auch ihre eigenen Mängel auf, dh es ist leicht, Systempfade bei der Fehlerbehandlung aufzudecken. In diesem Artikel wird dieses Problem beschrieben und eine Lösung bereitgestellt.

1. Problemhintergrund

Golangs Fehlerbehandlungsmechanismus ist sehr entwicklerfreundlich. Wenn Sie in einer Funktion einen Fehler zurückgeben müssen, können Sie direkt eine Variable vom Typ Fehler zurückgeben. Beispiel:

func Divide(a, b int) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("cannot divide by zero")
    }
    return float64(a) / float64(b), nil
}

Wenn Sie diese Funktion verwenden, müssen Sie nur feststellen, ob die Fehlervariable Null ist, um festzustellen, ob ein Fehler aufgetreten ist. Zum Beispiel:

result, err := Divide(10, 2)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(result)

Diese Fehlerbehandlungsmethode ist sehr prägnant, effizient und wird von allen leicht akzeptiert. Allerdings enthalten die Fehlerstapelinformationen Pfadinformationen, was bedeutet, dass der Angreifer beim Auftreten eines Programmfehlers vertrauliche Informationen wie den Systempfad aus den Fehlerinformationen erhalten kann, um präzisere Angriffe durchzuführen.

2. Problemanalyse

Schauen wir uns das obige Beispiel an. Bei der Ausführung von Divide(10, 0) lautet die Fehlermeldung wie folgt:

cannot divide by zero
main.Divide
    /Users/xxx/Documents/go/src/error.go:3
main.main
    /Users/xxx/Documents/go/src/main.go:10
runtime.main
    /usr/local/go/src/runtime/proc.go:204
runtime.goexit
    /usr/local/go/src/runtime/asm_amd64.s:1371

#🎜 🎜#Okay Wie Sie sehen, können wir nicht nur die Fehlermeldung sowie die Datei- und Zeilennummer sehen, in der sich die Fehlerfunktion befindet, sondern auch den spezifischen Implementierungscode der Fehlerfunktion. Diese Art der Offenlegung von Fehlinformationen ist zu detailliert und erhöht die Erfolgswahrscheinlichkeit des Angreifers erheblich.

3. Lösung

Da das Problem nun entdeckt wurde, müssen wir eine Lösung finden. Als nächstes sind zwei mögliche Lösungen:

Benutzerdefinierter Fehlertyp

In Golang können wir Fehlertypen anpassen. Die Definition ist sehr einfach, Sie müssen lediglich die Error()-Methode der Fehlerschnittstelle implementieren. Zum Beispiel:

type MyError struct {
    Reason string
}

func (m MyError) Error() string {
    return m.Reason
}

func Divide(a, b int) (float64, error) {
    if b == 0 {
        return 0, MyError{Reason: "cannot divide by zero"}
    }
    return float64(a) / float64(b), nil
}

Auf diese Weise enthalten die Fehlerstapelinformationen bei Auftreten eines Programmfehlers keine vertraulichen Informationen wie Pfade mehr, sondern nur unsere benutzerdefinierten Fehlerinformationen. Zum Beispiel:

cannot divide by zero

Bibliotheken von Drittanbietern verwenden

Zusätzlich zu benutzerdefinierten Fehlertypen können wir dazu auch vorhandene Bibliotheken von Drittanbietern verwenden Lösen Sie diese Frage. Zu den häufig verwendeten Bibliotheken gehören Logrus, Zerolog usw., die Fehlerinformationen verschlüsseln und verarbeiten und die Offenlegung vertraulicher Informationen wie Systempfade wirksam verhindern können.

Am Beispiel von Logrus müssen wir nur die Fehlertypvariable als Parameter übergeben, wenn wir Logrus zum Aufzeichnen von Protokollen verwenden. Beispiel:

import (
    log "github.com/sirupsen/logrus"
)

func Divide(a, b int) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("cannot divide by zero")
    }
    return float64(a) / float64(b), nil
}

func main() {
    result, err := Divide(10, 0)
    if err != nil {
        log.WithError(err).Error("divide error")
        return
    }
    log.Info(result)
}

Auf diese Weise werden beim Auftreten eines Programmfehlers nur Fehlerinformationen im Protokoll empfangen und keine vertraulichen Informationen wie Pfade offengelegt.

4. Zusammenfassung

Dieser Artikel stellt die Sicherheitsprobleme des Fehlerbehandlungsmechanismus von Golang vor und bietet zwei Lösungen. Das Anpassen von Fehlertypen ist eine gängige Lösung, und die Verwendung von Bibliotheken von Drittanbietern kann Probleme bequemer und effizienter lösen. Golang-Entwickler müssen darauf achten, ob in Fehlermeldungen vertrauliche Informationen offengelegt werden und entsprechende vorbeugende Maßnahmen ergreifen. Nur so können unsere Programme sicherer und zuverlässiger gemacht werden.

Das obige ist der detaillierte Inhalt vonGolang-Fehler-Expositionspfad. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!