Go 语言 Session机制和 Cookie机制

一、会话机制

会话（Session）跟踪是Web程序中常用的技术，用来跟踪用户的整个会话。常用的会话跟踪技术是Cookie与Session。Cookie 通过在客户端记录信息确定用户身份，Session 通过在服务器端记录信息确定用户身份。

因为 HTTP 协议是无状态的，所以用户的每一次请求都是无状态的。为了解决获知在整个 Web 操作过程中哪些连接与该用户有关，Web 里面经典的解决方案是 cookie 和 session，cookie 机制是一种客户端机制，把用户数据保存在客户端，而 session 机制是一种服务器端的机制，服务器使用一种类似于散列表的结构来保存信息，每一个网站访客都会被分配给一个唯一的标志符，即 sessionID，它的存放形式无非两种：要么经过 url 传递，要么保存在客户端的 cookies 里。当然，也可以将 Session 保存到数据库里，这样会更安全，但效率方面会有所下降。

二、Cookie 机制

Cookie简而言之就是在本地计算机保存一些用户操作的历史信息（当然包括登录信息），并在用户再次访问该站点时浏览器通过 HTTP 协议将本地 Cookie 内容发送给服务器，从而完成验证，或继续上一步操作。

在程序中，会话跟踪是很重要的事情。理论上，一个用户的所有请求操作都应该属于同一个会话，而另一个用户的所有请求操作则应该属于另一个会话，二者不能混淆。例如，用户A在超市购买的任何商品都应该放在A的购物车内，不论是用户A什么时间购买的，这都是属于同一个会话的，不能放入用户B或用户C的购物车内，这不属于同一个会话。

而 Web 应用程序是使用 HTTP 协议传输数据的。HTTP 协议是无状态的协议。一旦数据交换完毕，客户端与服务器端的连接就会关闭，再次交换数据需要建立新的连接。这就意味着服务器无法从连接上跟踪会话。即用户A购买了一件商品放入购物车内，当再次购买商品时服务器已经无法判断该购买行为是属于用户A的会话还是用户B的会话了。要跟踪该会话，必须引入一种机制。

Cookie就是这样的一种机制。它可以弥补 HTTP 协议无状态的不足。在 Session 出现之前，基本上所有的网站都采用 Cookie 来跟踪会话。

Cookie 原理图如下：

需要注意：

Cookie 具有不可跨域名性。根据 Cookie 规范，浏览器访问 Google 只会携带Google 的 Cookie，而不会携带 Baidu 的 Cookie。Cookie 在客户端是由浏览器来管理的。浏览器能够保证 Google 只会操作 Google 的 Cookie 而不会操作 Baidu 的 Cookie，从而保证用户的隐私安全。浏览器判断一个网站是否能操作另一个网站 Cookie 的依据是域名。Google 与 Baidu的域名不一样，因此 Google 不能操作 Baidu 的 Cookie。
Cookie 并不提供修改、删除操作。如果要修改某个 Cookie，只需要新建一个同名的Cookie，添加到 response 中覆盖原来的 Cookie。

Go 设置 Cookie

Go语言中通过net/http包中的SetCookie来设置：

http.SetCookie(w ResponseWriter, cookie *Cookie)

w 表示需要写入的 response，cookie 是一个 struct，让我们来看一下cookie对象是怎么样的

type Cookie struct {Name       stringValue      stringPath       stringDomain     stringExpires    time.TimeRawExpires string// MaxAge=0 means no 'Max-Age' attribute specified.
// MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
// MaxAge>0 means Max-Age attribute present and given in secondsMaxAge   intSecure   boolHttpOnly boolRaw      stringUnparsed []string // Raw text of unparsed attribute-value pairs
}

如何设置 cookie 实例：

expiration := time.Now()
expiration = expiration.AddDate(1, 0, 0)
cookie := http.Cookie{Name: "username", Value: "nill", Expires: expiration}
http.SetCookie(w, &cookie)

