As noticed in my previous commit, the existing jwt libraries added a lot of performance cost between jwt-featured requests and simple requests. That's why a new custom JWT parser was created. This commit adds our custom jwt parser as the underline token signer and verifier

_examples/auth/jwt/basic/main.go

@@ -4,41 +4,75 @@ import (
 	"time"
 
 	"github.com/kataras/iris/v12"
-	"github.com/kataras/iris/v12/middleware/jwt"
+	"github.com/kataras/jwt"
 )
 
+/*
+Learn how to use any JWT 3rd-party package with Iris.
+In this example we use the kataras/jwt one.
+
+Install with:
+    go get -u github.com/kataras/jwt
+
+Documentation:
+    https://github.com/kataras/jwt#table-of-contents
+*/
+
+// Replace with your own key and keep them secret.
+// The "signatureSharedKey" is used for the HMAC(HS256) signature algorithm.
+var signatureSharedKey = []byte("sercrethatmaycontainch@r32length")
+
 func main() {
 	app := iris.New()
-	// With AES-GCM (128) encryption:
-	// j := jwt.HMAC(15*time.Minute, "secret", "itsa16bytesecret")
-	// Without extra encryption, just the sign key:
-	j := jwt.HMAC(15*time.Minute, "secret")
 
-	app.Get("/", generateToken(j))
-	app.Get("/protected", j.VerifyMap(), protected)
+	app.Get("/", generateToken)
+	app.Get("/protected", protected)
 
 	app.Listen(":8080")
 }
 
-func generateToken(j *jwt.JWT) iris.Handler {
-	return func(ctx iris.Context) {
-		token, err := j.Token(iris.Map{
-			"foo": "bar",
-		})
-		if err != nil {
-			ctx.StopWithStatus(iris.StatusInternalServerError)
-			return
-		}
+type fooClaims struct {
+	Foo string `json:"foo"`
+}
 
-		ctx.HTML(`Token: ` + token + `<br/><br/>
-		<a href="/protected?token=` + token + `">/secured?token=` + token + `</a>`)
+func generateToken(ctx iris.Context) {
+	claims := fooClaims{
+		Foo: "bar",
 	}
+
+	// Sign and generate compact form token.
+	token, err := jwt.Sign(jwt.HS256, signatureSharedKey, claims, jwt.MaxAge(10*time.Minute))
+	if err != nil {
+		ctx.StopWithStatus(iris.StatusInternalServerError)
+		return
+	}
+
+	tokenString := string(token) // or jwt.BytesToString
+	ctx.HTML(`Token: ` + tokenString + `<br/><br/>
+		<a href="/protected?token=` + tokenString + `">/protected?token=` + tokenString + `</a>`)
 }
 
 func protected(ctx iris.Context) {
+	// Extract the token, e.g. cookie, Authorization: Bearer $token
+	// or URL query.
+	token := ctx.URLParam("token")
+	// Verify the token.
+	verifiedToken, err := jwt.Verify(jwt.HS256, signatureSharedKey, []byte(token))
+	if err != nil {
+		ctx.StopWithStatus(iris.StatusUnauthorized)
+		return
+	}
+
 	ctx.Writef("This is an authenticated request.\n\n")
 
-	claims := jwt.Get(ctx).(iris.Map)
+	// Decode the custom claims.
+	var claims fooClaims
+	verifiedToken.Claims(&claims)
 
-	ctx.Writef("foo=%s\n", claims["foo"])
+	// Just an example on how you can retrieve all the standard claims (set by jwt.MaxAge, "exp").
+	standardClaims := jwt.GetVerifiedToken(ctx).StandardClaims
+	expiresAtString := standardClaims.ExpiresAt().Format(ctx.Application().ConfigurationReadOnly().GetTimeFormat())
+	timeLeft := standardClaims.Timeleft()
+
+	ctx.Writef("foo=%s\nexpires at: %s\ntime left: %s\n", claims.Foo, expiresAtString, timeLeft)
 }