Segurança e Boas Práticas de Desenvolvimento em Go

Desenvolver aplicativos seguros é essencial para proteger dados e usuários contra possíveis ameaças. Neste artigo, destacaremos algumas boas práticas de segurança em desenvolvimento Go, abordando prevenção de ataques de injeção de SQL, XSS e CSRF, além de práticas recomendadas de autenticação e autorização.

1. Prevenção de Injeção de SQL

Para prevenir ataques de injeção de SQL, utilize prepared statements ou consultas parametrizadas. Evite a concatenação direta de strings para formar consultas SQL. Aqui está um exemplo:

stmt, err := db.Prepare("SELECT * FROM users WHERE username = ? AND password = ?")
if err != nil {
    // Tratar o erro
}

rows, err := stmt.Query(username, password)
if err != nil {
    // Tratar o erro
}
defer stmt.Close()

// Processar o resultado...
    

2. Prevenção de XSS (Cross-Site Scripting)

Para evitar ataques XSS, sanitize input e escape output. Use bibliotecas de template seguras que escapem automaticamente dados renderizados. Exemplo:

import (
    "html/template"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    data := struct {
        Name string
    }{
        Name: template.HTMLEscapeString(r.FormValue("name")),
    }

    tmpl.Execute(w, data)
}
    

3. Prevenção de CSRF (Cross-Site Request Forgery)

Para prevenir ataques CSRF, use tokens anti-CSRF (também conhecidos como tokens de sincronização de formulário) em formulários e verifique a origem das solicitações. Exemplo:

import (
    "net/http"
    "github.com/gorilla/csrf"
)

func main() {
    csrfMiddleware := csrf.Protect([]byte("chave-secreta"), csrf.Secure(false)) // Altere Secure para true em produção

    http.ListenAndServe(":8080", csrfMiddleware(http.DefaultServeMux))
}
    

4. Autenticação e Autorização

Implemente autenticação robusta, como OAuth2, JWT (JSON Web Tokens) para autenticação de API e utilize middleware para autorização baseada em papéis. Exemplo:

import (
    "github.com/dgrijalva/jwt-go"
    "github.com/gin-gonic/gin"
)

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

    r.POST("/login", func(c *gin.Context) {
        // Lógica de login e geração de token JWT
    })

    // Middleware de autorização
    r.Use(func(c *gin.Context) {
        tokenString := c.GetHeader("Authorization")
        token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
            // Verificar e retornar a chave de verificação
        })
        if err != nil || !token.Valid {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "Unauthorized"})
            c.Abort()
            return
        }
        // Lógica de autorização
        c.Next()
    })

    // Rotas protegidas...

    r.Run(":8080")
}
    

Seguindo essas boas práticas, você pode desenvolver aplicativos Go mais seguros e resilientes contra ameaças comuns. Lembre-se sempre de manter-se atualizado sobre as melhores práticas de segurança e revisar regularmente o código para identificar e corrigir possíveis vulnerabilidades.

Se tiver alguma dúvida ou sugestão, não hesite em compartilhar nos comentários abaixo!