ईमानदारी से, प्रमाणीकरण विधियों और तकनीकों का एक बहुत कुछ है जो आप अपने आवेदन में माउंट कर सकते हैं और यह अनुप्रयोगों के व्यापार तर्क और आवश्यकताओं पर निर्भर करता है।
उदाहरण के लिए Oauth2, LDAP, स्थानीय प्रमाणीकरण, आदि
मेरा उत्तर मानता है कि आप स्थानीय प्रमाणीकरण की तलाश कर रहे हैं जिसका अर्थ है कि आप अपने आवेदन में उपयोगकर्ता की पहचान का प्रबंधन करते हैं। सर्वर को बाहरी एपीआई के एक सेट को उजागर करना चाहिए जिससे उपयोगकर्ता और व्यवस्थापक खातों का प्रबंधन कर सकें और कैसे वे विश्वसनीय संचार प्राप्त करने के लिए सर्वर की पहचान करना चाहते हैं। आप उपयोगकर्ता की जानकारी रखते हुए एक डीबी टेबल बनाते हुए समाप्त करेंगे। जहां सुरक्षा उद्देश्यों के लिए पासवर्ड हैश किया गया है देखें डेटाबेस में पासवर्ड कैसे स्टोर करें
निम्नलिखित विधियों में से एक के आधार पर उपयोगकर्ताओं को प्रमाणित करने के लिए एप्लिकेशन आवश्यकताओं को मानें:
मूल प्रमाणीकरण (उपयोगकर्ता नाम, पासवर्ड):
यह नियम विधि आधार में एन्कोड किए गए प्राधिकरण हेडर में उपयोगकर्ता क्रेडेंशियल्स सेट पर निर्भर करती है और इसे rfc7617 में परिभाषित किया जाता है , मूल रूप से ऐप प्राप्त होने पर उपयोगकर्ता अपने डीकोड को डीकोड के साथ तुलना करने के लिए पासवर्ड को फिर से प्राधिकरण और फिर से हैश करने का अनुरोध करता है। हैश अगर यह उपयोगकर्ता से प्रमाणित है तो अन्यथा उपयोगकर्ता को 401 स्थिति कोड लौटाएं।
सर्टिफिकेट-आधारित प्रमाणीकरण:
यह प्रमाणिक विधि उपयोगकर्ता को पहचानने के लिए डिजिटल सर्टिफिकेट पर निर्भर करती है, और इसे x509 ऑर्ट के रूप में जाना जाता है, इसलिए जब एप्लिकेशन को उपयोगकर्ता के अनुरोधों को प्राप्त होता है, तो वह ग्राहक के प्रमाण पत्र को पढ़ता है और उसे सत्यापित करता है जो प्रदान किए गए CA रूट प्रमाणपत्र से मेल खाता है। एपीपी को।
बियरर टोकन:
यह सामान्य तरीका अल्पकालिक एक्सेस टोकन पर निर्भर करता है, बियरर टोकन एक क्रिप्टिक स्ट्रिंग है, जो आमतौर पर लॉगिन अनुरोध के जवाब में सर्वर द्वारा उत्पन्न होता है। इसलिए जब एप्लिकेशन उपयोगकर्ता अनुरोधों को प्राप्त करता है तो वह प्राधिकरण को पढ़ता है और उपयोगकर्ता को प्रमाणित करने के लिए टोकन को मान्य करता है।
हालांकि, मैं
प्रमाणीकरण पुस्तकालय के लिए गो-संरक्षक की सिफारिश करूंगा जो यह रणनीतियों के रूप में ज्ञात प्रमाणीकरण विधियों के एक विस्तृत सेट के माध्यम से करता है। मूल रूप से गो-गार्जियन मार्गों को माउंट नहीं करता है या किसी विशेष डेटाबेस स्कीमा को नहीं मानता है, जो लचीलेपन को अधिकतम करता है और डेवलपर द्वारा निर्णय लेने की अनुमति देता है।
गो-अभिभावक प्रमाणक की स्थापना करना सीधा है।
यहाँ उपरोक्त विधियों का पूरा उदाहरण दिया गया है।
package main
import (
"context"
"crypto/x509"
"encoding/pem"
"fmt"
"io/ioutil"
"log"
"net/http"
"sync"
"github.com/golang/groupcache/lru"
"github.com/gorilla/mux"
"github.com/shaj13/go-guardian/auth"
"github.com/shaj13/go-guardian/auth/strategies/basic"
"github.com/shaj13/go-guardian/auth/strategies/bearer"
gx509 "github.com/shaj13/go-guardian/auth/strategies/x509"
"github.com/shaj13/go-guardian/store"
)
var authenticator auth.Authenticator
var cache store.Cache
func middleware(next http.Handler) http.HandlerFunc {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log.Println("Executing Auth Middleware")
user, err := authenticator.Authenticate(r)
if err != nil {
code := http.StatusUnauthorized
http.Error(w, http.StatusText(code), code)
return
}
log.Printf("User %s Authenticated\n", user.UserName())
next.ServeHTTP(w, r)
})
}
func Resource(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Resource!!\n"))
}
func Login(w http.ResponseWriter, r *http.Request) {
token := "90d64460d14870c08c81352a05dedd3465940a7"
user := auth.NewDefaultUser("admin", "1", nil, nil)
cache.Store(token, user, r)
body := fmt.Sprintf("token: %s \n", token)
w.Write([]byte(body))
}
func main() {
opts := x509.VerifyOptions{}
opts.KeyUsages = []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth}
opts.Roots = x509.NewCertPool()
// Read Root Ca Certificate
opts.Roots.AddCert(readCertificate("<root-ca>"))
cache = &store.LRU{
lru.New(100),
&sync.Mutex{},
}
// create strategies
x509Strategy := gx509.New(opts)
basicStrategy := basic.New(validateUser, cache)
tokenStrategy := bearer.New(bearer.NoOpAuthenticate, cache)
authenticator = auth.New()
authenticator.EnableStrategy(gx509.StrategyKey, x509Strategy)
authenticator.EnableStrategy(basic.StrategyKey, basicStrategy)
authenticator.EnableStrategy(bearer.CachedStrategyKey, tokenStrategy)
r := mux.NewRouter()
r.HandleFunc("/resource", middleware(http.HandlerFunc(Resource)))
r.HandleFunc("/login", middleware(http.HandlerFunc(Login)))
log.Fatal(http.ListenAndServeTLS(":8080", "<server-cert>", "<server-key>", r))
}
func validateUser(ctx context.Context, r *http.Request, userName, password string) (auth.Info, error) {
// here connect to db or any other service to fetch user and validate it.
if userName == "stackoverflow" && password == "stackoverflow" {
return auth.NewDefaultUser("stackoverflow", "10", nil, nil), nil
}
return nil, fmt.Errorf("Invalid credentials")
}
func readCertificate(file string) *x509.Certificate {
data, err := ioutil.ReadFile(file)
if err != nil {
log.Fatalf("error reading %s: %v", file, err)
}
p, _ := pem.Decode(data)
cert, err := x509.ParseCertificate(p.Bytes)
if err != nil {
log.Fatalf("error parseing certificate %s: %v", file, err)
}
return cert
}
उपयोग:
curl -k https://127.0.0.1:8080/login -u stackoverflow:stackoverflow
token: 90d64460d14870c08c81352a05dedd3465940a7
- टोकन के साथ प्रमाणित करें:
curl -k https://127.0.0.1:8080/resource -H "Authorization: Bearer 90d64460d14870c08c81352a05dedd3465940a7"
Resource!!
- एक उपयोगकर्ता क्रेडेंशियल के साथ प्रमाणित करें:
curl -k https://127.0.0.1:8080/resource -u stackoverflow:stackoverflow
Resource!!
- उपयोगकर्ता प्रमाणपत्र के साथ प्रमाणित करें:
curl --cert client.pem --key client-key.pem --cacert ca.pem https://127.0.0.1:8080/resource
Resource!!
आप एक साथ कई प्रमाणीकरण विधियों को सक्षम कर सकते हैं। आपको आमतौर पर कम से कम दो तरीकों का उपयोग करना चाहिए