@@ -32,14 +32,14 @@ type TicketData struct {
3232// SessionStore is an implementation of the sessions.SessionStore
3333// interface that stores sessions in redis
3434type SessionStore struct {
35− CookieCipher encryption.Cipher
36− CookieOptions *options.CookieOptions
37− Client Client
35+ CookieCipher encryption.Cipher
36+ Cookie *options.Cookie
37+ Client Client
3838}
3939
4040// NewRedisSessionStore initialises a new instance of the SessionStore from
4141// the configuration given
42−func NewRedisSessionStore(opts *options.SessionOptions, cookieOpts *options.CookieOptions) (sessions.SessionStore, error) {
42+func NewRedisSessionStore(opts *options.SessionOptions, cookieOpts *options.Cookie) (sessions.SessionStore, error) {
4343 cipher, err := encryption.NewBase64Cipher(encryption.NewCFBCipher, encryption.SecretBytes(cookieOpts.Secret))
4444 if err != nil {
4545 return nil, fmt.Errorf("error initialising cipher: %v", err)
@@ -51,9 +51,9 @@ func NewRedisSessionStore(opts *options.SessionOptions, cookieOpts *options.Cook
5151 }
5252
5353 rs := &SessionStore{
54− Client: client,
55− CookieCipher: cipher,
56− CookieOptions: cookieOpts,
54+ Client: client,
55+ CookieCipher: cipher,
56+ Cookie: cookieOpts,
5757 }
5858 return rs, nil
5959
@@ -145,13 +145,13 @@ func (store *SessionStore) Save(rw http.ResponseWriter, req *http.Request, s *se
145145
146146 // Old sessions that we are refreshing would have a request cookie
147147 // New sessions don't, so we ignore the error. storeValue will check requestCookie
148− requestCookie, _ := req.Cookie(store.CookieOptions.Name)
148+ requestCookie, _ := req.Cookie(store.Cookie.Name)
149149 value, err := s.EncodeSessionState(store.CookieCipher)
150150 if err != nil {
151151 return err
152152 }
153153 ctx := req.Context()
154− ticketString, err := store.storeValue(ctx, value, store.CookieOptions.Expire, requestCookie)
154+ ticketString, err := store.storeValue(ctx, value, store.Cookie.Expire, requestCookie)
155155 if err != nil {
156156 return err
157157 }
@@ -159,7 +159,7 @@ func (store *SessionStore) Save(rw http.ResponseWriter, req *http.Request, s *se
159159 ticketCookie := store.makeCookie(
160160 req,
161161 ticketString,
162− store.CookieOptions.Expire,
162+ store.Cookie.Expire,
163163 *s.CreatedAt,
164164 )
165165
@@ -170,12 +170,12 @@ func (store *SessionStore) Save(rw http.ResponseWriter, req *http.Request, s *se
170170// Load reads sessions.SessionState information from a ticket
171171// cookie within the HTTP request object
172172func (store *SessionStore) Load(req *http.Request) (*sessions.SessionState, error) {
173− requestCookie, err := req.Cookie(store.CookieOptions.Name)
173+ requestCookie, err := req.Cookie(store.Cookie.Name)
174174 if err != nil {
175175 return nil, fmt.Errorf("error loading session: %s", err)
176176 }
177177
178− val, _, ok := encryption.Validate(requestCookie, store.CookieOptions.Secret, store.CookieOptions.Expire)
178+ val, _, ok := encryption.Validate(requestCookie, store.Cookie.Secret, store.Cookie.Expire)
179179 if !ok {
180180 return nil, fmt.Errorf("cookie signature not valid")
181181 }
@@ -189,12 +189,12 @@ func (store *SessionStore) Load(req *http.Request) (*sessions.SessionState, erro
189189
190190// loadSessionFromString loads the session based on the ticket value
191191func (store *SessionStore) loadSessionFromString(ctx context.Context, value string) (*sessions.SessionState, error) {
192− ticket, err := decodeTicket(store.CookieOptions.Name, value)
192+ ticket, err := decodeTicket(store.Cookie.Name, value)
193193 if err != nil {
194194 return nil, err
195195 }
196196
197− resultBytes, err := store.Client.Get(ctx, ticket.asHandle(store.CookieOptions.Name))
197+ resultBytes, err := store.Client.Get(ctx, ticket.asHandle(store.Cookie.Name))
198198 if err != nil {
199199 return nil, err
200200 }
@@ -227,7 +227,7 @@ func (store *SessionStore) Clear(rw http.ResponseWriter, req *http.Request) erro
227227 http.SetCookie(rw, clearCookie)
228228
229229 // If there was an existing cookie we should clear the session in redis
230− requestCookie, err := req.Cookie(store.CookieOptions.Name)
230+ requestCookie, err := req.Cookie(store.Cookie.Name)
231231 if err != nil && err == http.ErrNoCookie {
232232 // No existing cookie so can't clear redis
233233 return nil
@@ -235,17 +235,17 @@ func (store *SessionStore) Clear(rw http.ResponseWriter, req *http.Request) erro
235235 return fmt.Errorf("error retrieving cookie: %v", err)
236236 }
237237
238− val, _, ok := encryption.Validate(requestCookie, store.CookieOptions.Secret, store.CookieOptions.Expire)
238+ val, _, ok := encryption.Validate(requestCookie, store.Cookie.Secret, store.Cookie.Expire)
239239 if !ok {
240240 return fmt.Errorf("cookie signature not valid")
241241 }
242242
243243 // We only return an error if we had an issue with redis
244244 // If there's an issue decoding the ticket, ignore it
245− ticket, _ := decodeTicket(store.CookieOptions.Name, string(val))
245+ ticket, _ := decodeTicket(store.Cookie.Name, string(val))
246246 if ticket != nil {
247247 ctx := req.Context()
248− err := store.Client.Del(ctx, ticket.asHandle(store.CookieOptions.Name))
248+ err := store.Client.Del(ctx, ticket.asHandle(store.Cookie.Name))
249249 if err != nil {
250250 return fmt.Errorf("error clearing cookie from redis: %s", err)
251251 }
@@ -256,13 +256,13 @@ func (store *SessionStore) Clear(rw http.ResponseWriter, req *http.Request) erro
256256// makeCookie makes a cookie, signing the value if present
257257func (store *SessionStore) makeCookie(req *http.Request, value string, expires time.Duration, now time.Time) *http.Cookie {
258258 if value != "" {
259− value = encryption.SignedValue(store.CookieOptions.Secret, store.CookieOptions.Name, []byte(value), now)
259+ value = encryption.SignedValue(store.Cookie.Secret, store.Cookie.Name, []byte(value), now)
260260 }
261261 return cookies.MakeCookieFromOptions(
262262 req,
263− store.CookieOptions.Name,
263+ store.Cookie.Name,
264264 value,
265− store.CookieOptions,
265+ store.Cookie,
266266 expires,
267267 now,
268268 )
@@ -284,12 +284,12 @@ func (store *SessionStore) storeValue(ctx context.Context, value string, expirat
284284 stream := cipher.NewCFBEncrypter(block, ticket.Secret)
285285 stream.XORKeyStream(ciphertext, []byte(value))
286286
287− handle := ticket.asHandle(store.CookieOptions.Name)
287+ handle := ticket.asHandle(store.Cookie.Name)
288288 err = store.Client.Set(ctx, handle, ciphertext, expiration)
289289 if err != nil {
290290 return "", err
291291 }
292− return ticket.encodeTicket(store.CookieOptions.Name), nil
292+ return ticket.encodeTicket(store.Cookie.Name), nil
293293}
294294
295295// getTicket retrieves an existing ticket from the cookie if present,
@@ -300,14 +300,14 @@ func (store *SessionStore) getTicket(requestCookie *http.Cookie) (*TicketData, e
300300 }
301301
302302 // An existing cookie exists, try to retrieve the ticket
303− val, _, ok := encryption.Validate(requestCookie, store.CookieOptions.Secret, store.CookieOptions.Expire)
303+ val, _, ok := encryption.Validate(requestCookie, store.Cookie.Secret, store.Cookie.Expire)
304304 if !ok {
305305 // Cookie is invalid, create a new ticket
306306 return newTicket()
307307 }
308308
309309 // Valid cookie, decode the ticket
310− ticket, err := decodeTicket(store.CookieOptions.Name, string(val))
310+ ticket, err := decodeTicket(store.Cookie.Name, string(val))
311311 if err != nil {
312312 // If we can't decode the ticket we have to create a new one
313313 return newTicket()