chemin d'exposition aux erreurs Golang

Golang est un langage de programmation efficace, concis et sûr, mais il a aussi ses propres défauts, c'est-à-dire qu'il est facile d'exposer les chemins système lors de la gestion des erreurs. Cet article décrira ce problème et fournira une solution.

1. Contexte du problème

Le mécanisme de gestion des erreurs de Golang est très convivial pour les développeurs. Dans une fonction, si vous devez renvoyer une erreur, vous pouvez retourner directement une variable de type error. Par exemple :

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

Lorsque vous utilisez cette fonction, il vous suffit de déterminer si la variable d'erreur est nulle pour déterminer si une erreur s'est produite. Par exemple :

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

Cette méthode de gestion des erreurs est très concise, efficace et facilement acceptée par tout le monde. Cependant, les informations de la pile d'erreurs contiennent des informations de chemin, ce qui signifie que lorsqu'une erreur de programme se produit, l'attaquant peut obtenir des informations sensibles telles que le chemin du système à partir des informations d'erreur pour mener des attaques plus précises.

2. Analyse du problème

Jetons un coup d'œil à l'exemple ci-dessus lors de l'exécutionDivide(10, 0), le message d'erreur est le suivant :

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

Comme vous pouvez le voir, nous ne pouvons pas seulement voir le message d'erreur ainsi que le numéro de fichier et de ligne. où se trouve la fonction d'erreur, mais également Vous pouvez voir le code d'implémentation spécifique de la fonction d'erreur. Ce type de divulgation de fausses informations est trop détaillé et augmente considérablement les chances de succès de l'attaquant.

3. Solution

Maintenant que le problème a été découvert, nous devons trouver une solution. Voici ensuite deux solutions possibles :

1. Types d'erreur personnalisés

Dans Golang, nous pouvons personnaliser les types d'erreur. La définition est très simple, il suffit d'implémenter la méthode Error() de l'interface d'erreur. Par exemple :

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
}

De cette façon, lorsqu'une erreur de programme se produit, les informations de la pile d'erreurs ne contiennent plus d'informations sensibles telles que les chemins, mais uniquement nos informations d'erreur personnalisées. Par exemple :

cannot divide by zero

2. Utiliser des bibliothèques tierces

En plus des types d'erreur personnalisés, nous pouvons également utiliser des bibliothèques tierces existantes pour résoudre ce problème. Les bibliothèques couramment utilisées incluent logrus, zerolog, etc., qui peuvent crypter et traiter les informations d'erreur et empêcher efficacement l'exposition d'informations sensibles telles que les chemins système.

En prenant logrus comme exemple, il nous suffit de transmettre la variable de type d'erreur en tant que paramètre lors de l'utilisation de logrus pour enregistrer les journaux. Par exemple :

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)
}

De cette façon, lorsqu'une erreur de programme se produit, seules les informations d'erreur seront reçues dans le journal et aucune information sensible telle que les chemins ne sera exposée.

4. Résumé

Cet article présente les problèmes de sécurité du mécanisme de gestion des erreurs de Golang et propose deux solutions. La personnalisation des types d'erreurs est une solution courante, et l'utilisation de bibliothèques tierces peut résoudre les problèmes de manière plus pratique et plus efficace. Les développeurs de Golang doivent faire attention à savoir si des informations sensibles peuvent être exposées dans les messages d'erreur et prendre les mesures préventives correspondantes. Ce n'est qu'ainsi que nos programmes pourront être rendus plus sûrs et plus fiables.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!