Utiliser le framework Gin pour implémenter des fonctions de protection de sécurité Web

Avec la popularité d'Internet, les applications Web sont devenues un élément indispensable de notre vie et de notre travail. Cependant, les problèmes de sécurité ont toujours constitué un défi de taille pour les applications Web. Les problèmes de sécurité Web incluent l'injection SQL, les attaques de scripts intersites, les accès non autorisés, etc. Ces risques de sécurité peuvent conduire à la fuite de données confidentielles voire au contrôle total du serveur. Afin de résoudre ces problèmes de sécurité Web, nous pouvons utiliser la fonction de protection de sécurité Web fournie par le framework Gin.

Gin est un framework Web léger en langage Go qui offre la possibilité de créer rapidement des applications Web hautes performances. Dans le même temps, le framework Gin fournit également de nombreuses fonctions liées à la sécurité Web, et l'utilisation de ces fonctions peut grandement améliorer la sécurité des applications Web.

1. Utiliser le protocole HTTPS

HTTPS est un protocole HTTP basé sur le protocole de communication crypté TLS/SSL. Il protège le processus de communication des applications Web en utilisant une technologie de cryptage à clé publique et privée pour éviter le vol ou la falsification de données. Si vous souhaitez utiliser le protocole HTTPS dans votre application web, vous pouvez rediriger automatiquement les requêtes HTTP vers le protocole HTTPS via le middleware fourni par le framework Gin.

Tout d'abord, vous devez générer un certificat auto-signé sur votre serveur. Ensuite, utilisez le code suivant pour activer le middleware du framework Gin :

func main() {
    r := gin.Default()
    r.Use(TLSHandler())
    ...
    r.Run(":443")
}

func TLSHandler() gin.HandlerFunc {
    return func(c *gin.Context) {
        if c.Request.TLS == nil || len(c.Request.TLS.PeerCertificates) == 0 {
            loc, err := time.LoadLocation("Asia/Shanghai")
            if err != nil {
                loc = time.FixedZone("Asia/Shanghai", 8*60*60)
            }
            c.Redirect(http.StatusMovedPermanently, "https://"+c.Request.Host+c.Request.URL.Path)
            return
        }
    }
}

Ce middleware vérifie si la requête utilise le protocole TLS. S'il n'est pas utilisé, il sera redirigé vers le protocole HTTPS via HTTP 301.

2. Prévenir l'injection SQL

L'injection SQL est une méthode d'attaque qui exploite les vulnérabilités des applications Web. Un attaquant peut saisir du code SQL malveillant pour falsifier ou voler des données dans la base de données. Afin d'éviter les attaques par injection SQL, nous pouvons utiliser l'outil de support officiel GORM du framework Gin, qui fournit de nombreuses mesures de protection de sécurité pour l'accès aux bases de données, telles que l'utilisation d'instructions préparées, la liaison de paramètres, l'échappement automatique, etc.

Ce qui suit est un exemple de code permettant au framework Gin d'utiliser les instructions précompilées GORM :

func main() {
    db, err := gorm.Open("sqlite3", "test.db")
    if err != nil {
        panic(err.Error())
    }

    db.DB().SetMaxIdleConns(10)
    db.DB().SetMaxOpenConns(100)

    r := gin.Default()

    r.GET("/user/:id", func(c *gin.Context) {
        var user User
        if err := db.Where("id = ?", c.Param("id")).First(&user).Error; err != nil {
            c.AbortWithStatus(http.StatusNotFound)
            return
        }
        c.JSON(http.StatusOK, user)
    })

    r.Run(":8080")
}

Dans le code ci-dessus, lorsque le framework Gin exécute des requêtes SQL via les méthodes fournies par GORM, il utilise des instructions précompilées et lie les paramètres à la requête. chaîne au milieu. Cela rend les attaques par injection SQL plus difficiles.

3. Prévenir les attaques par script intersite

L'attaque par script intersite (XSS) est une méthode d'attaque dans laquelle les attaquants exploitent les vulnérabilités de sécurité des applications Web pour injecter du code exécutable malveillant afin d'obtenir les informations sensibles des utilisateurs. Pour prévenir les attaques XSS, nous pouvons utiliser le middleware CSRF fourni par le framework Gin.

