Go i JWT - Proste uwierzytelnianie

Question

Obecnie tworzę API (z funkcją "go") i pracuję nad częścią sesji. Po przeprowadzeniu badań dotyczących tego, czego należy użyć podczas sesji, stwierdziłem, że JWT jest naprawdę interesujący.

Jednak nie jestem pewien, aby zrozumieć, jak go używać po kilku tutoriali. Więc to jest mój pomysł:

func main() { 

    router := mux.NewRouter().StrictSlash(true) 

    router.HandleFunc("/login", login) 
    router.HandleFunc("/logout", logout) 
    router.HandleFunc("/register", register) 

    http.ListenAndServe(":8080", router) 

} 

Po tych wniosków rozpatrzonych, tworzę funkcje differents.

func login(w http.ResponseWriter, r *http.Request) { 
    /*                                                 
    Here I just have to search in my database (SQL, I know how to do it). If the user is registered, I create a token and give it to him, but how can I do it?           
    */ 
} 

func logout(w http.ResponseWriter, r *http.Request) { 
    /*                                                 
    I get a token and stop/delete it?                                          
    */ 
} 

func register(w http.ResponseWriter, r *http.Request) { 
    /*                                                 
    I search if the user isn't register and then, if it isn't, I create a user in the database (I know how to do it). I connect him but again, how to make a new token?         
    */ 
} 

Wiele tutoriali w sieci wydaje się naprawdę trudne, ale chcę po prostu czegoś prostego. Po prostu chcę pakiet uchwytów (powyższy kod), które działają z pakietem usług, aby mieć coś takiego jak uwierzytelnianie tokenu silnika.

Drugim punktem, którego nie jestem pewien, jest zapisanie tokena. Jeśli użytkownik łączy się sam, to co jest najlepsze? Za każdym razem, gdy użytkownik uruchamia aplikację, aplikacja łączy się i pobiera nowy token z zapisanych informacji (użytkownik/hasło) lub po prostu zapisze token na zawsze? A co z serwerem, czy token jest automatycznie zarządzany i zapisywany przy pomocy JWT, czy też muszę go umieścić w bazie danych SQL?

Dziękuję za pomoc!

EDIT 1

Dziękujemy! Więc po przeczytaniu odpowiedzi na swoje pytanie, mam obudowane mojego kodu (token.go) podoba

package services 

import (
    "fmt" 
    "github.com/dgrijalva/jwt-go" 
    "time" 
    "../models" 
) 

var tokenEncodeString string = "something" 

func createToken(user models.User) (string, error) { 
    // create the token                                             
    token := jwt.New(jwt.SigningMethodHS256) 

    // set some claims                                             
    token.Claims["username"] = user.Username; 
    token.Claims["password"] = user.Password; 
    token.Claims["exp"] = time.Now().Add(time.Hour * 72).Unix() 

    //Sign and get the complete encoded token as string                                     
    return (token.SignedString(tokenEncodeString)) 
} 

func parseToken(unparsedToken string) (bool, string) { 
    token, err := jwt.Parse(unparsedToken, func(token *jwt.Token) (interface{}, error) { 
      // Don't forget to validate the alg is what you expect:                                  
      if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok { 
        return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"]) 
      } 
      return myLookupKey(token.Header["kid"]), nil 
    }) 

    if err == nil && token.Valid { 
      return true, unparsedToken 
    } else { 
      return false, "" 
    } 
} 

Jednak mam następujący błąd: "token.go: niezdefiniowane: myLookupKey" I wyglądał na internecie i znalazłem enkapsułowana funkcja, która ma ten prototyp:

func ExampleParse(myToken string, myLookupKey func(interface{}) (interface{}, error)) { 
/* same code in my func parseToken() */ 
} 

Jaka jest różnica między moją funkcją a tą? Jak mogę użyć tego?

Dzięki!

Answer 1

Po pierwsze musisz zaimportować bibliotekę JWT w Golang (wejdź na stronę github.com/dgrijalva/jwt-go), a następnie znajdziesz ją w poniższym linku.

https://github.com/dgrijalva/jwt-go

Najpierw trzeba stworzyć symboliczny

// Create the token 
token := jwt.New(jwt.SigningMethodHS256) 
// Set some claims 
token.Claims["foo"] = "bar" 
token.Claims["exp"] = time.Now().Add(time.Hour * 72).Unix() 
// Sign and get the complete encoded token as a string 
tokenString, err := token.SignedString(mySigningKey) 

i po parse że Reklamowe

token, err := jwt.Parse(myToken, func(token *jwt.Token) (interface{}, error) { 
    // Don't forget to validate the alg is what you expect: 
    if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok { 
     return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"]) 
    } 
    return myLookupKey(token.Header["kid"]), nil 
}) 

if err == nil && token.Valid { 
    deliverGoodness("!") 
} else { 
    deliverUtterRejection(":(") 
} 

Ponadto istnieją pewne przykłady dotyczące stosowania JWT w GOlang jak to https://github.com/slok/go-jwt-example

EDIT-1

package main 

import (
    "fmt" 
    "time" 

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

const (
    mySigningKey = "WOW,MuchShibe,ToDogge" 
) 

func main() { 
    createdToken, err := ExampleNew([]byte(mySigningKey)) 
    if err != nil { 
     fmt.Println("Creating token failed") 
    } 
    ExampleParse(createdToken, mySigningKey) 
} 

func ExampleNew(mySigningKey []byte) (string, error) { 
    // Create the token 
    token := jwt.New(jwt.SigningMethodHS256) 
    // Set some claims 
    token.Claims["foo"] = "bar" 
    token.Claims["exp"] = time.Now().Add(time.Hour * 72).Unix() 
    // Sign and get the complete encoded token as a string 
    tokenString, err := token.SignedString(mySigningKey) 
    return tokenString, err 
} 

func ExampleParse(myToken string, myKey string) { 
    token, err := jwt.Parse(myToken, func(token *jwt.Token) (interface{}, error) { 
     return []byte(myKey), nil 
    }) 

    if err == nil && token.Valid { 
     fmt.Println("Your token is valid. I like your style.") 
    } else { 
     fmt.Println("This token is terrible! I cannot accept this.") 
    } 
}