Go 读取 Cookie

上面的例子演示了如何设置 cookie 数据，下面的是如何读取 cookie 实例：

cookie, _ := r.Cookie("username")
fmt.Fprint(w, cookie)

还有另外一种读取方式

for _, cookie := range r.Cookies() {fmt.Fprint(w, cookie.Name)
}

可以看到通过 request 获取 cookie 非常方便。

三、Session 机制

Session 是服务器端使用的一种记录客户端状态的机制，使用上比 Cookie 简单一些，相应的也增加了服务器的存储压力。

Session 是另一种记录客户状态的机制，不同的是 Cookie 保存在客户端浏览器中，而 Session 保存在服务器上。客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上。这就是 Session。客户端浏览器再次访问时只需要从该 Session 中查找该客户的状态就可以了。

如果说 Cookie 机制是通过检查客户身上的“通行证”来确定客户身份的话，那么 Session 机制就是通过检查服务器上的“客户明细表”来确认客户身份。Session 相当于程序在服务器上建立的一份客户档案，客户来访的时候只需要查询客户档案表就可以了。

Session 的原理图如下：

注意：

Session 保存在服务器端。为了获得更高的存取速度，服务器一般把 Session 放在内存里。每个用户都会有一个独立的 Session。如果 Session 内容过于复杂，当大量客户访问服务器时可能会导致内存溢出。因此，Session 里的信息应该尽量精简。
Session 在用户第一次访问服务器的时候自动创建。
为防止内存溢出，服务器会把长时间内没有活跃的 Session 从内存删除。这个时间就是 Session 的超时时间。

Session 创建过程

当用户访问Web应用时，服务端程序会随需要创建session，这个过程可以概括为三个步骤：

生成全局唯一标识符（sessionid）；
开辟数据存储空间。一般会在内存中创建相应的数据结构，但这种情况下，系统一旦掉电，所有的会话数据就会丢失，如果是电子商务类网站，这将造成严重的后果。所以为了解决这类问题，你可以将会话数据写到文件里或存储在数据库中，当然这样会增加 I/O 开销，但是它可以实现某种程度的 session 持久化，也更有利于 session 的共享；
将 session 的全局唯一标示符发送给客户端。

以上三个步骤中，最关键的是如何发送这个 session 的唯一标识这一步上。考虑到 HTTP 协议的定义，数据无非可以放到请求行、头域或 Body 里，所以一般来说会有两种常用的方式： cookie 和 URL 重写。

Cookie 服务端通过设置 Set-cookie 头就可以将 session 的标识符传送到客户端，而客户端此后的每一次请求都会带上这个标识符，另外一般包含 session 信息的 cookie 会将失效时间设置为0(会话 cookie)，即浏览器进程有效时间。至于浏览器怎么处理这个0，每个浏览器都有自己的方案，但差别都不会太大(一般体现在新建浏览器窗口的时候)；
URL重写，所谓URL重写，就是在返回给用户的页面里的所有的URL后面追加session标识符，这样用户在收到响应之后，无论点击响应页面里的哪个链接或提交表单，都会自动带上session标识符，从而就实现了会话的保持。虽然这种做法比较麻烦，但是，如果客户端禁用了cookie的话，此种方案将会是首选。

Go 实现 Session 管理

session 管理涉及到如下几个因素：

全局 session 管理器
保证 sessionid 的全局唯一性
为每个客户关联一个 session
session 的存储(可以存储到内存、文件、数据库等)
session 过期处理

Session 管理器
定义一个全局的 session 管理器

type Manager struct {cookieName  string     // private cookienamelock        sync.Mutex // protects sessionprovider    ProvidermaxLifeTime int64
}func NewManager(provideName, cookieName string, maxLifeTime int64) (*Manager, error) {provider, ok := provides[provideName]if !ok {return nil, fmt.Errorf("session: unknown provide %q (forgotten import?)", provideName)}return &Manager{provider: provider, cookieName: cookieName, maxLifeTime: maxLifeTime}, nil
}

