Simplifiez la validation des entrées Gin dans Go avec ginvalidator

Aperçu

ginvalidator est un ensemble de middlewares Gin qui englobe la vaste collection de validateurs et de désinfectants proposés par mon autre package open source validatorgo. Il utilise également le populaire package open source gjson pour la syntaxe des champs JSON, permettant une interrogation et une extraction efficaces des données à partir d'objets JSON.

Il vous permet de les combiner de plusieurs manières afin que vous puissiez valider et assainir vos demandes de Gin, et propose des outils pour déterminer si la demande est valide ou non, quelles données ont été mises en correspondance selon vos validateurs.

Il est basé sur la populaire bibliothèque js/express express-validator

Soutien

Cette version de ginvalidator nécessite que votre application fonctionne sur Go 1.16 .
Il est également vérifié qu'il fonctionne avec Gin 1.x.x.

Raisonnement

Pourquoi ne pas l'utiliser ?

• Validateurs manuscrits : Vous pouvez écrire votre propre logique de validation manuellement, mais cela devient rapidement répétitif et compliqué. Chaque fois que vous avez besoin d’une nouvelle validation, vous écrivez encore et encore le même type de code. Il est facile de faire des erreurs et c’est difficile à entretenir.
• Liaison et validation du modèle intégré de Gin : Gin a une validation intégrée, mais ce n'est pas idéal pour tout le monde. Les balises Struct sont limitantes et rendent votre code plus difficile à lire, surtout lorsque vous avez besoin de règles complexes. De plus, la validation est trop étroitement liée à vos modèles, ce qui n'est pas idéal pour la flexibilité.
• Autres bibliothèques (comme Galidator) : Il existe d'autres bibliothèques, mais elles semblent souvent trop complexes pour ce qu'elles font. Ils nécessitent plus de configuration et de travail que prévu, surtout lorsque vous souhaitez simplement une solution simple et directe pour la validation.

Installation

Assurez-vous que Go est installé sur votre ordinateur.

Étape 1 : Créer un nouveau module Go

1. Créez un dossier vide avec un nom de votre choix.
2. Ouvrez un terminal, naviguez (cd) dans ce dossier et initialisez un nouveau module Go :

go mod init example.com/learning

Étape 2 : Installer les packages requis

Utilisez go get pour installer les packages nécessaires.

1. Installer Gin :

go get -u github.com/gin-gonic/gin

1. Installez ginvalidator :

go get -u github.com/bube054/ginvalidator

Commencer

L'exemple est l'une des meilleures façons d'apprendre quelque chose ! Alors retroussons les manches et commençons à coder.

Installation

La première chose dont on a besoin est un serveur Gin en cours d'exécution. Implémentons-en un qui dit bonjour à quelqu'un ; pour cela, créez un main.go puis ajoutez le code suivant :

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/hello", func(ctx *gin.Context) {
        person := ctx.Query("person")
        ctx.String(http.StatusOK, "Hello, %s!", person)
    })

    r.Run() // listen and serve on 0.0.0.0:8080
}

Maintenant, exécutez ce fichier en exécutant go run main.go sur votre terminal.

go mod init example.com/learning

Le serveur HTTP devrait être en cours d'exécution et vous pouvez ouvrir http://localhost:8080/hello?person=John pour saluer John !

? Conseil :
Vous pouvez utiliser Air avec Go et Gin pour implémenter le rechargement en direct. Ceux-ci redémarrent automatiquement le serveur chaque fois qu'un fichier est modifié, vous n'avez donc pas à le faire vous-même !

Ajout d'un validateur

Le serveur fonctionne donc, mais il pose des problèmes. Plus particulièrement, vous ne voulez pas dire bonjour à quelqu'un dont le nom n'est pas défini.
Par exemple, accéder à http://localhost:8080/hello affichera « Bonjour ».