Le middleware CSRF vérifiera toutes les requêtes HTTP POST contenant des champs de formulaire pour s'assurer qu'il s'agit de paramètres sécurisés du framework Gin. Si la requête ne contient pas de paramètres de sécurité valides, le middleware CSRF lèvera une exception de code d'état HTTP 403.

Ce qui suit est un exemple de code utilisant le middleware CSRF du framework Gin :

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

    csrf := csrf.New(csrf.Options{
        Secret: "krCXcjS0n7vPDS2HaBw00lDWGCQujCn7",
    })

    r.Use(csrf)

    r.POST("/sign", func(c *gin.Context) {
        username := c.PostForm("username")
        password := c.PostForm("password")
        c.JSON(http.StatusOK, gin.H{"message": "登录成功", "username": username, "password": password})
    })

    r.Run(":8080")
}

Dans le code ci-dessus, le framework Gin utilise le middleware CSRF et définit une clé comme paramètre de sécurité. Lorsqu'un utilisateur soumet une demande de formulaire, le middleware CSRF vérifie et vérifie automatiquement les paramètres de sécurité pour garantir que les données sont efficacement protégées pendant la transmission.

4. Prévenir les accès non autorisés

L'accès non autorisé est une méthode d'attaque, c'est-à-dire qu'un attaquant exploite les vulnérabilités de sécurité des applications Web pour obtenir un accès non autorisé, puis effectuer des opérations malveillantes. Pour empêcher tout accès non autorisé, nous pouvons utiliser le middleware d'authentification JWT (JSON Web Token) dans le framework Gin.

JWT est un protocole d'authentification basé sur la structure de données JSON. Il assure la sécurité des données et l'anti-écoute clandestine en transmettant des informations de sécurité entre le client et le serveur. Lors de l'utilisation du middleware JWT, nous devons utiliser une clé secrète pour signer tous les jetons générés. Lorsqu'un utilisateur s'authentifie, le middleware confirme qu'il est autorisé en validant le jeton.

Ce qui suit est un exemple de code utilisant le middleware d'authentification JWT du framework Gin :

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

    var db *gorm.DB // 定义数据库

    authMiddleware := &jwt.GinJWTMiddleware{
        Realm:       "test zone",
        Key:         []byte("krCXcjS0n7vPDS2HaBw00lDWGCQujCn7"),
        Timeout:     time.Hour,
        MaxRefresh:  time.Hour,
        Authenticator: func(userId string, password string, c *gin.Context) (interface{}, error) {
            var user User
            if err := db.Where("username = ? AND password = ?", userId, password).First(&user).Error; err != nil {
                return nil, fmt.Errorf("用户名或密码错误")
            }
            return &user, nil
        },
        Authorizator: func(data interface{}, c *gin.Context) bool {
            if v, ok := data.(*User); ok && v.UserName == "admin" {
                return true
            }
            return false
        },
        Unauthorized: func(c *gin.Context, code int, message string) {
            c.JSON(code, gin.H{"code": http.StatusUnauthorized, "message": message})
        },
        TokenLookup: "header: Authorization, query: token, cookie: jwt",
        TokenHeadName: "Bearer",
        TimeFunc: time.Now,
    }

    r.Use(authMiddleware.MiddlewareFunc())

    r.POST("/login", authMiddleware.LoginHandler)

    r.GET("/admin", authMiddleware.MiddlewareFunc(), func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"message": "管理员页面"})
    })

    r.Run(":8080")
}

Dans le code ci-dessus, le framework Gin utilise le middleware d'authentification JWT et définit une base de données utilisée pour l'authentification. Lorsqu'un utilisateur soumet une preuve d'identité valide, le middleware JWT appelle la fonction « Authentificateur » pour vérifier qu'il est suffisamment autorisé. Lorsque le jeton expire, le middleware JWT actualise automatiquement le jeton à l'aide de l'option « MaxRefresh ».

Résumé

Le problème de sécurité Web est l'un des principaux problèmes rencontrés par les applications Internet. Afin d'assurer la sécurité des applications web, nous pouvons utiliser de nombreux plug-ins de protection de sécurité web fournis par le framework Gin. Qu'il s'agisse d'empêcher l'injection SQL, d'empêcher les attaques de scripts intersites ou d'empêcher les accès non autorisés, le middleware fourni par le framework Gin peut nous aider à réduire les risques de sécurité et à fournir une meilleure protection des utilisateurs dans les applications.

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!