El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este módulo, aprenderás sobre las mejores prácticas de seguridad al desarrollar aplicaciones en Go. La seguridad es un aspecto crucial del desarrollo de software, y seguir estas prácticas te ayudará a proteger tus aplicaciones contra vulnerabilidades comunes.

Conceptos Clave

Validación de Entradas: Asegúrate de validar y sanitizar todas las entradas del usuario para prevenir ataques como la inyección SQL y la inyección de comandos.
Autenticación y Autorización: Implementa mecanismos robustos para autenticar y autorizar a los usuarios.
Cifrado: Utiliza cifrado para proteger datos sensibles tanto en tránsito como en reposo.
Manejo de Errores: Evita exponer detalles internos de la aplicación en los mensajes de error.
Actualizaciones y Parches: Mantén tus dependencias y bibliotecas actualizadas para protegerte contra vulnerabilidades conocidas.

Validación de Entradas

Ejemplo de Validación de Entradas

package main

import (
    "fmt"
    "net/http"
    "regexp"
)

func isValidInput(input string) bool {
    // Define a regular expression for valid input
    var validInput = regexp.MustCompile(`^[a-zA-Z0-9]+$`)
    return validInput.MatchString(input)
}

func handler(w http.ResponseWriter, r *http.Request) {
    userInput := r.URL.Query().Get("input")
    if !isValidInput(userInput) {
        http.Error(w, "Invalid input", http.StatusBadRequest)
        return
    }
    fmt.Fprintf(w, "Valid input: %s", userInput)
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

Explicación

Validación con Expresiones Regulares: Utilizamos una expresión regular para validar que la entrada del usuario solo contenga caracteres alfanuméricos.
Manejo de Errores: Si la entrada no es válida, respondemos con un error HTTP 400 (Bad Request).

Autenticación y Autorización

Ejemplo de Autenticación Básica

package main

import (
    "net/http"
)

func basicAuth(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        user, pass, ok := r.BasicAuth()
        if !ok || user != "admin" || pass != "password" {
            w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next(w, r)
    }
}

func handler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello, authenticated user!"))
}

func main() {
    http.HandleFunc("/", basicAuth(handler))
    http.ListenAndServe(":8080", nil)
}

Explicación

Autenticación Básica: Implementamos una autenticación básica que verifica el nombre de usuario y la contraseña.
Encabezado WWW-Authenticate: Si la autenticación falla, respondemos con un encabezado WWW-Authenticate y un error HTTP 401 (Unauthorized).

Cifrado

Ejemplo de Cifrado de Datos

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "io"
)

func encrypt(data, passphrase string) (string, error) {
    block, err := aes.NewCipher([]byte(passphrase))
    if err != nil {
        return "", err
    }

    ciphertext := make([]byte, aes.BlockSize+len(data))
    iv := ciphertext[:aes.BlockSize]
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        return "", err
    }

    stream := cipher.NewCFBEncrypter(block, iv)
    stream.XORKeyStream(ciphertext[aes.BlockSize:], []byte(data))

    return hex.EncodeToString(ciphertext), nil
}

func main() {
    encrypted, err := encrypt("my secret data", "mysecretpassphrase")
    if err != nil {
        fmt.Println("Error encrypting data:", err)
        return
    }
    fmt.Println("Encrypted data:", encrypted)
}

Explicación

Cifrado AES: Utilizamos el cifrado AES en modo CFB para cifrar datos.
Vector de Inicialización (IV): Generamos un IV aleatorio para cada cifrado para asegurar que el mismo texto plano cifrado con la misma clave produzca diferentes textos cifrados.

Manejo de Errores

Ejemplo de Manejo de Errores

package main

import (
    "log"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    _, err := w.Write([]byte("Hello, world!"))
    if err != nil {
        log.Println("Error writing response:", err)
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
    }
}