C'est là que ginvalidator est utile. Il fournit des validateurs, des désinfectants et des modificateurs qui sont utilisés pour valider votre demande.
Ajoutons un validateur et un modificateur qui vérifie que la chaîne de requête de la personne ne peut pas être vide, avec le validateur nommé Empty et le modificateur nommé Not :

go get -u github.com/gin-gonic/gin

? Remarque :

Par souci de concision, gv est utilisé comme alias pour ginvalidator dans les exemples de code.

Maintenant, redémarrez votre serveur et accédez à nouveau à http://localhost:8080/hello. Hmm, il affiche toujours "Bonjour, !"... pourquoi ?

Gestion des erreurs de validation

La chaîne de validation ginvalidator ne signale pas automatiquement les erreurs de validation aux utilisateurs.
La raison en est simple : à mesure que vous ajoutez davantage de validateurs ou de champs, comment souhaitez-vous collecter les erreurs ? Voulez-vous une liste de toutes les erreurs, une seule par champ, une seule au total...?

La prochaine étape évidente consiste donc à modifier à nouveau le code ci-dessus, cette fois en vérifiant le résultat de la validation avec la fonction ValidationResult :

go get -u github.com/bube054/ginvalidator

Maintenant, si vous accédez à nouveau à http://localhost:8080/hello, vous verrez le contenu JSON suivant, formaté pour plus de clarté :

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/hello", func(ctx *gin.Context) {
        person := ctx.Query("person")
        ctx.String(http.StatusOK, "Hello, %s!", person)
    })

    r.Run() // listen and serve on 0.0.0.0:8080
}

Maintenant, ce que cela nous dit, c'est que

• il y a eu exactement une erreur dans cette demande ;
• ce champ s'appelle personne ;
• il se trouve dans la chaîne de requête (emplacement : "requêtes");
• le message d'erreur qui a été donné était "Valeur invalide".

C'est un meilleur scénario, mais il peut encore être amélioré. Continuons.

Créer de meilleurs messages d'erreur

Tous les validateurs d'emplacement de requête acceptent un deuxième argument facultatif, qui est une fonction utilisée pour formater le message d'erreur. Si nil est fourni, un message d'erreur générique par défaut sera utilisé, comme indiqué dans l'exemple ci-dessus.

go run main.go

Maintenant, si vous accédez à nouveau à http://localhost:8080/hello, vous verrez le contenu JSON suivant, avec le nouveau message d'erreur :

package main

import (
    "net/http"

    gv "github.com/bube054/ginvalidator"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/hello", gv.NewQuery("person", nil).
        Chain().
        Not().
        Empty(nil).
        Validate(), func(ctx *gin.Context) {
            person := ctx.Query("person")
            ctx.String(http.StatusOK, "Hello, %s!", person)
        })

    r.Run()
}

Accéder aux données validées/assainies

Vous pouvez utiliser GetMatchedData, qui collecte automatiquement toutes les données que ginvalidator a validées et/ou nettoyées. Ces données sont ensuite accessibles à l'aide de la méthode Get de MatchedData :

go mod init example.com/learning

ouvrez http://localhost:8080/hello?person=John pour saluer John !

Les emplacements disponibles sont BodyLocation, CookieLocation QueryLocation, ParamLocation et HeaderLocation.
Chacun de ces emplacements comprend une méthode String qui renvoie l'emplacement où les données validées/assainies sont stockées.

Assainissement des intrants

Bien que l'utilisateur ne puisse plus envoyer de noms de personnes vides, il peut toujours injecter du HTML dans votre page ! Ceci est connu sous le nom de vulnérabilité Cross-Site Scripting (XSS).
Voyons comment cela fonctionne. Allez sur http://localhost:8080/hello?person=John, et vous devriez voir "Bonjour, John!".
Bien que cet exemple soit correct, un attaquant pourrait modifier la chaîne de requête de la personne en un code

• Qu'est-ce que le langage Go ? Introduction aux avantages et inconvénients du langage Go
• Que signifie le gin ?
• Pourquoi Go est-il plus performant que PHP ?
• À quoi convient le langage go ?
• aller aux bases du langage