Tutoriel sur la mise en œuvre du décodage d'authentification de base en langue go

Ce document décrit comment décoder les informations d'authentification de base dans les demandes HTTP dans GO. Bien que Go lui-même n'intercepte pas directement l'authentification de base dans le navigateur, il peut obtenir le nom d'utilisateur et le mot de passe en analysant le champ d'autorisation dans l'en-tête de demande et effectuer le décodage de base64. Cet article fournira des étapes détaillées et un exemple de code pour aider les développeurs à mettre en œuvre l'analyse d'authentification de base dans les applications GO.

Analyser l'en-tête d'autorisation

Les informations d'authentification de base sont généralement contenues dans l'en-tête d'autorisation pour les demandes HTTP. GO Language peut accéder à ces informations via le champ d'en-tête de l'objet HTTP.Request.

Obtenez une en-tête d'autorisation

Tout d'abord, vous devez obtenir la valeur de l'en-tête d'autorisation. Dans l'objet HTTP.Request de Go's, l'en-tête est un type de chaîne de carte [String] [], vous pouvez donc l'obtenir de la manière suivante:

 package principal

importer (
    "FMT"
    "net / http"
)

Func Handler (w http.ResponseWriter, r * http.request) {
    Authheader: = R.Header ["Autorisation"]
    fmt.fprintf (W, "En-tête d'autorisation:% V \ n", Authheader)
}

func main () {
    http.handlefunc ("/", gestionnaire)
    http.ListenandServe (": 8080", nil)
}

Dans cet exemple, la variable Authheader contiendra une tranche de chaîne, où le premier élément est généralement la valeur de l'en-tête d'autorisation.

Analyser les informations d'authentification de base

La valeur d'en-tête d'autorisation est généralement sous la forme de Nom d'utilisateur codé de base . Vous devez extraire la partie codée Base64 et la décoder.

 package principal

importer (
    "Encodage / base64"
    "FMT"
    "net / http"
    "Strings"
)

Func Handler (w http.ResponseWriter, r * http.request) {
    Authheader: = R.Header.get ("Autorisation")
    Si authheader == "" {
        fmt.fprintf (W, "L'en-tête d'autorisation est manquant \ n")
        Retour
    }

    // Vérifiez s'il s'agit de l'authentification de base
    Authparts: = Strings.split (Authheader, "")
    Si Len (Authparts)! = 2 || Strings.tolower (Authparts [0])! = "Basic" {
        fmt.fprintf (W, "format d'en-tête d'autorisation non valide \ n")
        Retour
    }

    // Decode Base64
    Base64Encoded: = Authparts [1]
    décodé, err: = base64.stDencoding.decodestring (base64encoded)
    Si err! = Nil {
        fmt.fprintf (W, "Error Decoding Base64:% v \ n", err)
        Retour
    }

    // Nom d'utilisateur et mot de passe Split UserPass: = String (décodé)
    parties: = Strings.splitn (UserPass, ":", 2)
    Si Len (parties)! = 2 {
        fmt.fprintf (w, "nom d'utilisateur invalide: format de mot de passe \ n")
        Retour
    }

    Nom d'utilisateur: = pièces [0]
    Mot de passe: = pièces [1]

    fmt.fprintf (w, "nom d'utilisateur:% s, mot de passe:% s \ n", nom d'utilisateur, mot de passe)
}

func main () {
    http.handlefunc ("/", gestionnaire)
    http.ListenandServe (": 8080", nil)
}

Dans cet exemple, nous vérifions d'abord si l'en-tête d'autorisation existe, puis vérifions que son format est un nom d'utilisateur de base . Ensuite, nous utilisons la fonction Base64.stDencoding.Decodestring pour décoder la chaîne codée Base64 et diviser le résultat en nom d'utilisateur et mot de passe.

Exemple complet

Voici un exemple complet de la façon de gérer l'authentification de base dans GO.

 package principal

importer (
    "Encodage / base64"
    "FMT"
    "enregistrer"
    "net / http"
    "Strings"
)

Func BasicAuth (Handler http.handlerfunc, royaume String) http.handlerfunc {
    return func (w http.ResponseWriter, r * http.request) {
        auth: = r.header.get ("autorisation")
        Si auth == "" {
            w.header (). set ("www-authenticate", `rène de base =" `royaume` "`)
            W.WriteHeader (http.statusunauthorized)
            w.write ([] byte ("non autorisé. \ n"))
            Retour
        }

        Authparts: = Strings.split (auth, "")
        Si Len (Authparts)! = 2 || Strings.tolower (Authparts [0])! = "Basic" {
            Http.Error (W, "Format d'en-tête d'autorisation invalide", http.statusunAuthorized)
            Retour
        }

        charge utile, err: = base64.stDencoding.decodestring (authparts [1])
        Si err! = Nil {
            Http.Error (W, "Format d'en-tête d'autorisation invalide", http.statusunAuthorized)
            Retour
        }

        paire: = Strings.splitn (String (charge utile), ":", 2)
        Si Len (paire)! = 2 {
            Http.Error (W, "Format d'en-tête d'autorisation invalide", http.statusunAuthorized)
            Retour
        }

        Nom d'utilisateur, mot de passe: = paire [0], paire [1]

        // Vérifiez le nom d'utilisateur et le mot de passe ici si! CheckCredentials (nom d'utilisateur, mot de passe) {
            w.header (). set ("www-authenticate", `rène de base =" `royaume` "`)
            W.WriteHeader (http.statusunauthorized)
            w.write ([] byte ("non autorisé. \ n"))
            Retour
        }

        Handler (W, R)
    }
}