Go 实现整个的流程在 main 包中创建一个全局的 session 管理器

var globalSessions *session.Manager
//然后在init函数中初始化
func init() {globalSessions, _ = NewManager("memory", "gosessionid", 3600)
}

session 是保存在服务器端的数据，它可以以任何的方式存储，比如存储在内存、数据库或者文件中。因此可以抽象出一个 Provider 接口，用以表征 session 管理器底层存储结构。

type Provider interface {SessionInit(sid string) (Session, error)SessionRead(sid string) (Session, error)SessionDestroy(sid string) errorSessionGC(maxLifeTime int64)
}

SessionInit函数实现Session的初始化，操作成功则返回此新的Session变量
SessionRead函数返回sid所代表的Session变量，如果不存在，那么将以sid为参数调用SessionInit函数创建并返回一个新的Session变量
SessionDestroy函数用来销毁sid对应的Session变量 SessionGC根据maxLifeTime来删除过期的数据

Session 接口设置值、读取值、删除值以及获取当前 sessionID 这四个操作。

type Session interface {Set(key, value interface{}) error // set session valueGet(key interface{}) interface{}  // get session valueDelete(key interface{}) error     // delete session valueSessionID() string                // back current sessionID
}

以上设计思路来源于
database/sql/driver，先定义好接口，然后具体的存储session的结构实现相应的接口并注册后，相应功能这样就可以使用了，以下是用来随需注册存储session的结构的Register函数的实现。

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, provider Provider) {if provider == nil {panic("session: Register provider is nil")}if _, dup := provides[name]; dup {panic("session: Register called twice for provider " + name)}provides[name] = provider
}

全局唯一的 Session ID
Session ID 是用来识别访问 Web 应用的每一个用户，因此必须保证它是全局唯一的（GUID），下面代码展示了如何满足这一需求：

func (manager *Manager) sessionId() string {b := make([]byte, 32)if _, err := rand.Read(b); err != nil {return ""}return base64.URLEncoding.EncodeToString(b)
}

Session 创建
SessionStart 这个函数就是用来检测是否已经有某个 Session 与当前来访用户发生了关联，如果没有则创建之。

func (manager *Manager) SessionStart(w http.ResponseWriter, r *http.Request) (session Session) {manager.lock.Lock()defer manager.lock.Unlock()cookie, err := r.Cookie(manager.cookieName)if err != nil || cookie.Value == "" {sid := manager.sessionId()session, _ = manager.provider.SessionInit(sid)cookie := http.Cookie{Name: manager.cookieName, Value: url.QueryEscape(sid), Path: "/", HttpOnly: true, MaxAge: int(manager.maxLifeTime)}http.SetCookie(w, &cookie)} else {sid, _ := url.QueryUnescape(cookie.Value)session, _ = manager.provider.SessionRead(sid)}return
}

可以用前面 login 操作来演示 session 的运用：

func login(w http.ResponseWriter, r *http.Request) {sess := globalSessions.SessionStart(w, r)r.ParseForm()if r.Method == "GET" {t, _ := template.ParseFiles("login.gtpl")w.Header().Set("Content-Type", "text/html")t.Execute(w, sess.Get("username"))} else {sess.Set("username", r.Form["username"])http.Redirect(w, r, "/", 302)}
}

操作值：设置、读取和删除

SessionStart函数返回的是一个满足Session接口的变量，上面的例子中的代码session.Get(“uid”) 已经展示了基本的读取数据的操作，现在再来看一下详细的操作:

