Ungültige Speicheradresse oder Null-Zeiger-Dereferenzierungsvalidierungs-JWT-Ablaufzeit

Der Herausgeber von PHP, Xiaoxin, stellt Ihnen die häufigsten Probleme bei der Überprüfung der JWT-Ablaufzeit vor. Wenn wir JWT zur Authentifizierung verwenden, müssen wir häufig überprüfen, ob das Token abgelaufen ist. Manchmal können jedoch Fehler wie eine ungültige Speicheradresse oder eine Null-Zeiger-Dereferenzierung auftreten. Diese Fehler können dazu führen, dass die Token-Validierung fehlschlägt. In diesem Artikel werden die Ursachen dieser Probleme für Sie analysiert und Lösungen bereitgestellt, die Ihnen dabei helfen, die Ablaufzeit von JWT erfolgreich zu überprüfen.

Frageninhalt

Ich verwende Golang, um mich mit dem JWT-Token anzumelden. Bisher läuft alles gut. Es wird überprüft, wie viel Zeit auf dem Token verbleibt, und wenn kein Token vorhanden ist, wird eine Nachricht gesendet Aber ich habe zwei Probleme: Wenn das Token ungültig ist oder die Ablaufzeit abgelaufen ist, wird dieser Fehler angezeigt:

Die Zeile mit dem Fehler sieht so aus claims := token.claims.(*jwtcustomclaims)

Meine jwtcustomclaims-Variable sieht so aus:

type jwtcustomclaims struct {
    user     string `json:"email"`
    nombre   string `json:"nombre"`
    apellido string `json:"apellido"`
    edad     int    `json:"edad"`
    genero   string `json:"genero"`
    rol      string `json:"rol"`
    jwt.standardclaims
}

Durch die Verwendung dieser Struktur wird auch ein Token generiert. Die vollständige Funktion zum Überprüfen des Tokens lautet wie folgt:

func ValidateToken(tokenString string, secretKey string, c *fiber.Ctx) (*jwt.Token, error) {
    token, err := jwt.ParseWithClaims(tokenString, &jwtCustomClaims{}, func(token *jwt.Token) (interface{}, error) {
        return []byte(secretKey), nil
    })

    if err != nil {
        if err == jwt.ErrSignatureInvalid {
            return nil, err
        }
        return nil, c.JSON(fiber.Map{
            "message": "Unauthorized",
            "code":    400,
        })

    }

    _, ok := token.Claims.(*jwtCustomClaims)
    if !ok || !token.Valid {
        return nil, c.JSON(fiber.Map{
            "message": "Unauthorized",
            "code":    400,
        })
    }

    return token, nil
}

func TokenMiddleware(c *fiber.Ctx) error {
    tokenString := c.Get("Authorization")
    if tokenString == "" {
        return c.JSON(fiber.Map{
            "message": "No token",
            "code":    400,
        })
    }

    // Separa el token del encabezado "Bearer"
    tokenString = strings.ReplaceAll(tokenString, "Bearer ", "")

    token, err := ValidateToken(tokenString, os.Getenv("SECRET"), c)
    if err != nil {
        return err
    }

        claims := token.Claims.(*jwtCustomClaims)

        expiresIn := time.Until(time.Unix(claims.ExpiresAt, 0))
        if expiresIn > 0 {
            return c.JSON(fiber.Map{
                "message":    "Token is valid",
                "expires_in": expiresIn.String(),
                "is_expired": false,
            })
            //return c.Next()
        } else {
            return c.JSON(fiber.Map{
                "message":    "Token is valid but expired",
                "expires_in": 0,
                "is_expired": true,
            })
        }
}

Um zu überprüfen, ob das Token validiert wird, habe ich gerade versucht, einen anderen Tokentyp aus einem anderen Projekt einzufügen und ihn nur zum Testen falsch zu schreiben, aber es wird ein Konsolenfehler gesendet. Für die Ablaufzeit habe ich mir den Fehler online angesehen und die Lösung bestand darin, so zu schreiben

, aber es hat nicht funktioniert und ich weiß nicht, was ich sonst tun soll if claims == nil

Workaround

Bitte testen Sie es aus:

func ValidateToken(tokenString string, secretKey string, c *fiber.Ctx) (jwtCustomClaims, error) {
    var claims jwtCustomClaims
    token, err := jwt.ParseWithClaims(tokenString, &claims, func(token *jwt.Token) (interface{}, error) {
        return []byte(secretKey), nil
    })
    if err != nil {
        if err == jwt.ErrSignatureInvalid {
            return jwtCustomClaims{}, err
        }
        return jwtCustomClaims{}, c.JSON(fiber.Map{
            "message": "Unauthorized",
            "code":    400,
        })

    }

    if !token.Valid {
        return jwtCustomClaims{}, c.JSON(fiber.Map{
            "message": "Unauthorized",
            "code":    400,
        })
    }

    return claims, nil
}

func TokenMiddleware(c *fiber.Ctx) error {
    .
    .
    .

    claims, err := ValidateToken(tokenString, os.Getenv("SECRET"), c)
    if err != nil {
        return err
    }

    expiresIn := time.Until(time.Unix(claims.ExpiresAt, 0))

    .
    .
    .
}

Das obige ist der detaillierte Inhalt vonUngültige Speicheradresse oder Null-Zeiger-Dereferenzierungsvalidierungs-JWT-Ablaufzeit. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!