func checkCredentials (nom d'utilisateur, chaîne de mot de passe) bool {
    // Dans l'application réelle, vous devez vérifier le nom d'utilisateur et le mot de passe de la base de données ou d'autres endroits // Ce n'est qu'un exemple simple. Return username == "admin" && mot de passe == "mot de passe"
}

func protectedHandler (w http.responsewriter, r * http.request) {
    fmt.fprintln (w, "Bienvenue dans la zone protégée!")
}

func main () {
    Protégé: = http.handlerfunc (ProtectedHandler)
    http.handlefunc ("/", BasicAuth (protégé, "mon royaume"))

    Log.println ("Serveur démarré sur: 8080")
    Log.fatal (http.ListenandServe (": 8080", nil))
}

Dans cet exemple, la fonction BasicAuth est un middleware pour gérer l'authentification de base. Il vérifie d'abord si l'en-tête d'autorisation existe, et s'il n'existe pas, il renvoie un code d'état 401 non autorisé et définit l'en-tête WWW-Authenticate. Si l'en-tête d'autorisation existe, décodez le nom d'utilisateur et le mot de passe codés Base64 et appelez la fonction CheckCredentials pour la vérification. Si la vérification échoue, un code d'état 401 non autorisé est renvoyé. Si la vérification est réussie, la fonction de gestionnaire d'origine est appelée.

Choses à noter

• Sécurité: l'authentification de base elle-même n'est pas sécurisée car elle transmet des noms d'utilisateur et des mots de passe via le codage de base64 et est facilement écouté. Dans les environnements de production, il est recommandé d'utiliser des méthodes d'authentification plus sûres telles que OAuth 2.0 ou JWT.
• Gestion des erreurs: Dans les applications réelles, diverses erreurs possibles doivent être traitées, telles que la défaillance de décodage de base64, le nom d'utilisateur et le format de mot de passe, etc.
• Vérification de l'utilisateur: la fonction CheckCredentials n'est qu'un exemple. Dans l'application réelle, vous devez vérifier le nom d'utilisateur et le mot de passe de la base de données ou ailleurs.
• HTTPS: Il est fortement recommandé d'utiliser le protocole HTTPS lors de l'utilisation de l'authentification de base pour crypter les données pendant la transmission.

Résumer

Ce document décrit comment décoder les informations d'authentification de base dans les demandes HTTP dans GO. En analysant l'en-tête d'autorisation et en décodant le nom d'utilisateur et le mot de passe codés en base64, une fonction d'authentification simple peut être obtenue. Cependant, comme l'authentification de base elle-même présente des risques de sécurité, il est recommandé d'utiliser une méthode d'authentification plus sûre dans les environnements de production. Dans le même temps, vous devez faire attention à la gestion des erreurs et à la vérification des utilisateurs, et utiliser autant que possible le protocole HTTPS.

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!