func count(w http.ResponseWriter, r *http.Request) {sess := globalSessions.SessionStart(w, r)createtime := sess.Get("createtime")if createtime == nil {sess.Set("createtime", time.Now().Unix())} else if (createtime.(int64) + 360) < (time.Now().Unix()) {globalSessions.SessionDestroy(w, r)sess = globalSessions.SessionStart(w, r)}ct := sess.Get("countnum")if ct == nil {sess.Set("countnum", 1)} else {sess.Set("countnum", (ct.(int) + 1))}t, _ := template.ParseFiles("count.gtpl")w.Header().Set("Content-Type", "text/html")t.Execute(w, sess.Get("countnum"))
}

通过上面的例子可以看到，Session 的操作和操作 key/value 数据库类似：Set、Get、Delete等操作。

因为 Session 有过期的概念，可以定义GC操作，当访问过期时间满足GC的触发条件后将会引起GC，但是当进行了任意一个 Session 操作，都会对 Session 实体进行更新，都会触发对最后访问时间的修改，这样当GC的时候就不会误删除还在使用的Session实体。

Session重置

Web应用中有用户退出这个操作，那么当用户退出应用的时候，就需要对该用户的 session 数据进行销毁操作，上面的代码已经演示了如何使用 session 重置操作，下面这个函数就是实现了这个功能：

//Destroy sessionid
func (manager *Manager) SessionDestroy(w http.ResponseWriter, r *http.Request){cookie, err := r.Cookie(manager.cookieName)if err != nil || cookie.Value == "" {return} else {manager.lock.Lock()defer manager.lock.Unlock()manager.provider.SessionDestroy(cookie.Value)expiration := time.Now()cookie := http.Cookie{Name: manager.cookieName, Path: "/", HttpOnly: true, Expires: expiration, MaxAge: -1}http.SetCookie(w, &cookie)}
}

Session 销毁
再来看一下 Session 管理器如何来管理销毁，只要在 mian 启动的时候启动：

func init() {go globalSessions.GC()
}func (manager *Manager) GC() {manager.lock.Lock()defer manager.lock.Unlock()manager.provider.SessionGC(manager.maxLifeTime)time.AfterFunc(time.Duration(manager.maxLifeTime), func() { manager.GC() })
}

GC 充分利用了 time 包中的定时器功能，当超时 maxLifeTime 之后调用 GC 函数，这样就可以保证 maxLifeTime 时间内的 Session 都是可用的，类似的方案也可以用于统计在线用户数之类的。

Session 存储

下面将示例一个基于内存的 session 存储接口的实现，内存的实现请看下面的例子代码：

var pder = &Provider{list: list.New()}type SessionStore struct {sid          string                      //session id唯一标示timeAccessed time.Time                   //最后访问时间value        map[interface{}]interface{} //session里面存储的值
}func (st *SessionStore) Set(key, value interface{}) error {st.value[key] = valuepder.SessionUpdate(st.sid)return nil
}func (st *SessionStore) Get(key interface{}) interface{} {pder.SessionUpdate(st.sid)if v, ok := st.value[key]; ok {return v} else {return nil}
}func (st *SessionStore) Delete(key interface{}) error {delete(st.value, key)pder.SessionUpdate(st.sid)return nil
}func (st *SessionStore) SessionID() string {return st.sid
}type Provider struct {lock     sync.Mutex               //用来锁sessions map[string]*list.Element //用来存储在内存list     *list.List               //用来做gc
}func (pder *Provider) SessionInit(sid string) (session.Session, error) {pder.lock.Lock()defer pder.lock.Unlock()v := make(map[interface{}]interface{}, 0)newsess := &SessionStore{sid: sid, timeAccessed: time.Now(), value: v}element := pder.list.PushBack(newsess)pder.sessions[sid] = elementreturn newsess, nil
}func (pder *Provider) SessionRead(sid string) (session.Session, error) {if element, ok := pder.sessions[sid]; ok {return element.Value.(*SessionStore), nil} else {sess, err := pder.SessionInit(sid)return sess, err}return nil, nil
}func (pder *Provider) SessionDestroy(sid string) error {if element, ok := pder.sessions[sid]; ok {delete(pder.sessions, sid)pder.list.Remove(element)return nil}return nil
}func (pder *Provider) SessionGC(maxlifetime int64) {pder.lock.Lock()defer pder.lock.Unlock()for {element := pder.list.Back()if element == nil {break}if (element.Value.(*SessionStore).timeAccessed.Unix() + maxlifetime) < time.Now().Unix() {pder.list.Remove(element)delete(pder.sessions, element.Value.(*SessionStore).sid)} else {break}}
}func (pder *Provider) SessionUpdate(sid string) error {pder.lock.Lock()defer pder.lock.Unlock()if element, ok := pder.sessions[sid]; ok {element.Value.(*SessionStore).timeAccessed = time.Now()pder.list.MoveToFront(element)return nil}return nil
}func init() {pder.sessions = make(map[string]*list.Element, 0)session.Register("memory", pder)
}