func main() {
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Explicación

Registro de Errores: Registramos los errores en el servidor para análisis posterior.
Mensajes de Error Genéricos: Respondemos con un mensaje de error genérico para evitar exponer detalles internos.

Actualizaciones y Parches

Ejemplo de Actualización de Dependencias

go get -u all

Explicación

Actualización de Dependencias: Utilizamos el comando go get -u all para actualizar todas las dependencias del proyecto a sus últimas versiones.

Ejercicio Práctico

Ejercicio

Implementa una función en Go que valide una dirección de correo electrónico utilizando una expresión regular.
Crea un middleware de autenticación que verifique un token JWT en las solicitudes HTTP.
Implementa una función que cifre y descifre datos utilizando AES en modo GCM.

Solución

Validación de Correo Electrónico

package main

import (
    "fmt"
    "regexp"
)

func isValidEmail(email string) bool {
    var emailRegex = regexp.MustCompile(`^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$`)
    return emailRegex.MatchString(email)
}

func main() {
    email := "[email protected]"
    fmt.Println("Is valid email:", isValidEmail(email))
}

Middleware de Autenticación con JWT

package main

import (
    "net/http"
    "strings"

    "github.com/dgrijalva/jwt-go"
)

func jwtAuth(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        authHeader := r.Header.Get("Authorization")
        if authHeader == "" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }

        tokenString := strings.Split(authHeader, " ")[1]
        token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
            return []byte("mysecretkey"), nil
        })

        if err != nil || !token.Valid {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }

        next(w, r)
    }
}

func handler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello, authenticated user!"))
}

func main() {
    http.HandleFunc("/", jwtAuth(handler))
    http.ListenAndServe(":8080", nil)
}

Cifrado y Descifrado con AES en Modo GCM

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "io"
)

func encryptGCM(plaintext, key string) (string, error) {
    block, err := aes.NewCipher([]byte(key))
    if err != nil {
        return "", err
    }

    aesGCM, err := cipher.NewGCM(block)
    if err != nil {
        return "", err
    }

    nonce := make([]byte, aesGCM.NonceSize())
    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
        return "", err
    }

    ciphertext := aesGCM.Seal(nonce, nonce, []byte(plaintext), nil)
    return hex.EncodeToString(ciphertext), nil
}

func decryptGCM(ciphertext, key string) (string, error) {
    data, err := hex.DecodeString(ciphertext)
    if err != nil {
        return "", err
    }

    block, err := aes.NewCipher([]byte(key))
    if err != nil {
        return "", err
    }

    aesGCM, err := cipher.NewGCM(block)
    if err != nil {
        return "", err
    }

    nonceSize := aesGCM.NonceSize()
    nonce, ciphertext := data[:nonceSize], data[nonceSize:]
    plaintext, err := aesGCM.Open(nil, nonce, ciphertext, nil)
    if err != nil {
        return "", err
    }

    return string(plaintext), nil
}

func main() {
    key := "mysecretkey12345"
    plaintext := "my secret data"

    encrypted, err := encryptGCM(plaintext, key)
    if err != nil {
        fmt.Println("Error encrypting data:", err)
        return
    }
    fmt.Println("Encrypted data:", encrypted)

    decrypted, err := decryptGCM(encrypted, key)
    if err != nil {
        fmt.Println("Error decrypting data:", err)
        return
    }
    fmt.Println("Decrypted data:", decrypted)
}

Conclusión

En esta sección, hemos cubierto varias prácticas de seguridad esenciales para el desarrollo de aplicaciones en Go. Desde la validación de entradas hasta el cifrado de datos y la autenticación, estas prácticas te ayudarán a construir aplicaciones más seguras y robustas. Asegúrate de aplicar estos principios en tus proyectos para proteger tus aplicaciones y datos contra amenazas comunes.

Mejores Prácticas de Seguridad

Conceptos Clave

Validación de Entradas

Ejemplo de Validación de Entradas

Explicación

Autenticación y Autorización

Ejemplo de Autenticación Básica

Explicación

Cifrado

Ejemplo de Cifrado de Datos

Explicación

Manejo de Errores

Ejemplo de Manejo de Errores

Explicación

Actualizaciones y Parches

Ejemplo de Actualización de Dependencias

Explicación

Ejercicio Práctico

Ejercicio

Solución

Validación de Correo Electrónico

Middleware de Autenticación con JWT

Cifrado y Descifrado con AES en Modo GCM

Conclusión

Curso de Programación en Go

Módulo 1: Introducción a Go

Módulo 2: Conceptos Básicos

Módulo 3: Estructuras de Datos Avanzadas

Módulo 4: Manejo de Errores

Módulo 5: Concurrencia

Módulo 6: Temas Avanzados

Módulo 7: Desarrollo Web con Go

Módulo 8: Trabajando con Bases de Datos

Módulo 9: Despliegue y Mantenimiento

Módulo 10: Proyecto Final