mirror of
https://github.com/astaxie/beego.git
synced 2024-12-23 11:40:49 +00:00
236 lines
6.5 KiB
Go
236 lines
6.5 KiB
Go
package session
|
|
|
|
import (
|
|
"crypto/hmac"
|
|
"crypto/md5"
|
|
"crypto/rand"
|
|
"crypto/sha1"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"time"
|
|
)
|
|
|
|
type SessionStore interface {
|
|
Set(key, value interface{}) error //set session value
|
|
Get(key interface{}) interface{} //get session value
|
|
Delete(key interface{}) error //delete session value
|
|
SessionID() string //back current sessionID
|
|
SessionRelease(w http.ResponseWriter) // release the resource & save data to provider & return the data
|
|
Flush() error //delete all data
|
|
}
|
|
|
|
type Provider interface {
|
|
SessionInit(gclifetime int64, config string) error
|
|
SessionRead(sid string) (SessionStore, error)
|
|
SessionExist(sid string) bool
|
|
SessionRegenerate(oldsid, sid string) (SessionStore, error)
|
|
SessionDestroy(sid string) error
|
|
SessionAll() int //get all active session
|
|
SessionGC()
|
|
}
|
|
|
|
var provides = make(map[string]Provider)
|
|
|
|
// Register makes a session provide available by the provided name.
|
|
// If Register is called twice with the same name or if driver is nil,
|
|
// it panics.
|
|
func Register(name string, provide Provider) {
|
|
if provide == nil {
|
|
panic("session: Register provide is nil")
|
|
}
|
|
if _, dup := provides[name]; dup {
|
|
panic("session: Register called twice for provider " + name)
|
|
}
|
|
provides[name] = provide
|
|
}
|
|
|
|
type managerConfig struct {
|
|
CookieName string `json:"cookieName"`
|
|
EnableSetCookie bool `json:"enableSetCookie,omitempty"`
|
|
Gclifetime int64 `json:"gclifetime"`
|
|
Maxlifetime int64 `json:"maxLifetime"`
|
|
Maxage int `json:"maxage"`
|
|
Secure bool `json:"secure"`
|
|
SessionIDHashFunc string `json:"sessionIDHashFunc"`
|
|
SessionIDHashKey string `json:"sessionIDHashKey"`
|
|
CookieLifeTime int64 `json:"cookieLifeTime"`
|
|
ProviderConfig string `json:"providerConfig"`
|
|
}
|
|
|
|
type Manager struct {
|
|
provider Provider
|
|
config *managerConfig
|
|
}
|
|
|
|
//options
|
|
//1. is https default false
|
|
//2. hashfunc default sha1
|
|
//3. hashkey default beegosessionkey
|
|
//4. maxage default is none
|
|
func NewManager(provideName, config string) (*Manager, error) {
|
|
provider, ok := provides[provideName]
|
|
if !ok {
|
|
return nil, fmt.Errorf("session: unknown provide %q (forgotten import?)", provideName)
|
|
}
|
|
cf := new(managerConfig)
|
|
cf.EnableSetCookie = true
|
|
err := json.Unmarshal([]byte(config), cf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if cf.Maxlifetime == 0 {
|
|
cf.Maxlifetime = cf.Gclifetime
|
|
}
|
|
err = provider.SessionInit(cf.Maxlifetime, cf.ProviderConfig)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if cf.SessionIDHashFunc == "" {
|
|
cf.SessionIDHashFunc = "sha1"
|
|
}
|
|
if cf.SessionIDHashKey == "" {
|
|
cf.SessionIDHashKey = string(generateRandomKey(16))
|
|
}
|
|
|
|
return &Manager{
|
|
provider,
|
|
cf,
|
|
}, nil
|
|
}
|
|
|
|
//get Session
|
|
func (manager *Manager) SessionStart(w http.ResponseWriter, r *http.Request) (session SessionStore) {
|
|
cookie, err := r.Cookie(manager.config.CookieName)
|
|
if err != nil || cookie.Value == "" {
|
|
sid := manager.sessionId(r)
|
|
session, _ = manager.provider.SessionRead(sid)
|
|
cookie = &http.Cookie{Name: manager.config.CookieName,
|
|
Value: url.QueryEscape(sid),
|
|
Path: "/",
|
|
HttpOnly: true,
|
|
Secure: manager.config.Secure}
|
|
if manager.config.Maxage >= 0 {
|
|
cookie.MaxAge = manager.config.Maxage
|
|
}
|
|
if manager.config.EnableSetCookie {
|
|
http.SetCookie(w, cookie)
|
|
}
|
|
r.AddCookie(cookie)
|
|
} else {
|
|
sid, _ := url.QueryUnescape(cookie.Value)
|
|
if manager.provider.SessionExist(sid) {
|
|
session, _ = manager.provider.SessionRead(sid)
|
|
} else {
|
|
sid = manager.sessionId(r)
|
|
session, _ = manager.provider.SessionRead(sid)
|
|
cookie = &http.Cookie{Name: manager.config.CookieName,
|
|
Value: url.QueryEscape(sid),
|
|
Path: "/",
|
|
HttpOnly: true,
|
|
Secure: manager.config.Secure}
|
|
if manager.config.Maxage >= 0 {
|
|
cookie.MaxAge = manager.config.Maxage
|
|
}
|
|
if manager.config.EnableSetCookie {
|
|
http.SetCookie(w, cookie)
|
|
}
|
|
r.AddCookie(cookie)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
//Destroy sessionid
|
|
func (manager *Manager) SessionDestroy(w http.ResponseWriter, r *http.Request) {
|
|
cookie, err := r.Cookie(manager.config.CookieName)
|
|
if err != nil || cookie.Value == "" {
|
|
return
|
|
} else {
|
|
manager.provider.SessionDestroy(cookie.Value)
|
|
expiration := time.Now()
|
|
cookie := http.Cookie{Name: manager.config.CookieName,
|
|
Path: "/",
|
|
HttpOnly: true,
|
|
Expires: expiration,
|
|
MaxAge: -1}
|
|
http.SetCookie(w, &cookie)
|
|
}
|
|
}
|
|
|
|
func (manager *Manager) GetProvider(sid string) (sessions SessionStore, err error) {
|
|
sessions, err = manager.provider.SessionRead(sid)
|
|
return
|
|
}
|
|
|
|
func (manager *Manager) GC() {
|
|
manager.provider.SessionGC()
|
|
time.AfterFunc(time.Duration(manager.config.Gclifetime)*time.Second, func() { manager.GC() })
|
|
}
|
|
|
|
func (manager *Manager) SessionRegenerateId(w http.ResponseWriter, r *http.Request) (session SessionStore) {
|
|
sid := manager.sessionId(r)
|
|
cookie, err := r.Cookie(manager.config.CookieName)
|
|
if err != nil && cookie.Value == "" {
|
|
//delete old cookie
|
|
session, _ = manager.provider.SessionRead(sid)
|
|
cookie = &http.Cookie{Name: manager.config.CookieName,
|
|
Value: url.QueryEscape(sid),
|
|
Path: "/",
|
|
HttpOnly: true,
|
|
Secure: manager.config.Secure,
|
|
}
|
|
} else {
|
|
oldsid, _ := url.QueryUnescape(cookie.Value)
|
|
session, _ = manager.provider.SessionRegenerate(oldsid, sid)
|
|
cookie.Value = url.QueryEscape(sid)
|
|
cookie.HttpOnly = true
|
|
cookie.Path = "/"
|
|
}
|
|
if manager.config.Maxage >= 0 {
|
|
cookie.MaxAge = manager.config.Maxage
|
|
}
|
|
http.SetCookie(w, cookie)
|
|
r.AddCookie(cookie)
|
|
return
|
|
}
|
|
|
|
func (manager *Manager) GetActiveSession() int {
|
|
return manager.provider.SessionAll()
|
|
}
|
|
|
|
func (manager *Manager) SetHashFunc(hasfunc, hashkey string) {
|
|
manager.config.SessionIDHashFunc = hasfunc
|
|
manager.config.SessionIDHashKey = hashkey
|
|
}
|
|
|
|
func (manager *Manager) SetSecure(secure bool) {
|
|
manager.config.Secure = secure
|
|
}
|
|
|
|
//remote_addr cruunixnano randdata
|
|
func (manager *Manager) sessionId(r *http.Request) (sid string) {
|
|
bs := make([]byte, 24)
|
|
if _, err := io.ReadFull(rand.Reader, bs); err != nil {
|
|
return ""
|
|
}
|
|
sig := fmt.Sprintf("%s%d%s", r.RemoteAddr, time.Now().UnixNano(), bs)
|
|
if manager.config.SessionIDHashFunc == "md5" {
|
|
h := md5.New()
|
|
h.Write([]byte(sig))
|
|
sid = hex.EncodeToString(h.Sum(nil))
|
|
} else if manager.config.SessionIDHashFunc == "sha1" {
|
|
h := hmac.New(sha1.New, []byte(manager.config.SessionIDHashKey))
|
|
fmt.Fprintf(h, "%s", sig)
|
|
sid = hex.EncodeToString(h.Sum(nil))
|
|
} else {
|
|
h := hmac.New(sha1.New, []byte(manager.config.SessionIDHashKey))
|
|
fmt.Fprintf(h, "%s", sig)
|
|
sid = hex.EncodeToString(h.Sum(nil))
|
|
}
|
|
return
|
|
}
|