上面这个代码实现了一个内存存储的 session 机制。通过 init 函数注册到 session 管理器中。这样就可以方便的调用了。调用该引擎，请看下面的代码：

// **首先要导入上面的代码包**
var globalSessions *session.Manager//然后在init函数中初始化
func init() {globalSessions, _ = session.NewManager("memory", "gosessionid", 3600)go globalSessions.GC()
}

预防 Session 劫持

session 劫持是一种广泛存在的比较严重的安全威胁，在 session 技术中，客户端和服务端通过 session 的标识符来维护会话，但这个标识符很容易就能被嗅探到，从而被其他人利用。它是中间人攻击的一种类型。

cookieonly 和 token

其中一个解决方案就是 sessionID 的值只允许 cookie 设置，而不是通过 URL 重置方式设置，同时设置 cookie 的 httponly 为 true，这个属性是设置是否可通过客户端脚本访问这个设置的cookie，第一这个可以防止这个 cookie 被 XSS 读取从而引起 session 劫持，第二 cookie 设置不会像 URL 重置方式那么容易获取 sessionID。

第二步就是在每个请求里面加上 token，实现类似前面章节里面讲的防止 form 重复递交类似的功能，我们在每个请求里面加上一个隐藏的 token，然后每次验证这个 token，从而保证用户的请求都是唯一性。

h := md5.New()
salt:="nill%^7&8888"
io.WriteString(h,salt+time.Now().String())
token:=fmt.Sprintf("%x",h.Sum(nil))
if r.Form["token"]!=token{//提示登录
}
sess.Set("token",token)

间隔生成新的 SID

还有一个解决方案就是，给 session 额外设置一个创建时间的值，一旦过了一定的时间，就销毁这个 sessionID，重新生成新的 session，这样可以一定程度上防止 session 劫持的问题。

createtime := sess.Get("createtime")
if createtime == nil {sess.Set("createtime", time.Now().Unix())
} else if (createtime.(int64) + 60) < (time.Now().Unix()) {globalSessions.SessionDestroy(w, r)sess = globalSessions.SessionStart(w, r)
}

session 启动后，设置一个值，用于记录生成 sessionID 的时间。通过判断每次请求是否过期(这里设置了60秒)定期生成新的 ID，这样使得攻击者获取有效 sessionID 的机会大大降低。

上面两个手段的组合可以在实践中消除 session 劫持的风险，一方面，由于 sessionID 频繁改变，使攻击者难有机会获取有效的 sessionID；另一方面，因为 sessionID 只能在 cookie 中传递，然后设置了 httponly，所以基于 URL 攻击的可能性为零，同时被 XSS 获取 sessionID 也不可能。最后，由于还设置了 MaxAge=0，这样就相当于 session cookie 不会留在浏览器的历史记录里面。

四、总结

本文引用了《Go Web 编程》这本书中的内容，参考了astaxie/beego框架，写出来希望能够分享 Cookie与Session 的执行原理以及 Go 语言的实现。

五、参考文章

https://blog.csdn.net/fangaoxin/article/details/6952954
http://www.cnblogs.com/lyzg/p/6067766.html
https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/